{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "64bf446c",
   "metadata": {},
   "source": [
    "# Hugging Face + YOLOv5n для детекции автомобилей\n",
    "\n",
    "В работе используется **маленькая модель `fcakyon/yolov5n-v7.0` с Hugging Face** как стартовая точка для дообучения на датасете **Car Object Detection**.\n",
    "\n",
    "Почему выбрана именно эта модель:\n",
    "- она компактная (`YOLOv5n`) и подходит для сценариев, где важен компромисс между скоростью и точностью;\n",
    "- это **anchor-based** детектор, поэтому для него можно осмысленно подбирать **anchors**;\n",
    "- модель предобучена на **COCO**, где есть классы дорожных сцен, в том числе автомобили.\n",
    "\n",
    "Ниже реализованы:\n",
    "1. локально-совместимая подготовка датасета;\n",
    "2. дообучение модели с подбором `anchors` и `imgsz`;\n",
    "3. расчёт `Precision`, `Recall`, `mAP@0.50`, `mAP@0.50:0.95`;\n",
    "4. измерение скорости инференса, `FPS` и задержки на **CPU/GPU**;\n",
    "5. автоматический краткий вывод о компромиссе **точность–скорость**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0383c958",
   "metadata": {},
   "source": [
    "## 1. Кратко об архитектуре YOLOv5n\n",
    "\n",
    "**YOLOv5n** — это облегчённая версия семейства YOLOv5. Архитектурно модель включает:\n",
    "- **backbone** для извлечения признаков;\n",
    "- **neck** (FPN/PAN-подобная агрегация признаков разных масштабов);\n",
    "- **anchor-based detection head**, который предсказывает координаты рамок, objectness и класс объекта на нескольких масштабах.\n",
    "\n",
    "Для выбранной задачи это удобно по двум причинам:\n",
    "1. модель изначально быстрая;\n",
    "2. anchors можно адаптировать под реальные размеры bbox в датасете автомобилей."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01a7ccb5",
   "metadata": {},
   "source": [
    "## 2. Установка зависимостей и клонирование YOLOv5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2d4ecd52",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Cloning into 'yolov5'...\n",
      "\u001b[33mWARNING: Ignoring invalid distribution ~ulsectl (/home/konnilol/.pyenv/versions/3.12.12/lib/python3.12/site-packages)\u001b[0m\u001b[33m\n",
      "\u001b[0m\u001b[33mWARNING: Ignoring invalid distribution ~hirp (/home/konnilol/.pyenv/versions/3.12.12/lib/python3.12/site-packages)\u001b[0m\u001b[33m\n",
      "\u001b[0m\u001b[33mWARNING: Ignoring invalid distribution ~ulsectl (/home/konnilol/.pyenv/versions/3.12.12/lib/python3.12/site-packages)\u001b[0m\u001b[33m\n",
      "\u001b[0m\u001b[33mWARNING: Ignoring invalid distribution ~hirp (/home/konnilol/.pyenv/versions/3.12.12/lib/python3.12/site-packages)\u001b[0m\u001b[33m\n",
      "\u001b[0m\u001b[33mWARNING: Ignoring invalid distribution ~ulsectl (/home/konnilol/.pyenv/versions/3.12.12/lib/python3.12/site-packages)\u001b[0m\u001b[33m\n",
      "\u001b[0m\u001b[33mWARNING: Ignoring invalid distribution ~hirp (/home/konnilol/.pyenv/versions/3.12.12/lib/python3.12/site-packages)\u001b[0m\u001b[33m\n",
      "\u001b[0m\u001b[33mWARNING: Ignoring invalid distribution ~ulsectl (/home/konnilol/.pyenv/versions/3.12.12/lib/python3.12/site-packages)\u001b[0m\u001b[33m\n",
      "\u001b[0m\u001b[33mWARNING: Ignoring invalid distribution ~hirp (/home/konnilol/.pyenv/versions/3.12.12/lib/python3.12/site-packages)\u001b[0m\u001b[33m\n",
      "\u001b[0m\u001b[33mWARNING: Ignoring invalid distribution ~ulsectl (/home/konnilol/.pyenv/versions/3.12.12/lib/python3.12/site-packages)\u001b[0m\u001b[33m\n",
      "\u001b[0m"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Готово.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[33mWARNING: Ignoring invalid distribution ~hirp (/home/konnilol/.pyenv/versions/3.12.12/lib/python3.12/site-packages)\u001b[0m\u001b[33m\n",
      "\u001b[0m\u001b[33mWARNING: Ignoring invalid distribution ~ulsectl (/home/konnilol/.pyenv/versions/3.12.12/lib/python3.12/site-packages)\u001b[0m\u001b[33m\n",
      "\u001b[0m\u001b[33mWARNING: Ignoring invalid distribution ~hirp (/home/konnilol/.pyenv/versions/3.12.12/lib/python3.12/site-packages)\u001b[0m\u001b[33m\n",
      "\u001b[0m"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import subprocess\n",
    "from pathlib import Path\n",
    "\n",
    "os.environ[\"WANDB_MODE\"] = \"disabled\"\n",
    "\n",
    "if not Path(\"yolov5\").exists():\n",
    "    subprocess.run([\"git\", \"clone\", \"https://github.com/ultralytics/yolov5\"], check=True)\n",
    "\n",
    "subprocess.run([sys.executable, \"-m\", \"pip\", \"install\", \"-q\", \"-r\", \"yolov5/requirements.txt\"], check=True)\n",
    "subprocess.run([sys.executable, \"-m\", \"pip\", \"install\", \"-q\", \"huggingface_hub\", \"scikit-learn\"], check=True)\n",
    "print(\"Готово.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d9e892c",
   "metadata": {},
   "source": [
    "## 3. Импорт библиотек"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9162820d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "import time\n",
    "import json\n",
    "import shutil\n",
    "import random\n",
    "import subprocess\n",
    "from pathlib import Path\n",
    "\n",
    "import cv2\n",
    "import yaml\n",
    "import torch\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from tqdm.auto import tqdm\n",
    "from sklearn.cluster import KMeans\n",
    "from sklearn.model_selection import train_test_split\n",
    "from huggingface_hub import hf_hub_download, list_repo_files"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66a504fb",
   "metadata": {},
   "source": [
    "## 4. Настройки эксперимента"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5126d7a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WORKDIR: /home/konnilol/Downloads/work_hf_yolov5n_car\n",
      "DEVICE: 0\n"
     ]
    }
   ],
   "source": [
    "SEED = 42\n",
    "random.seed(SEED)\n",
    "np.random.seed(SEED)\n",
    "torch.manual_seed(SEED)\n",
    "\n",
    "# Можно задать путь вручную. Пример:\n",
    "# MANUAL_DATA_ROOT = Path(\"./car-object-detection/data\")\n",
    "MANUAL_DATA_ROOT = None\n",
    "\n",
    "WORKDIR = Path(\"./work_hf_yolov5n_car\").resolve()\n",
    "WORKDIR.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "HF_REPO_ID = \"fcakyon/yolov5n-v7.0\"\n",
    "\n",
    "IMG_SIZE_CANDIDATES = [512, 640]\n",
    "PILOT_EPOCHS = 5\n",
    "FINAL_EPOCHS = 40\n",
    "BATCH_SIZE = 16\n",
    "VAL_SIZE = 0.2\n",
    "DEVICE = \"0\" if torch.cuda.is_available() else \"cpu\"\n",
    "\n",
    "print(\"WORKDIR:\", WORKDIR)\n",
    "print(\"DEVICE:\", DEVICE)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64c75fd8",
   "metadata": {},
   "source": [
    "## 5. Поиск датасета на локальной машине"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ac8d2c1c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DATA_ROOT: /home/konnilol/Downloads/car-object-detection/data\n",
      "DATA_FORMAT: csv\n"
     ]
    }
   ],
   "source": [
    "def resolve_data_root(manual_root=None):\n",
    "    candidates = []\n",
    "    if manual_root is not None:\n",
    "        candidates.append(Path(manual_root).resolve())\n",
    "\n",
    "    candidates += [\n",
    "        Path(\"./car-object-detection/data\").resolve(),\n",
    "        Path(\"./car-object-detection\").resolve(),\n",
    "        Path(\"./data\").resolve(),\n",
    "        Path(\"../input/car-object-detection/data\").resolve(),\n",
    "        Path(\"../input/car-object-detection\").resolve(),\n",
    "    ]\n",
    "\n",
    "    for p in candidates:\n",
    "        if not p.exists():\n",
    "            continue\n",
    "        if (p / \"train_solution_bounding_boxes (1).csv\").exists() and (p / \"training_images\").exists():\n",
    "            return p, \"csv\"\n",
    "        if (p / \"images\").exists() and (p / \"labels\").exists():\n",
    "            return p, \"yolo\"\n",
    "\n",
    "    raise FileNotFoundError(\n",
    "        \"Не удалось найти датасет. Укажите MANUAL_DATA_ROOT вручную.\"\n",
    "    )\n",
    "\n",
    "DATA_ROOT, DATA_FORMAT = resolve_data_root(MANUAL_DATA_ROOT)\n",
    "print(\"DATA_ROOT:\", DATA_ROOT)\n",
    "print(\"DATA_FORMAT:\", DATA_FORMAT)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4771dffb",
   "metadata": {},
   "source": [
    "## 6. Загрузка исходной модели с Hugging Face"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "62d9c3f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Скачанные веса: /home/konnilol/.cache/huggingface/hub/models--fcakyon--yolov5n-v7.0/snapshots/e63eb5a3061a09a639094279fd5082bc51d8a019/yolov5n.pt\n"
     ]
    }
   ],
   "source": [
    "repo_files = list_repo_files(HF_REPO_ID)\n",
    "pt_files = [f for f in repo_files if f.endswith(\".pt\")]\n",
    "if len(pt_files) == 0:\n",
    "    raise FileNotFoundError(f\"В репозитории {HF_REPO_ID} не найден .pt файл.\")\n",
    "\n",
    "weight_filename = sorted(pt_files)[0]\n",
    "hf_weights_path = hf_hub_download(repo_id=HF_REPO_ID, filename=weight_filename)\n",
    "print(\"Скачанные веса:\", hf_weights_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a74461cb",
   "metadata": {},
   "source": [
    "## 7. Подготовка train/val в формате YOLOv5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "abf64a61",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Подготовка train: 100%|██████████| 284/284 [00:00<00:00, 456.96it/s]\n",
      "Подготовка val: 100%|██████████| 71/71 [00:00<00:00, 467.43it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train images: 284\n",
      "val images: 71\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "def ensure_dir(path: Path):\n",
    "    path.mkdir(parents=True, exist_ok=True)\n",
    "    return path\n",
    "\n",
    "dataset_dir = WORKDIR / \"dataset_yolo\"\n",
    "for split in [\"train\", \"val\"]:\n",
    "    ensure_dir(dataset_dir / \"images\" / split)\n",
    "    ensure_dir(dataset_dir / \"labels\" / split)\n",
    "\n",
    "def copy_file(src: Path, dst: Path):\n",
    "    if not dst.exists():\n",
    "        shutil.copy2(src, dst)\n",
    "\n",
    "def write_yolo_label(label_path: Path, rows, image_w, image_h):\n",
    "    lines = []\n",
    "    for _, row in rows.iterrows():\n",
    "        xmin, ymin, xmax, ymax = float(row[\"xmin\"]), float(row[\"ymin\"]), float(row[\"xmax\"]), float(row[\"ymax\"])\n",
    "        x_center = ((xmin + xmax) / 2.0) / image_w\n",
    "        y_center = ((ymin + ymax) / 2.0) / image_h\n",
    "        w = (xmax - xmin) / image_w\n",
    "        h = (ymax - ymin) / image_h\n",
    "        lines.append(f\"0 {x_center:.6f} {y_center:.6f} {w:.6f} {h:.6f}\")\n",
    "    label_path.write_text(\"\\n\".join(lines), encoding=\"utf-8\")\n",
    "\n",
    "if DATA_FORMAT == \"csv\":\n",
    "    csv_candidates = [\n",
    "        DATA_ROOT / \"train_solution_bounding_boxes (1).csv\",\n",
    "        DATA_ROOT / \"train_solution_bounding_boxes.csv\",\n",
    "    ]\n",
    "    csv_path = next((p for p in csv_candidates if p.exists()), None)\n",
    "    if csv_path is None:\n",
    "        raise FileNotFoundError(\"CSV с bounding boxes не найден.\")\n",
    "\n",
    "    df = pd.read_csv(csv_path).copy()\n",
    "    df.columns = [c.strip() for c in df.columns]\n",
    "\n",
    "    # Нормализуем названия колонок\n",
    "    name_col = next((c for c in df.columns if c.lower() in [\"image\", \"name\", \"image_id\", \"filename\"]), None)\n",
    "    if name_col is None:\n",
    "        name_col = df.columns[0]\n",
    "\n",
    "    rename_map = {name_col: \"filename\"}\n",
    "    for src, dst in [(\"xmin\", \"xmin\"), (\"ymin\", \"ymin\"), (\"xmax\", \"xmax\"), (\"ymax\", \"ymax\")]:\n",
    "        if src not in df.columns:\n",
    "            raise ValueError(f\"В CSV не найдена колонка {src}.\")\n",
    "    df = df.rename(columns=rename_map)\n",
    "    df[\"filename\"] = df[\"filename\"].astype(str)\n",
    "\n",
    "    image_dir = DATA_ROOT / \"training_images\"\n",
    "    all_images = sorted(df[\"filename\"].unique().tolist())\n",
    "\n",
    "    train_images, val_images = train_test_split(\n",
    "        all_images, test_size=VAL_SIZE, random_state=SEED, shuffle=True\n",
    "    )\n",
    "\n",
    "    for split_name, image_list in [(\"train\", train_images), (\"val\", val_images)]:\n",
    "        for filename in tqdm(image_list, desc=f\"Подготовка {split_name}\"):\n",
    "            src_img = image_dir / filename\n",
    "            if not src_img.exists():\n",
    "                # Попытка добавить .jpg, если в CSV хранился stem\n",
    "                alt = image_dir / f\"{filename}.jpg\"\n",
    "                if alt.exists():\n",
    "                    src_img = alt\n",
    "                    filename = alt.name\n",
    "                else:\n",
    "                    continue\n",
    "\n",
    "            dst_img = dataset_dir / \"images\" / split_name / src_img.name\n",
    "            dst_lbl = dataset_dir / \"labels\" / split_name / f\"{src_img.stem}.txt\"\n",
    "            copy_file(src_img, dst_img)\n",
    "\n",
    "            img = cv2.imread(str(src_img))\n",
    "            h, w = img.shape[:2]\n",
    "            rows = df[df[\"filename\"].isin([src_img.name, src_img.stem])]\n",
    "            write_yolo_label(dst_lbl, rows, w, h)\n",
    "\n",
    "elif DATA_FORMAT == \"yolo\":\n",
    "    image_dir = DATA_ROOT / \"images\"\n",
    "    label_dir = DATA_ROOT / \"labels\"\n",
    "\n",
    "    image_files = sorted([p for p in image_dir.iterdir() if p.suffix.lower() in [\".jpg\", \".jpeg\", \".png\", \".bmp\"]])\n",
    "    paired = []\n",
    "    for img_path in image_files:\n",
    "        lbl_path = label_dir / f\"{img_path.stem}.txt\"\n",
    "        if lbl_path.exists():\n",
    "            paired.append((img_path, lbl_path))\n",
    "\n",
    "    train_pairs, val_pairs = train_test_split(\n",
    "        paired, test_size=VAL_SIZE, random_state=SEED, shuffle=True\n",
    "    )\n",
    "\n",
    "    for split_name, pairs in [(\"train\", train_pairs), (\"val\", val_pairs)]:\n",
    "        for img_path, lbl_path in tqdm(pairs, desc=f\"Подготовка {split_name}\"):\n",
    "            copy_file(img_path, dataset_dir / \"images\" / split_name / img_path.name)\n",
    "            copy_file(lbl_path, dataset_dir / \"labels\" / split_name / lbl_path.name)\n",
    "\n",
    "else:\n",
    "    raise ValueError(\"Неизвестный формат датасета.\")\n",
    "\n",
    "train_img_count = len(list((dataset_dir / \"images\" / \"train\").glob(\"*\")))\n",
    "val_img_count = len(list((dataset_dir / \"images\" / \"val\").glob(\"*\")))\n",
    "print(\"train images:\", train_img_count)\n",
    "print(\"val images:\", val_img_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9aac99a",
   "metadata": {},
   "source": [
    "## 8. Визуальная проверка примера"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b70d183d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxoAAAHdCAYAAACaMg93AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs/WuwLclVHop+I6vmnOu51352t1ottQQGgcVDYflwb3BsbMtcAQYLHbAtKxzBBQegMIQQ8vVFYcDmaTCGCCSDbQQYwQVdI4cwBIQxYKRAx5jjEweMhWVJIMRtoUdL3bt79957rb3WmnNW5f2ROTLHyEdVzdUtsM1MqfeaVZWPkZkjx/jGyBdZay22YRu2YRu2YRu2YRu2YRu2YRuewWD+uAnYhm3Yhm3Yhm3Yhm3Yhm3Yhv/5wtbQ2IZt2IZt2IZt2IZt2IZt2IZnPGwNjW3Yhm3Yhm3Yhm3Yhm3Yhm14xsPW0NiGbdiGbdiGbdiGbdiGbdiGZzxsDY1t2IZt2IZt2IZt2IZt2IZteMbD1tDYhm3Yhm3Yhm3Yhm3Yhm3Yhmc8bA2NbdiGbdiGbdiGbdiGbdiGbXjGw9bQ2IZt2IZt2IZt2IZt2IZt2IZnPGwNjW3Yhm3Yhm3Yhm3Yhm3Yhm14xsPW0NiGbdiGbXiGwrd+67eCiCbFJSJ867d+68eXoD/h4dd+7ddARPi1X/u1P25StmEbtmEb/kSGraGxDduwDdvwP2B4//vfj52dHRARfvM3f3Pj9P/iX/wL/PW//tfx3Oc+F0SEL//yL5+U7qu+6qtARPiiL/qip03fr/7qr+IlL3kJjo6OcHh4iBe/+MV4y1veksX7+Z//efyZP/NnsLOzg+c+97n4lm/5FqzX60n0bsM2bMM2bMMfX9gaGtuwDduwDc9Q+OZv/macnp7+kZT12te+Fm3bXjj993zP9+Dtb387XvjCF07O5zd/8zfx4z/+49jZ2Xna9L3pTW/CS1/6UsxmM3zXd30Xvvd7vxef8zmfgw9+8IMq3r/7d/8OL3/5y3H58mX8wA/8AF7+8pfjO7/zO/HqV796lIbP+ZzPwenpKT7ncz5nvHLbsA3bsA3b8IyHi2upbdiGbdiGbVChbdunBf6nhl/+5V/GL//yL+MbvuEb8J3f+Z0XyuMd73hHmM04ODgYjW+txdd93dfhy77sy/C2t73tadH3yCOP4Gu/9mvx6le/Gm94wxsG8/p7f+/v4TM+4zPwK7/yK6FtL126hO/6ru/Ca17zGnzKp3xKNa0xZpJRtA3bsA3bsA0fn7Cd0diGbdiGbRgJb33rW0FEeMc73pF9e+Mb3wgiwrve9a7iHo3z83O89rWvxY0bN3B4eIiXvexl+NCHPnRhWlarFV7zmtfgNa95DT7xEz/xwvk8/PDDk/eTAMBP/uRP4l3vehf+0T/6R0+bvh/6oR9C13X49m//dgDA8fExrLVZvHe/+91497vfja/+6q9WBtzXfM3XwFqLt771rYO0lPZo/MW/+BfxaZ/2afit3/otfPZnfzZ2d3fx/Oc/Hz/0Qz+Upf/ABz6Al73sZdjf38d9992H1772tfjlX/7l7b6PbdiGbdiGiWFraGzDNmzDNoyEL/zCL8TBwQH+9b/+19m3t7zlLXjhC1+IT/u0Tyum/cqv/Eq8/vWvx0tf+lL843/8jzGbzfCFX/iFF6bl9a9/PW7duoVv/uZvvnAem4a7d+/ida97Hb7xG78RDzzwwGDcKfT96q/+Kj7lUz4Fv/iLv4iHHnoIh4eHuHbtGv7BP/gH6Ps+xPvt3/5tAMCf/bN/VqV/8MEH8dBDD4Xvm4Zbt27hr/yVv4IXv/jF+Cf/5J/goYcewt/5O38HP/ZjPxbinJyc4CUveQl+9Vd/FV/3dV+Hb/qmb8Jv/MZv4HWve92FytyGbdiGbfiTGLaGxjZswzZsw0jY3d3FX/2rfxVvfetb0XVdeP/Rj34U73jHO/CKV7yimO6d73wnfuqnfgpf8zVfgze/+c342q/9WvzMz/xM1SgZCx/96EfxHd/xHfiO7/gOXLp06UJ5XCR8+7d/O3Z3d/Ha1752MN5U+t73vvfhgx/8IL7iK74Cf/tv/2289a1vxRd8wRfgO7/zO/FN3/RNId6jjz4KAHjWs56V5fGsZz0LH/nIRy5Un4985CN43etehx/4gR/Aq1/9arztbW/Di170Ivz9v//3sVqtALiZqj/4gz/Av/pX/wrf/d3fjde85jV4xzvegfPz8wuVuQ3bsA3b8CcxbA2NbdiGbdiGCeEVr3gFHnvsMbVk5q1vfSv6vq8aGr/4i78IAPi6r/s69f7rv/7rL0TD6173OnzCJ3wCvvIrv/JC6S8Sfu/3fg9veMMb8L3f+71YLBaDcafSd3x8jFu3buHbvu3b8O3f/u340i/9Urz5zW/G53/+5+MNb3gD7t69CwBhY32p3J2dnQtvvG/bFq961avC83w+x6te9So89thj+K3f+i0AwC/90i/h2c9+Nl72spepMr/qq77qQmVuwzZswzb8SQxbQ2MbtmEbtmFC+PzP/3wcHR2p41ff8pa34EUvehE++ZM/uZjmAx/4AIwx2V6FF7zgBRuX/5/+03/CT/7kT+L7v//7Ycwfneh+zWteg8/+7M/Gl37plw7G24S+3d1dAMArX/lK9f6Vr3wlTk9Pw5IojleaRTg7OwvfNw0PPvgg9vf31Tvuw0ceeQSA67tP/MRPzPax/Kk/9acuVOY2bMM2bMOfxLA1NLZhG7ZhGyaExWKBl7/85fjZn/1ZrNdrfPjDH8Z//I//sTqb8UyHb/iGb8Cf//N/Hs9//vPxyCOP4JFHHsHNmzcBuCVGf/iHf/iMl/n2t78dv/RLv4TXvOY1ocxHHnkE6/Uap6eneOSRR3Dnzp2N6XvwwQcBAPfff78q77777gPg9lAAcckUL6GS4dFHHw35bMM2bMM2bMN/n2F7vO02bMM2bMPE8IpXvAI/8RM/gbe97W14z3veA2vtoKHx8MMPo+97vP/971ezGL/7u7+7cdl/+Id/iA984AN4/vOfn3172ctehqOjIzz11FMb5ztWJgB8yZd8Sfbtwx/+MJ7//Ofj+7//+/H1X//1G9H34he/GO973/vw4Q9/GJ/wCZ8Q4vGeixs3bgAAXvSiFwFw93d81md9lor3oQ99CF/91V99oXp95CMfwcnJiZrV+L3f+z0AwPOe9zwAru/e/e53w1qrZjV+//d//0JlbsM2bMM2/EkMW0NjG7ZhG7ZhYvjcz/1cXL16FW95y1vwnve8B5/1WZ9VBNYcvuALvgDf+I3fiH/6T/8p/tk/+2fh/etf//qNy/7hH/5h3Lt3T717+9vfjh/4gR/A933f9w3eJ3HR8JKXvAQ/+7M/m73/6q/+ajz88MP4pm/6Jnz6p3/6xvS94hWvwE//9E/jX/7LfxmOy+37Hm9605tw9epVvPjFLwYAvPCFL8SnfMqn4Id/+Ifxqle9Ck3TAHC3mhMR/tpf+2shz9u3b+PRRx/Fs571LBwdHQ3Wa71e441vfCP+7t/9uwCA5XKJN77xjbhx40Yo+/M+7/Pw7//9v8fP//zP44u/+IsBuOVaP/IjPzK9AbdhG7ZhG/6Eh62hsQ3bsA3bMDHMZjN8yZd8CX76p38aJycn+L7v+77B+C960Yvwyle+Ev/8n/9z3L59G5/92Z+Nt73tbRfyir/0pS/N3vEMwV/4C38hOwJ2LPzCL/wC3vnOdwJwd1/8zu/8Trhc72Uvexk+4zM+A8997nPx3Oc+N0v79V//9bj//vvx8pe//EL0ffEXfzH+8l/+y/ju7/5u3Lx5E5/5mZ+Jn/u5n8Ov//qv441vfKPa/P293/u9eNnLXoaXvvSl+Jt/82/iXe96F37wB38QX/mVX4lP/dRPDfF+9md/Fl/xFV+BN73pTfjyL//ywbo/+OCD+J7v+R488sgj+ORP/mS85S1vwX/5L/8FP/zDP4zZbAYAeNWrXoUf/MEfxCtf+Uq85jWvwbOe9Sy8+c1vDhcAbnIHyTZswzZsw5/UsDU0tmEbtmEbNgiveMUr8KM/+qMgIvyNv/E3RuP/2I/9GG7cuIE3v/nN+Lmf+zm85CUvwb/9t/8Wz3nOc/4IqK2Hn/mZn8FP/MRPhOff/u3fDpuwH3roIXzGZ3zGx61sIsLP/dzP4Zu/+Zvxlre8BT/+4z+OF7zgBfipn/op/K2/9bdU3C/6oi/Cv/k3/wbf9m3fhle/+tW4ceMGvvEbvxH/8B/+wwuXf+XKFfzET/wEXv3qV+NHfuRHcP/99+MHf/AH1YlSBwcHePvb3x5uLz84OMCXfdmXhY3x2xvHt2EbtmEbxgPZ0nWs27AN27AN27AN/4OHt73tbfjcz/1c/If/8B/w5/7cnwPgbga/efMm3vWud10oz9e//vV47Wtfiw996EN49rOf/UySuw3bsA3b8D9d2J46tQ3bsA3bsA3/UwY+rer69esXSp/e03F2doY3vvGN+KRP+qStkbEN27AN2zAhbJdObcM2bMM2/DGGruvw+OOPD8Y5ODjAwcHBaF7L5RJPPvnkYJyjo6ML3z/xP0o4OTnBm9/8ZrzhDW/AQw89VL3nZCx8yZd8CZ773OfiRS96EW7fvo2f+qmfwnvf+168+c1vfoYp3oZt2IZt+J8zbA2NbdiGbdiGP8bwwQ9+cPDkKgD4lm/5Fnzrt37raF6/8Ru/gb/0l/7SYJwpm6X/Rw+PP/44Xv3qV+PTP/3T8aY3venCFxx+3ud9Hn70R38Ub37zm9F1Hf70n/7T+Omf/uk/srtTtmEbtmEb/kcP2z0a27AN27ANf4zh7OwMv/7rvz4Y5xM+4RPUfRO1cOvWLfzWb/3WYJwXvvCF4SK8bdiGbdiGbdiGj2fYGhrbsA3bsA3bsA3bsA3bsA3b8IyH7WbwbdiGbdiGbdiGbdiGbdiGbXjGw+Q9Gq9804dhrYWb/3AXFbkLiwiw7rnve5WGiEBE4EkTi85/sSACiNwtry5fC5ebTlMK/M34uBx62ECj9TQOrc3ltGlZIc/Ce34j0/BvIgNA1NdaR5WvmzEm1M0m+ap2Em1cqD3g65nRq367etsu7xPOxf21Sbq0fn3414r21nX0dQBAY/Nj1vVxiBaa2gqqND1pWaX6lGl3BTpeo8BnMq21FrAEKrS3rJsgP+uakKevW4nGtH61usn2lXwRymBaaLw9imOIsynRX6E78CvF9yX+lLSX+JNJ6/vKeBPtw7KEANhe8BgJWeM6FsYYVWZKx0XvVSv1f0p32nbGNLHNKmM05ssvEOoK+Sort9JPLI+LdVAE+0i19kdOs00zkWmsGvCuPfoqnZFaAyefyjIn5Rf+lstrKffyupTqU+pLR3eB0qT8Uv5pPqFNLMAyOKU71o/zogKv5HSPLT6Q+Sq5YijJQ8gicuNDlY8mycu97b22ICI0Gbf1Tv5ndWMWStvPJHyn+Ub2Va39Ir31dgCAvu/g9ADVeYAJTfIZLVs+EwV96jLMtYERb4wxsOhhbR/4O8UrWbl2GM/o+vWAH/K1VDUZJfNLZauOp2VAmq5Kp0doQ3GGfkedG7FVHpf5So+1mtxpmhwjACmGdPlZx+zFepLNSohFQ+vVEj8q/Gn78pgqYNOabJJYizE2k0MDgE3qfB7DJPAUl/v//r+PK9jJhkbsAF1Z15nD6WJwArTaIBYYVlI6p0iDULQefEzMpkKHFLr6fSlbzcT6vbU8sIaVVM7gw533dG+lJfjBklSorsyeXnkhF983haJRe6vSFsKwsIxxyuDXC54i0NAKm3ntabBWNdQAUErHxyMUhWUq3Aq8PxX4+NhhLGxKUxUcjtARFV5f/F4rr0x/Hl/+HTKGxwvPdPXHic+0/A5vJ4DoqWFMHwyNtxJdQ+PCP6myP57hmWmfFCyQolvrkotzwLDMyPNW5WbJWL9SACt5DJ3npjw1VcaNGRlpUPjg6erMsfTBGZTT4F5HQyTU18dlJ+QIBZPoTMcN45bxsVR/X6WNNuPTIX0yWA44ma4bY6taPqmhlI63sTKn0HORMOT0EA/Fpt20zID1kndPJwQsZMs6JQ3TT53yXt+C3RAfCxaXeON+B+uwBA7HgUtgNG9uscONiAAy7o1F0VNfA6SpRzQtM01b+g4IOaMGggHPaKh0vrZlRi4LxtipQ0J8RHCQLD2nNw/sKRiOQaEPBrISFAqVlOSfZtAXvxEZ7/WmAriRbdSAQW6pLBoQlEqoDQAoqTTS8cG5l4w6AM7bKMv0/5hEUE4Bnk9HkQ6n9QAj6Ycxr5WMw+2fCqZpYN49274wa4HYT3XlWAfX5fibh4sq8ch+m9OT1iGq0iqRg/ltUnYsifmXSzeFYkoOFN1fNaOiRJfkgShZLWwGOqxS1lawA0PnQB3FmpToHjP6o5zwNJGNjq80DqSu4PIp0BhBu8wTkllkyRm1lp15REUDNk3nmslEOZoBMSmtSUWQursM+dJ45d9D/Z+O71QnTwHF48bGMACdaqykfV6MQ44/pB6PThFtiGSyIjR3oQzOkwgWPCM8LoMG6azEzfGEDkP96fCb4+UaX0ylzReWlu7jlHS2NDi05i3zk0U+5hBmwHhIWl9exTYo5DtBPzhgu5FuCTSTHo95nXSvybYqOt18pHweelqYbGiE6RZuAy694qUMTBreWAe6VRtmIztkPq0yFKy1KB8jA6fT7UMdS0RhuUZNkQxNV8Up6bRz03YoD2BNa3yXxx+yILUSQKnOFrCj65uSXIUBUWyDgrFZnWUIg9Py4wZ0yCfHT0AYj5V4gOQJTZs0WkfKBoFMXck5/kDeNXLAFIFCQrA3WDIFMTAgxkBQGKj+54bd75ORoGF8TI3mV0yXC0MfOfxJ+arEZ3J2oWSAPB26ayEdu+n74cR5907poqLczcr3BYgX2uieDtKKNAigX4pf83gNgTqddoAG9Y4CFST5VHiNRbScgESGDRkTQ3okSjWKZRT4r0oHopMsOMAKNEwOxf61gk91nYazF2Mp5bMB51XQWhfp44z2PO9N0xfzrEDypyvfMmOB2zAZqCVP/Tgtibwk8TtNt6kXvCIX8hkimzHNpJnhRBWWjMgalsgxTaluAhEOtKt7tCoLaTxnZKfp4WapyOfl6EvboOxUKdWvVN5Q2nKIul7XsxBFtY2OT5D2LAHJyoAhx0IaphsamVCP67YHPUHJr9AxCTjKOzAPyqMvQXwB3A01Qa2Da7TINDzlN9bZzHCqJqnFPDJA67Qz/WNLQqKXprbsS+Y7aIwJyWBt9LgD5b6qtk3QOv7RCu9LURHlWUSjrhkuCxI0aOHIbReMlLGmJ1J1LpcRn4fomKq7GLRMARrjCtFVUjoApk7BagA1XOYU4DBFecs2tdbCEBU81kLZIbatrBYv75xafm7wX8AqGykji3PB6fdypuEf38dpBG6PiwEoVZRUlgHUT8s3n+MV+fI/FhnvO50znfapQJGUfEDGR2PG/BhIBOoAbEgfld6PhRzEaJljpZdwgN48X/9PYjtSkrnUb4m45xTxjRWvEv4pGRScckgmlkH+CJgrRaGkHF+nLL34nWVRAKYlOuVfafzIBspKLlRNO4Q03SEn7kKuX8E5UXRXeay3iUFXHzd6hmpIRkcZH2Ff/GoBw/ymKlyWFaR7K9rbNsBKnSTlreQb5T1DqR4K9JJ+5v4u5l92OMr6W5FHGGuJY4WS+tZCjEb6b1JfXjGURhsLF7iwz68lFMuBuDJhA2dx1JaDZD61ltGWGDrZuEbDQnITD0F1GnYgvyEFIQUct9dUdVEDAkODttjjxG1pizOtKa2jAAwIjhO1ab9UdC0v0cdusEjrO/bBRdY+pspVe19iHCKCPrdAq666kVRSYOnnafw4Nj56rT1QVDSFfMtKNtc8djDHhErm3zBGCnkitu2UZUnpc54m8QyxsiECetlXEhCWjY3J0lDQFZVbnrY+a8Q0xLym87FOH4274XFZDaLZdBum5Y2TJflE84CMZrwDSRSOAu3WGxkDxYfU4fCMvkjyKKgTj6P9UFTq5ecL9cdAvvL9mDc4a06ht4b1XQrmvBQvTG9WDSWRNIW/YcylSC0fjEF/uDxtzNyzxVg7s2EwNrJ4E690yA3VjcxIv47oBQAB7CnPs1CRXH7XWzRNjiEizdYvU5F5y3ZlqhEzLxgBbDTYRA5I+RJsPltfokvGveeF70OybUzW87vUuI8h7S+JMQqHe2Rijap9NcQzTZD5hTFR2E1fU6/uVeTQkiHi2q7Pxi3nW2paXZ4N+CkzxLJ2tclfCHknLf1EZibPrhgKxo4uYzg8rZvBWQ2nbSIhNYWYqMQWmfFPG2MqHqoC7U2DpmNowFAah+obu4lYeMtO00o6gLEsXZqXUelKcSWQLHrfhB1dY4cxRikaghXjpBZX5ZcTgKIXZkSQWVvikDx+NH71gOZlCZ7YgXJKIK0WN/4OFE3JO3kfaiKM0xrPqZB4tmzQ3r6t0o0izJ+aeZjw3JtsI4/X6C4FDdqng6w03+gprY8J+Tx9hnBa3ClhquDV8YgRCsCG0gZ5DeadGsVEGbsPlsMOLNb3lPBQjBYjIcrwAnWQX0rtPwRUJJ+k8nUojDmaxlDr5H4VWU0DXHk5Sn4MxB0KZe9xWSaX8s1lmIOZJUccA5Yhw6D4vuAA4frXHBE1p0qtTCmvpsjlWpjS/8ybpX4PmjqI1z44U9V/AHor9rIFQ7Ck79Lx4GSH1kW+vEL/TOHP7H1Q1TbIqVLcofHmnJYUiNNQNxZCMl2oh2iF8Drn55xfys4hKUIGNJjoN0lBzeGUOmNK8Yb4T8rCJHfZFtKY9ekkBlGiOpWVBazicyi2Q+A+k7ZTzpOlsIGhIYBvrRjZqaofWBBVquGPbCMZPWSZC4cpgz7vhChwnMdBlpF7kTZR8WkZmrkjcPBSgEdCVq/0OEQOChSrMuPxwMUm4QFHBaEuyq4JdV0Wd2h9gEw2ALPB01TK1OUpQTXQQRKApPmmxtK4pzMObKlIysotr1yqCOI0+bCidDX3bUAu89rGTgXSdAzHAz4vSgSk8ljwQxDoWqG7epf5c1rIAQKH+rgurXeFmyqvCcqQV/kUl03WhNfCJukmxZUoZCL+GTXMUmSj4sgIeVqVr1DwlL5EIj8IAOWyKiunQNdwO0XwMgSY63xUpmdoqagEFxsFytON8UD8HOtpEf26uT7KeXgaT5bXj0f9XKaXSOvLNM80DLer10W2AH5J9rEsv5zXELDXfyOdtTSlcmqzRTVa0jzCO0D4WVyeDdwRwSTlmBX6mssMDV82MtJ66jrruLVxOaU9pM5VS9/FvzLdkG6rXTkQnSuJlSSzZ/1JYgloVkTEDVLPKhqCPmRsVCgr1Ef8DpqxdvjBsLMs+VL5ZgOfkJjhksSU8AshriKLGj+X5U5MD+hGKvUqx/H0qXo25eqJ8HG6sG98EMu4lDQeDVRU5jc2+HOBOpzXlDw3C1HppHnz9Cr/598W6L54eKby4eDqUGeZj095dUVa76+Yxhgz8ejAmKfMe5KX5+MQ8unWC+bD9RiOhOABia9C+tLfi4ZNQTr34VA+NcW2yXguAoSBvv94GynlaJuA8z+6IMERgIyXsvA0225obE4dv4p2/NG1ZUrTM1HuIKifaPjUjAwZ4ZloIiK6uDDDtLE5NY9N022SnwxRvUfZ1LQ5OItLx4GmGQdvm4TSWJD4I70DrRSsNw6fLh3j3+T4GM9vWp5pmlLk4bJK5U41QEvvjRkeU0PG2hT6iu8HvpXSOeM1/mfC783w8uQZDdM0GhRT9NRHmBxNJjY23QfrGDQ88/q8snKXFrae+aE4WPk3V9Ra9AWQkTJvPtMRSyktfUnjqHr50Ad6cl7V+wT0RS0xGGDC1Gaab5pPCWSV3vV9r5YU1ZStZHT3m9TvGKd+OVkpkPB6km9QPaii94ZCg0dvvO4/KSClwRZPpNLf9DOJDg28HJSu/1vw7qd1tTYXwaVn1V9Jee6d9FDoMVLLmSKhwUMWZ0740AaKY6bkqSMoRajyTZ7HBGAN+PO3Ke9CTYMHpVxOWkak2Y6MZySdPc3LKcsrfZPjakpIxy8xq2PM2MgkjX83zi+lODXwq+RXmmvSDvq5pEQ179dCLndyWmR5aboaj9XSOXq0seTihcQJ9RnBUbWJf4dCqoOi3PMlSXlC+br51PTO65w72WR/5KBTgzstp4zfK5v3M19cBhjwXohmwBnlqKEic9eAS8pnJX6r8QyXWJWZQ3ROjFOXQ1LHpBRRxlAhH/J5WT7NSPdNDG7Mp/lHjCaPWI5tN16v0gEa/n2B3lIdIn35/hinhkryQZarR1TMJJ15s4iYQKaLY4rE+FQSiLRu1/3F9z6538Yf221BIV8+xEb3o8C2Pq3SqwU6a/wR2lyNW9/nJd4SxaR6KMJg2a7pmIh/cxFJfiHBxUzNyYaGtHjJg5YezhKOzCvBjehg4rWDRlj3G3oFfe3VwE4EvElAczpAS9NoYS2kz4VpznzAg1NN/Md6BiGlOErGRknQDwH9vDnKceXvGoCTbVOip9wvSsQMCplav+q25nelgZYaNDJdqdyYl8gZUggns4IJzT5/a9VZ+9IwmNIHWQGFQiuQ2X9LjIyKsOf2yWgoAqhScVMmfXMeKvHcJt6WofE+VI5NrTEMLV/Ly5AySqUjQv2Ck6cfxtqnOF78eKhcZ1XNQ+uyOs+67y6vKX2nZEXlO8DNOF5XpNP5xTjl5ylhSAbVZG85HvIKD6UrCyH/atr6eCkfSei7rKiiEZeSY+BAXnTQlHuwHJQeBZ8UGWXikLE9ZtTJOFpfj+e9SSgbwHVaNy2zFjcDd0i058B44mCt3ww+olO5zepEAhFA5zq+zJv6b1oLJYlHHIz5mJN6OYLpUpr0XakM54eSJ+lVjL2kfhILkvfQxXc5iI9twj+GDFc2NhIHOyb0l6DWxS2NIU9rWm4F/wYYlZWR49ISnewAc+OfBuV8LUyf0TAUvKN2gHlTUM1/5frwKYIeyAdB2qgoMHmJHs7LhdyKI/Z+x7dZeuLInEvi6bMeIeRgrTYQC4pGvLaaP8E2NODXFwrQpGc3pBFgK22Q9E0R2HlAGwZwqQ4lBi0vEYvfh4FQ/k0IA/HeKbwhhi9Z6xXFU1AM6vuEwMDAJu/SthkEnsLTV5C/o0FFFxcBpvuiSmZGyQgcM1hlnLLaLPO+aqNirnkZNW/5lOWRPDYyeQJsfKdMpGHaNx7XUxUnEFVj+KKilPtuMyNO9Cvy/kgNn2h9F+pAMV1KmhujJZrrQDmXReNAZuhdJkcqvFwGW/W8x4y48rdynxd5kyIHlOuIjI4c4DKtRXKydONx/BHfvmMlUOsD1w7nrZtH8kHF/KTc52wL36YY9LXnKWHMqNBB69tSv8c61Mu0fnyR0sNCOrjBKuQ7O1ASSkbrn2K5gfGp4qbSwyqHKUO0Esbg2ZqUPMde1pVDsRwiPY5lPgHZJdhTyrIaX+b4snz8d5Rl+fhK8wyOduRtrZ/HdE8++xGdl+U8SDRqmFsh5oNc2muZofmIgvFlRfxxHFMK0zeDByIpeDX4XgFeihMZiq1WimTHf1RHPZMCYkjpjDVMDXypOiT5yhkNmd7CGQND4Cz30iZlRDwQhnNqfBRroZRsXu7Yb2lkpMYPodaOz4zgLva3FQ0BqZQ185fpSgHYwEZAQxPat067+DgKjqbkFQREVi8NRooJs3y1Fz9Vd+kytiE6q+PIpvzUqxkhFTWrSYnm+rdNgH7NuA7vKnE2CakhnRDkvgs5MmRkyLEWYcVwGAdBOYhlOa4N93ycSaLSozzUDFzQZroe8ccFx0FVTtVbJvdgb6ZHanRIp0k9j2nrrsffX2xPhAMCMQ/9d5OxUzLGEAFupDKWMNlgkWQlHJXo3IAmomVVzHMq8JkqR2pxprVfvt8hHfPsmCwGCSaJkrEZBLzPx/0rHQi5hK3LmxTk10IA4ZHIYhr3LHVz3t42GBk2gGGVh5gFGJIededNTCPvvirFr8mUmt6iQt8WKONMBnDOFH71SDKw/vAhOLoMX38wrwm6yikU3ojlWPWXx/+mxsZkQ6PrOt8xfmMtURA81lGYDAYb6LOw4IsLTNNEAJs13PTpfFbezLRDAry4VIm/T22rIqiLjK0UkAfrevCXkubTVSknlTxCcnlWcUCIGQyi+ikPtcD9y+X5zIreEX4nxV6aV8aUQXskdLOBg1hvAYOSdKXBmr6j7HdNsETDL33HyrvIAKHvJZhUMRKAfhGQUwpU4D2tNfw/Nf72Y3YsZK0p+jKACyvGU1qkL6dWUs3ocEk3BwKlUDsMoCYsh4yVUvohGizq5dRooGrfTOOdGv2lGZ0q7YXxkFPDS2rqsndMn25iNF4klMDzJuCiFG+4nHo/bxbiKW9p+QFIFXVF2UDwvwpGSC3IvCYs1ZLyOSv/mZF5tVB1aKRjMzZcTIdxx8dUUFU1bLPvOu9BmkUOqfNIyf4RelIVER2KcUxEXSXBdLq8adyQdumjforp9FjU0E/zd6zWeLszvgmwACzbtN5Vw0Ngljhya7IsxXaxruV4jgJuN40BUkepDmV+0N80P8W9iAoLE0Ijxi4YcoJWDEdoqMYUsNNpKnyevnQq+Nh6p2D6uPma0GDWyKyYnLge1zRO2ceLyITVGrgfQbimS26yQBS8AuqIOJc4oaTcIKxLZfqpCiXoYZQUNh99VjoWkJQCkel64SOsCiUrGMcHaUjwVGUUWFqQ1NtVAFfE9koBchEwD4CttNze9qrtVPDCz4LEZsce0hrXN0vw3zioazMAJXBR7u988A0pZTZQZF5TQO3myqtYepZX3GNCKpqqv8w7W7Kh+1nGtzFS8qzjKAEv4/n8SzW6CBQZMrJVeRVgOZTPRUPezwWbgXimULdF1g+sOIQZX7cb63VQ/OGV3QQbAOlsYlqWOuayxkMEUHJbqNPDw21e9wSOg/56eil3a6Aupi8VU6pnEmMUlA+ndyFnmaQN/WPp6HNNjc/N64IUDA8bWlT5XYhLEfikxFOSRsKfklzM6jCMbPVfH6oOvIzuOEBLkqlmEJTiRX1rIBuBZNlJX9WWV0XAzklLzsIyusl4BXycK/OAG7sahJNKENsv3XcaMUa9TAs2lKVDTMGzzJDQQNdULk8clHPIOdbGQ6LVe9Z7ss/rfU0geZxulRZ9qW3qfHDdX6Cn0JZWNZJ2EKS9G9oMifGkuxRyabYFxBaIitGT0Ma6PVaprMtLYbKhsbOzg/V67YSziQSv110AMlWB4QEmALd2PGXsmEgaYsmnymZpVmYT66Ho5N4QhkYNUG+21z52Pk04Vz4EgWvTNGOe01CyElQaeNfpkBzJfTDN4k7fldIqkGNRvGUTCHYGpA2tjSZdptUyahJ98pnzrTXLJgB0yMiYMpuRCTlrs4EwBpiH8t7UQGQGDnJlgBaomPr7JuAw5b1Jhj87MzZwFiRFhpxS2qfQUVI2xIbEYLz8m54VrW8ETpcspfFqho5U+jU6SDgyMpmu4ro32fIpkc7VA14+izrScHtMCXGclD6C0RDUUp9ACzLje7AMRFmxCd1T427Ks7VyqnlQNCyzWa2RsrVsHwB/jPKIgE4vL4nSnPOJdGVlDALY8dn5or6gacvZpsOmOn2yTJfnSLwJ+UUsUfuWzxaU8k2TDxlR4wZ1DoJLslSlyPBhNFxintPHWK3OWs4lfVvDikRuuXuMFvJU+UyUGaksLNE8xOsRlyQGs37lHsWsh4xXo5W8ABySOAqH8DsIE5oIZO2khWTABobGrSdv4t7pKZbLNYgIs9kMOzs7WCwW2NnZw3w+x3K5jOCWBbNxcyHo3ZWC/SBpfsotUUxlAV+yxIQBMeFUK8UUqRfmaQp/JiT2l7AixkIimVM6cpu4UjpRFmvIo2vtxY4uEyInCBC23COYl8ZdBsM8HVw+r0t1UVl/Ma05AGTlM5Xtk9JJjacL5iFF09MP0wB6LPNCm5oT4VmaxZD0bLr8a0iBlXj6Amre/SdPjprYkZsC3Y2NvBIOfro8Jlro6WU1BCxymaEoKHwabEtCNqNxkZ7W5RnhFe1VjlI3Mz4gIU9ToyuAndEynx7NmwZCwVhN/gIFwwFxLETcJ3OqgY+nd6VWEOsFHVIDdvmrYSNjMi1ZPkzcQJoLlZQHyU1TDZca4I9OyqF8hOyrvZtQ/ykSRRoHY+nG+04C6KELIZNUGb+XWycD21ImjFD1RzvSXSjLVWAaxf6W+ZhyUpk11ETim5IcwnjmEqZKjcmGxv7eAfb2D4OSlRehrVZrnJycYLVaYb1eh43hs9kMi8UCu7u7WOzuoG1bnJ7dw7pb1wvyiiGA14oXiSub6TBAeaskQEq9Ida/s72FGfFWlYTXFOWUAmQn0MtLmNiKZfugaAmLP2ZktoRIK5DarEhoo4Kni9u/ZpWn7yVgSdeGcz59MBJzAcvZlfZraDpYmJeXodVDXg+uegqCa8C63G953NoswKQZDheh/j2lKXhupsX3LzOPW80QHfOE5oa5jpv+VsatnMJPgMpQG+lJnwgcp4xj2fcyTW1cxjLLdzlk7ecYKpqCgd2n9Sl56zfnPZfHILYvAq1CPPFR9bEt97n28A3zqFLwAp+UbqSdGiQ9RE5RlJZlqXjhfVxXLOMi9FAO1jbRB+MzfsOhFN8m3zSoysep029qUASdIpeQ5B7QMtCN/R37sgQ1Y9SoZ1V7eNlPMmollBx8teVFMr68N0DVQyx5meK0kfmPLelK38tlM5xjyXhimqVe3ITXdCjRmAP3NIsyDgi/KjRMMyrG94TqOx4i9BgfM4ypIk/WNJ+mV437Qp9Yb+xY9AJTFHQJ06kaOHg9Et7kPAKpFXlqRPzocuOZ+tg2Ahgj7uHi9jPF9nODNu09SYYR/cB3r0hcIJfbuuxsiDBVzE0/dco0AYxLqNf3FmQMFjs7mM/nwrvtmcIYrLsO53fvou97nJwc4/x8CQuLWdtif/8Ae/t74Q4MEnKSBVbf92jbFn3fq8FMrl0QzvYNwizWntOY9KZNP4Xf95275t3Guz/glbwNA8IEopjJiQh23cEYg9726GwPoiYQ1jN4BYUz5i05Fh4Cd6yHDRmEdZQkZjFEz/bJs5zkiXn3VUEVAbWL4y5kie+NFND+N+eV3qvCsyF8crsFgQzvn4lcQUQwytDgHRlW5C+5KJaTKwrK5EtIbyXoKzZR3h4xk/J7VUb5Xe/3MMW0FBzuwXSiuNxHKqMhkJ/SzYAqAkWjlD3HYh6qARnZCwj+UKs8FWFWSiANC+RXUKhnnx9ZZzz4MWOIsC6AMjeWywZYCXxwESlAjOariFSpu2NprnF8VzI4iwAICHf5lNJLJaEmXfKa5PX2fZvFJW1kjPGOAx0lw4QyeqNxw8SndLECHA7SZ5HZgSI/6UlrCsC9DrCEwVCIQl4GZzNAiRxg+UHwpwRCGplSZsn2je1dMqATSvw3rhPCc81ZoZwqfZyt0ZuthwAwARRXa7NCtZQ72QB/069qxNLY9DxOeRwN/n2/UgRPLnYfdKsBqfuuih2Y1kiAca9K41gyvicNzwH1jtCgGiI4k9gg4jXx7HW71gN+lDCZ4aPe8BydVRovhBJJt7ICy5mMjqDOhEx9TCvTwztbHHZRLUqxDeSppl4cFaSmXimh5JgKBKI+1qcYJz1QPZahZ9EjpsrHSgkPFPiV9VJmVFjxG3G5dmiroI1Fja3HJvIiPtFSor/iK7ncXr6LvWE9T5LRNLkOsl7v2RBbthnzZdizYkVB4MN+SMaOsi8k6b1G70MJgf8IYsLT0xH4wwIw4DtGYHsYEuYMkc9z/Bb7yYZG07Ta2ycsHWPK+yc4vgSlbTuDMY3Ps0HTNDDkZkdWyyXOzs6wWq3Q9z2aNpK3v7+P2Wzmqu87hpfnyE0uuuMFcLFi8zoLLSV7Ceg9AzLQ9oaOtX3RSufTFZzgpJBNEBQosY9QJCmwkvSpdowCIqNBpdfjPnizhOck0p6ehhBaMishAw0DQXuEpXKMNBESRWO1wtKO8ZTGmgD0eSUtnc54Ze8IsN46ynKtlFNVjdKwYWRJAMHkiVR5UsjGIT6kgm0SJ67dr6eqAXZ9yKDNuMDVRN5ULIhQjFniH5J6sk5bhc5Rz3ChXdWYKEYKUX0ZUHJNllviu6rhozzp4q/AKxxvNIzUu+RJLY8RBsqFPJK/6UOUQfrNlNlNydOl+EPGVsnIyNo8BQGFfPJ+LwgDJlIAUh3SMSUAxIBhXH5f+12JL/5KW08CmjSPQFv4RSh3tPguaBrkE+JZoXp9I9iRfBHlcpp9yltpfvKdNISDvvXKUVXfxsNYpGGmeELKMInIcyUQCc2MvFhu/FsG4DW5WJ5l8SBY6mhRpo4nZqdqfMjPQT3JNojlBwiT6GtAYimo9h4TzzKPmHehNUq8GcrRmlLGDUZGYYg6Uh0fSAzD1Q5HDBPAm721sVagMcNimh/iu0hTnhcbOdymVryXzxBtLYyUihzRxAIgobWtNJ74O9S7cl6Cpj7SPg0NxjDZ0Cgp17qS0c9sUBARdnZ3wJ7N3lr0XResK2st1us1lstzZaA0bYOu69C0DfquQ9d17pvt0TQN2nZePcKSm6XzMxscxxgj9ou43rRiOoWNH3lHiJzuTJVhYwx67j3Sm1pdW0EIqrJiKbV5+K0+FCqZi/ByPgUh3nWdUpppX0vwP6Zca9+Gl3iNx4805GAmhgp/UjlVf0FhWQWKBAT/X5AIWrllbTtedFCwuZK+AB9liqPejzrYzJjJwHyQQfW+rsmQeqkhYtlr779x3qOGSTFEwUkot5d8LsoZZWSMlHYhGstp6zMZ+bupS0GGl5iUyxkqM/t2wXYabrfh5WRDIV1KxGWl9Zva1kMhemjH06Xju9Se4+WLmUj/zICbiJBu7RrSofJ73RGgQQgl5UbAnDrTcrkwpAcCcAyilSDErGhnfqMyEYCN5XM+a1kc64F3KeufWijHy9svG9sSqFaA3ZhDhduFrOyLPD/dH3m8aFgQwiKdSrWrhrd6W96XUZUZijZ9AlTJeA2ppzqsfHba8GYmC58nhj5AMsa2OockJ2XYKXICZigFQ5HmHB2wMeOfYoMEvpZjxNrSEjRNL7crFb6NhcmGxnq9zgaeRe6tSgVE9h2AtR3WvWcAQ4Dt0Xc92tbg6OgQwKEzRowJ93es+w7n56e4d+8ezs+dITJrWuzs7GBvr1XLrNggsH4Wg2dC2Bhho4cBdtM0cYmVMW6JmHUAHEBh2RYF+kqh1PT67nGr3sr2qSl5tTmnBFYrCiOcMZ0oiFLcGi2BIScasaV6yHW7U4GMz03Q5wbPWHqSkkbEjY41yr4NGc2S78fW+abLEBTlqcIR7TvaJpTkXBCgY86A+vspQpj3ywDpNFFGekGh1mhgI8rJhbw/mN9LwbA8AdAXlBPPuE4JNeVYnAGKVneBtvKzjDY0W5Mb+Hmb5GNzWh2mAtRNHAObgV5kYFN9G8kn75PyTDqHqWNBll6KUpaP9XXoNXkqyyqVk+qXoTynjWsOWgfIv8RAZUT+OPlVkGFZ+QreZOXxMp8U1JT4aBBshk+xrKDzBLDLed/zEMmyNL3VshUIHKNxen9VDSqmKLnRucTj0lCIHwFCSUYBum88nsnaSu+liDzPveeXBY0BA2/nEqlaZGSV5FtaXzWDA3FvhCpP7tfxr9K6Ze2VH1+raON6DIiQqLMC0Mi+Z/VSeRZkvYmNJskLXGsBngHJeEj86gXduXxxdS9O6OkKRFpGxmgapt+jkcwYKAY3hMY08fhb/y62m/vR9z3YhaKAeh9nL/SdELEBjTH+hCu3qbwxDbq121TedRanp9EIYQOBiLDY2cGNGzewWCzUZnU2NrjzeXM7AFgx+8EDsWmaYLwwTWl7BKGVdAabt0MDaBMvogStgBCTg57kep7lZWFxAFgrvdmadskHcsYnBUMyfgAbA7NgIyPa/UnSjSn41Oov1WnUKy5mFkjSyTSgJGJsiKKXMghh5wdxPHerXI9JRlZG8jBolJ8zmwGAW/NtAYqnwo2yq+Wo5RaRtLKxkXwMSsQ5NKAbRbLKCCGDJ+pw5qmuKvCUXhaoa0WCJ8dE7xjIn/I8HYxvVn4tzhRPek0/bFr2prRtkveQMR7HQn7fhM6/PKs1HhTHFGlI6RkL40ZNAlAKeT8TMzWcJg7TYSOvuMgyoY2Bn5bR1dJDmWwUORCW1lfQKEWTT7AJjyv5DxTFk4pT6BcJfIMMVDTXnQS1fsucfHDeb7kigCjqId3eknqdb+lZ6bNK4OV2uYhPDEGVlfvloMkArkHWrJm7LwsUly2FVyZv09D6QY+F5MV2DvVIjNDxsSQdJ6oi4RuVvrOsgnZk5vR4rpf8rrDWCHlJfhGzMF4Zz2D6ZnD0HnzyrIV762YNeqzWazRhw7XY5keaEWQeTLhpTADy0kggcgC/6zpl6HRdF2ZYmNN2d3ext7cXqfXGwnyxwHK5xJNPPomTkxOcnZ2FtIeXD3H//Q8AIHSdxXrtjR1KWZXQddFK5j7SRlEfdv1z01N4Lp2kkw/c2vKlGlOnIQog3d7uW6zLcFrnPXE0uPo5A9Evd+v15vJMWCR5Uoluv/mehWuPHMQ1FEVB+jetybBNwoyKgmHhc7GF+MgFubX5BGX4xlXzdba+gND+pcgkiOc0pfhJfS6+RGgksDISAj/3kUw0iIE4XZ/wL+eiliEm6S0gRFgKXYThRsMUldopNTu4rLEQjGnOodgHFzti+eMZpsqPWng6aVM6gDIXfRy4eVK9ywBKg4o/jlCTQ1OBsJbLdf4u2NgDQY6U+mw+YXhMFZenJM/ur3dMWiUw8wKZNPHOwQKjjA0N2tJ61cFaiU4psS7EIiz2JWlSHxABfQ8pBUt0RDwmzl/MmkjwQQHsb0LyNFgZ4wsuVmVGWslJTBJgOH4KOdT1ocRbYwQVDGFRRihTfErzpIw+ibHq8i2kCX+ntqJe1hnvQJeo0uSGEytxn7ZB5PIgF5jmtFMLpAW2BETllDk9GDbaoyEBcCr8ijMepEngTdV93weDwqUzcT+Gn2ngZVCTrEIby0zj84lVly5dwt7eXqwDLGDcqVPHx6e4c+cuzs7O0DQN9nZ3sb+7h8VigbZtMZ/P1T4GuYyKaZTGE9RsiKYx9dao9krqKcF/+F2ofpqX/lZXRmnZ8RnBag/x/W9eAjXZqyjqUFw65aVfMd0oSAi/BuOFKFbTF70hVvVPycArApZU6LuIIe+cxvqyEZ1JWRDJtFOXhUgwX4svjedx6y3yr+bZtC2s8HbZrF03CwR15jWrCsoNv3TcWRvjx5eeHQoALjWMS4q9twPLf7KjuCo1Uob9eLxamGp0pgbqFCCbljOFnlK5WV4jcTd1sGxa/tR3MSQodqS8enuWeWNqm47FKxkZz2wZ41BTOnZKbhn2iI4tPXK8Wii+QlGZpLS9UxmVAJQRrJGNWUallSGv8ilVJgN3tXKLr0MZoU0Tg0plLUnml6q+RWQRflm5xEF+YZxakCdMV013SlJCO8bP8WPFGJbgV6mv4vguZVD/lvWWok1Tnnet3n+kP5EwZLxey5KLfJWeZceAlsXyX12HqH+DQ6GCq/JDIypjVwz/TUTzRns05KZuKcz42Nt13ylhJwdmCszbtvXOCn20W0lAtv70qa7v+KVSnPL27V6kt4h7S4wxYsaFM3fAeW9vHzs7u5G2pkFr3AzLvXv38Pjjj+P09BRt22J3d9fdC7JYoJ3PsFyt4JZeNej9Ui5pdFnbASivw2S/jxVr3uuCXlihgXzhVQqdn56Rnt+1MXVZhV4+hiK4SnkhDfFUuZpXKs6OuYt76sZlxiMmrYuO7+g3/CDGWBRNARiKAZ8aeENALAVwPPq4ljbkFSks3v0S8m68MOq1kE6EdskIVW0DAyKWK8NLAniWcTjkykgKOveVp8hZqlmVhmJHZ3ULfwX9XG7oIsXYDFasMlRTuTMlOIUYaamlc4cfWlF23h+R38I/KodUH0w1EmRZ/G7qOO79bNnYuKqVWfv+TM10pDQM8epQulr8spHkNaYBAlqq5LOZF1iv9Y6/2WGheXQq7UNhrL2IEsNYi7tiunId5TjLjXhNB/xR7gxg6oso835JQK0CVFbEc5Kn2h8k05bjaN02zYGWj6NkXA/2cZlUT67+XcSEfnWBdY4W4jwtwKdgEiVtGsAhyy5Z31IdxdH1LNm9PIub4K2O47uMkF6+auGOOE/rGcdkA1dPDRHYIBX1Fk989D7Xq9yu0TlFZELFa+sSCLq9teHmj/QlX0NBq+Kt0DTpmhjIBDFPRUCsB/l8ea7CHZEb9zbxd9fvEWPqdrDxpF5mFIqnxklMIkRWUhHRIIk3coLqCmGjPRrL5RLn5+fh+FkG3vv7+5jP58BqOerLUzMfCUBgoyMFuADCpvCCThicWpb5yg3joGj0GNMEungZB+c5m81wcHAQZkPY2Oq6Dst793Dnzh1Y6zacL2YzzNpZyMvNgvTewKkZGrpthuqUdyxl8VNQchEwwO0Q28eo/MfWhsr+k23J73reGl8xMHPwpuuplAPJNAPeXa8ZpYKkkLdVYHtTb6D8bgQPBZpDHJYi9X4J7Wbjc6hrgZYSsM4Ni3I50lOSSJliSIVwKA+Am8HIy7I25+Ui4OCOocrMB+VQgViRxE71ZcZ2SI0o17Zp/mVjrWRkWym4kbZj7Ld87WqZv3Ojb9ioTZ+nGCpaPZRDOq5TGUxEYSa3ZrCUaE35c2hmpGZQTaF5GlBO6slRmPVG6Jr2Xo4phN/Rpp5W71KcoXhD9bfpd4c3RvMoxEBqbMT3MQ9HHwlQmuSQGL5ZGbz5maKyjwZDetfJCC+KPPJPw2nHeKGYLhn2mRFVIzM1hWoywoNRxqr8O4LnVO7IRwo0yBjVbgg05QC22DbZ32jRJlKuYPilB6f48q2rczB0Ej5mMFw20otEhTop2j3bBQyo8iOQkeM0SU4xj1CBmFJ/k7SFsjmDVHbEk7lS2URJJkSVfkxCbtRzsaU+KWrqSeWkYSNDg0E2K4ymaQIIXa/XODs7x3K1DEZB27Zo2xaz2SxbEgX4I2H7vrocJ302xgRLXCpCW2UQiDhWKToOjpbCyUw+T65DvFMj3g1ivbHFbcF1XC6XWK1WWK1WsLYLm9hl22mFHQHZsNBLjQmgJmyjN76Wlw7Z7IU3zFS6Qj6qzYRGJUQ2tVxJwF9wVt9nMBUwxCxzgKjSZuA4VxY2We4yxZhKyywpIG6TdGjLKqUAJAqdmC4YvwV6dD4jSrdA55BRNfZtirxhA0vOaA3VI3umen+ECIhx8v4FtCJiZc98Kjk1lh94ljTtGkDmfBxYifzyzJCt02QUifJxktJHpPhwW9TTyBBAXsGgn5r3FHk9SEfSdlSIN2SM18ocpEH2a3yJ8EoYxent1kMGYVKIZ5vN2iaNU9NnMl4qo2tl6GNS2cEySk6hzOFlepF/xMEoBbpKdQt1Ql3mUOGdndLOCQAslcu6pNbn2rjhTG2atSqORUuU4zlpMo8kddT5wgud6of62K23o34f4waN49tCQI6RvJwUixhC1I2NIaWr9clRXFYwJphHA04q06/IK9lXgc/S+uY5xTExjkuk7JS1CrWjiB91XWOsggiC1C+x7ZOxpPKIBjsRhf0bASMjdGUsUNjvgb1UX6R11hxus+/TwkaGxnw+x2KxUAUxaF4ul1guz3Hv9BSr1QrGGOzu7oKIMJ/Pw94MvpCvMQY7i51wAlTq5UvBeBCooXEoNkQBjESgHQE0GzjhvcmX/UQwqgViGqdpGpiZO143lGeB3m9UPz8/x3J5DiKE43MBZPtTnBHTwNr8+Fxdh9wYURe7QO+h4Xxke8h3HE8aemkaaVyVgEDoDv89gCjxved3Iox55KaC3RQclvJMi9ICr5zPuMEnUvoChoCXDfGCpgv9WS0nrUfyTvN6TJEZA5TzeErjkLc1xnNlqHEg6yjaQeYdppHJ3VvivqbHJpbGYCq+82BtfW0yC3mXb5+9l64iJ1u0zOHe0v2raZV9HpwYJJCFch16ZSzpz6iW7VYfI2MGQcaHhTgMuNMtvVON1CnxQ1kFUEkm7ssr5TU87qeVnfGU++G/cSQHM1yb5vSUgOewATDNUNvE8KiBXx7bY+M7gBeb88Jm/c1yK4fV0siotUHU2dNCqf7p+8n58dgp5BPkqx/fKV/qclh2iXykLzgDu0IWiWyNluaIgFLq4Sij+FGlK/CCpFGSFNsMWTAhGy5b3upuq9/k+wBErfUXIdvAbxHnSj7O84hiz/olQ3wpc+TztAJKSyT8Ets+gyA6D7lsWmZaCMERIUQ75x3KDf9IozSlgcKfmD6UEuOX9AD/NenyLPfcCyNDjn8t87wBlNS1Lnd9Z/b6/dTxt/GFfSUwz7Mds/kc+wcHIT4RYTaboes6rFYr3Lt3D7dv38ZyucR8Psfh/gHmiwXm8znatsV6vc4uj5P7KlKBa4KyIrUpWwaOw/E5H7n53Fp36lSsj1PAzPQsYH3J8Q9pwctG0/7+PnZ3d2GtxXzeomkanJ+f486dOzg7Owv07Ozs4PDwMNwXwjNBXGdpoHBdJBhioVgCuCSWgvE72We+Raugn/NON7vXPPolQ6X0zFisHKYrIU9+PQlpEVgEWwk/jQG50vtM8dtYJjKlvEGgZB9Dhf4oSGrAZ/gUpCEFNBR/6nsJ7oLAQ1QYZYEl6hQUrlfWSXksTKWBEMqdUI/UsBwCbal3rJxfmianZshTLt9PGQ2lMS7f19qhCJTHaBvoY9kPQ7Ry/AzMAYonhkCplkWZmZb1aYn+ojE2Mr4VABgQPAHYZ7JP128KH8hv1TE2kg+PFKI61Zw2d0hxGUDUhWkuWgbVjDANNit9KwuthMx5BMkFYl9eKW2SfeyrSFLJYHSzRyJSQank9U51Y053+iuNQLK8Qh66rEQX2HBvNtiQYbkyrJdi5WJbRHmryRVAVL4lAi+nnR6iYcV5MBaSY8pmbaF5Mvwe1L+xvXSbRv7MeV+O/WENw/EStRbnG6RRUe1b8sf7UjGu5iutH5XOtEkeeTEJL8o4JXk4LI9KYbKhUQJlDHol8G1N4xSJ7dW9GgzAL126FPJiJurXHc7Pz3F8fIzz83OcnJxgtVphb28Ph4eH2N/fx2wxDwYC/w1LtJp5BBpWz4RIGtkgcgrYulNreouGDOA323C7xilZC2s7IbwEowimB5wgCt4L6wym8/NoPHBduO48O3T79m3cunULq9UaTdNiZ3cHO3t7OFgcoOksuq5H38f69WLJFteLKJ6GZQFY8tunwmCJEEzeWdK2TXjv8uY7Rfx0nIlrbrnvS7wxhekuDLp9KBktcYoSALk+VeUpTQJ2Hg2WUZvFGqONl+F47irmm+aVKU0BoFFp19je+aDftI25b4fATHQwDIPIYtlUSkVhCZ1MK4WnSI4o/CgqOtFOWblaNwePtaQ1gwQTDGb9rQymAF2PYp0SEF003imdrclp1eXmv9N3JaA7BPuycV3o41r6Gj8YY9zm9BE+HQPpY0EaNfJvKW/5frgth4yQcpw07zFDrMZ/U75X8/VAqTbGS3JOGgUl4C1SQ4PcVL6lY1ONyqpDp/Q7eG/Ct3ig/Chozz5Ful16CvwdT1/PuSeWaMvMT/H09hItcq6gSqZvbyPUV5qmzB9JRdmogIVFDws/g5n1Z7oHIy1Xty4huq9CvCy9NjSG5JKsG8MsogqmsBGsyzyqw0HxkiTUeq9+yej331kvZdWrj3H3wxbGT6EiPpiMftJ/AoYTaYkVa+RRuYxQS786LU6ViW9Wp2mgO5iMbM9hp4EMG81oAGWDg8N6vXag1wN6BsNA3MwtZxOCcu/cTMDBwQEODw9x/fr1sKyIiLBer7FcLnFycoJ79+5huVyCyM0I7O7u4vCgjSdT+WVJksbZbAZrrbp/ozENOjhjoOvjPR1MX+rJl0I6ANEExMv0RBTqzzM1co8LLyNrmgZ7e3vY3d1F31tv61h01uLmzZvolueB9v39fVy+fBk7OztYrVYAgOVyib7vQmezcdAD4eJBGeTFhNwecn9J2seAPMK3cnb6iAL97zVE3jWQivjjWl5BiZbBNbJ3YViHdPr54qHsBdT9moONVImU+ICUWuDSdPq0TCCC3EHQMiHkwnOKWBSmTUKPC/mhDUN9kLaLnFktfR+lbWJ/c93/KEdmChJLToihPplqSPzxhovT+N9r3cp0DRkYY2kvTMikMqt0UC5v8oioHkMtebZo8AxmLoyoDBwCNLE9A40F2mrG7qABW5DBopgLBU1JmSYe59P4g1A8oeAZCpkhldTAkVopf2K3UW6RjKcp0BY+VMqQbrJhJ8BmuiI1uoStFOLoNppe2Y2XTumjW6MXkAE9kT+dpOthyXl3OY3c9M1p3bKhPosjZy+sdac6HR0d4ejoKMTtffp+1eP4+BjHx8ceeLv8ZrMZ9vb2cHBw4IyLJt5e3rat86kYgrEReMv6yr/pRYKl9mGwZi28seKMK2qbcJQv10mCjQg4jDdULYgsDg8P0NJhaCdrbViCdnJygtu3b2NnZwdXr17D3t6+2mze295zpUXbRCNMGhfc3nwhIrdrahDG+pZBlfP+lIVr9GgL5k39AyNevqnfyI90Ca1SUOfi5YNlCOdlCkfWk9wPm9adkrSSVKG0CJx22ONjizFiuhpYdTxZrpzNiU1jAETxCguHvOOJWBVaOSrHYsEYbz2P5ZGIVeYD9jym/YYiqBgEuj6yFYxKIo2aAeP0TDl3O9OsvEnxN6X9DmQyLwUyJWAzyJAotHdhlqNUn5q3WJ7ElRoHqqzKeCyBojSfQGNBho6prFp9N1GkuZKMStrCwlSM2tQuiv6CEk0l7/DwGE3jTP2uQMEmxqem2tNb27RapqsGyEvf+VkCMWudhz2+0zomUCfGjsRUXC47WBP/fFqNPJAeGxaACUKWQpSQo9dxVnh/R5vcCo++SxRlIeOfgkHBMzRuqZZNeK9eKOcZVjJQrA4hP9wgqDLrpXSmqqKglwsdbcizoC/E3x5RhpqUdtu7/6jYAOVs/UPMprIcMGxGooAGZP0g3qlkKQsG/pUdkMpZ/kviOcsoxDc+X5km5OX7O/fE8f5AERf+mr4AQiRNeb2C7i1ijdL4jZvyY7BommlyJg0b3aPRtm1Y7sSAVjIvA/xwy7fYP9C2bZjVSA0NK07OkOBWCTmjhXTv8+dO2dnZCaCS0/JpUQBwfHyMs7MznJ+fg4iws7uDxe4CBwcHQKcVlzwGl5/To2dtQQD0Nu5ZgSG1RIl6vZxLpuP2cP85puhtDyKEtuS9Jjz7wJcQupmfOZbLJU5PT7FcLmGtRTN3Rtb+7h56b2BYa9XMBYCQH9MlZ3KsqA/TV1Yq9WePTSExj2TfWp4yTPf2suApr7UuA/FoKOXfKnRJoWIhKkxeWBDSvREsnPXLuvGVGQdFz3QZfJTyKQG1LK4wmEIa33FOPsV7STUFSZqEeinuOc0YqK7VQ5ZrERVZkYZQx3ILE2lBWswLsSejXSmXBGSkj9Zl6Fn9Hs86Ox2Jw9iSFPXefYx1S8Cl6tMBYFtq39KynNK3QfomANk0BJsG0bCMcR1PBMeE6s/aLEysoQYVsbwMlCBvwzHHSa29SnHTOFPab2xcxXj1PKblW/hOLG8FABN63ses8m46VmV7Mw/LYGmoDRNjOr7Ox52Vp/vU6xiji7ugZFwUdH9m4OWhroYq44mEY6rSBsTvlV4u5e0apERCzFbEhcZSfLdSntjjAMo5cKps4feZbiNHS1BfglbSpGa8Rz6tsLGYWAhVUgi1Q3qyaKHcOr6QkcuyiMmcJjOtsuVrxapxiTwu49OpTg0ZJhsaAMKxrcvlMixBWiwW2N/fx2KxCMt5BGWByWInGBAIPazXBgZkGqHoeJD6/Q9cKcuAxeWrvITkZhPm87nqQAmY+eSrnZ0dsBHSzN3xvOdnbl/IyckJrLWhTjs7O5jNZlj7i/gyL03ioeOB1VsbLjHk0FlnFBnSa1PLTEQA+bs4/DKumTd2eEaE6xoNAGA2n4GaBkSAaZqwEf/O7ds4OzsL9d/b28s22XNecpNmCRCVAGsa1DvP4aGvbLSuZZvWg5UsIF/HAhQIyEF0KoRTyZYagKMDqdIGLPRkfaaZSNK77VINUyDH1BjQ0B6P8nIdqtKqFA4vGfLHp9iQe0qvKE+846x6BnqOIJ86eo8Y+Mnpbf4lQS8NKKlYT5/aN4Oi08bNkqVFgZyXKfBomOFIBK8Nci1kEgFRr+XHkDFM4l0ktw7MVVqRPzGtCZjInGbgJsrlEZLxWgqhHakIKzSdJforcYfKdfKoJH8Qu5ykXy7964IxBuT36JVlQP6ubIgIA4ciV43Jk02NhbG4w/HymYunPysylgAIRzt7HUDJYFQ8GxqTYV6MG8eikA2kMhJ9oGcNRRRoGepDyctgBdDOvNmSf+PIijK83GfWWj+TYYttUCujqGtDhWxoEhLjXVfMZrMRRMjrXRjvkb/5cjgZj1SbjjkPyQulCP4p0FZMR8jaMpZn4TQKJTKNMtkcf2qDMZcKUrjz/h3NN0NBOlULVRE6wdMXlgwEUy3E52sKsxkhuHQeQYvY8ZsmCLE8mYvSbSkw0q94PF3AztjseFsrzF+ieNoUe/v5Mj/2wPPyJV5SxRZ0UGheCfCSIzdA0lOmNPNGwAGQIdieu8Zmsw7SO79YLDCbxcv0etvDklVHzQZg4feHzGYz9L1blsWzNXyvRtM0fhM5YE0EPzXgzbMdbChxOTKkgJqIwvGwtu8Vg3K+/J8xhPligYVYKtQ0Dew61k/uxeA9IsvlEk3TYHd3N7RPeiJMeqJXCmoGDYWUZuEtiFGGhWkYJKWXHpKyF4PbVoH9VJFOmEUp0lagMTOqwhBhnqi3Tcy7tBdBKGIxq+DGQQQw02d7dJlaGbg2LM+axMopZZ18K0NXN87DLEkxc4rIkJwLQuYSciZxFGsNVA/1aSJ703w2CgWFpQxZjXucQeQV69jSmcFiC3FKHvBcmUijS1ehBDIHIMJk+lKnzFj8Wu6jgCX5rWcyBslFNMKdY4g3qaftOHXmJX7zGu5pGhglULBJyOM7czD1Sl6EzpJhW3XYyAv4et03Q3V0Y6awzC48R1hGTFOlPrJfYv8M1zUsrxL1EY95Wm5boGpkcDuEG8FsDrA1iNbpVdsSx7KQ61lJ/LUQrUSxnWrugAj+9ctQDueFlF5NpwblFnzBkKQ7tok2y2JfiTxLv0T2pD/FqAmvsCxUxqiNiWN7Rjo2G3Z5/Jpsda9jv6XGcOTrMj+l5cYCkiWrqjxNU43X0nh1WT6tcSYbGk3ToJ3PsFjswB4cwFXGoBEX9p2eneH87Bx936FpW+zu7KLxoLzvHfBfr1bovXHQGIN2xsub5JIqfSMiEJncVdaNdoI7m5+sOLVGNpjl83/8aVjCY2V7C2ssunWHtm1xdHTkllFxXWctAMLZ+TlO7t1Dt16jnc3cSVFE/gxjA2t7rNfRw2sag7ZpYMioDfBN00Qj2TNxadmD8/r7cyI8wG+aBrbrgoUelzIJQeLfU3KxoDEm7FExTeM2inc9zs/dnSf3Tk6w2NlBO4vL4parFfq+Q9u0avmZDFNAbmDm+ALZMhpSfpFgBOlGQRgLFs6rxV4ODY3d2d3y5Kl0CBFInZyg2l0TH4rW7325dW2jHdoyDyHctPEk6XFCLp4YVlaycqawRouE/iVQoNMyTTYmTgahVNWp8CTk9ZbZRncA5BLa4P1jxa+W1Yl/goqjeDEReRSfgkMtFK1qL90yuj0AxFnKEFPIolTQqqiRQYtAR0QvAlcSdWI6LI9uXRctK5HnldYtpVcoeoCXN3C+ScS0DmkfizJoCIUl+QReKrR7DeDrPHxZpKuGhCYdUqDE8MYJZQlwWEaXZkfHghW86SuiaS/kkdvA5T7OakaV3uIxKwVsNQiDWRHFysrHEXRlOaRAWfSB6ueAZBNSfZeomQ5uQv1KyIWYTwRTwwArCKCk/tLJImfASBYs6FEF8IOFB7K81FQCWh+H3IiLtMgc9PKbkL2QoTwGU/bq4U6psqG/Ih1hfBP8KUKiXoKGMEurhXbAWlD9KoVIaYzoWW4CxIlS8Z1qv5Az113I7hQQinxBlDkVQvsn+IAdPrGfrMqTbQ4S9ZL8k64CyHgrKV+1E/O4bFsvg+L+xRiM5xSCpsETEuSoHLtDmIFnfnJjj9MaaAEfCVd6uRRlJExfOuVPMmIBDH+0XMe30BjC5ctXMyDDoHh5fobT0zPcufMUlufuJKX5fI7Dw0NcunQJ87k7ona1WoelSs7D7u6SIPBmPad8GZSQIdiudwA6OT3KGuelAuLFdBzkJYFy9sNai3XXYeXzamYtbtx/X6gLn261XC5x7949nJ6e4vT0FNbacC/GYsZ1WWGxWGC9XmPRzsI+CSpsBGfa+r4PYFoqGmMaBM8v/KZxAz/T4ffHeC7gMtgzbq07+owI6KxFZ3s08xmu33cDfX8t1P90eY7T01McHx9jvV7j6OgIV48u+7Zym9sdOXrPyhDYZVAZlsMQoaN0gEYhIq8Qa5ombsLnwchSltnSZYDeRqFiQGqVz9hYkCA8gByqAB0PpmreY2H6ebqbsGkr0MczYUGc9rDhJpyQMMK/IEnEhmLY5NInqLhBUI+AjNh3fRBckjZHSqIZKPJvrLEXXtyWsRqh3wj6yGWI3xrgxuDW1/O+Ive9t56EAhAMbWBZ8Zcun8r7rAT0HM9GgJUtsAqKnr1Y+Z0lJJAgkZY7oZwkPxlf/s1t4WlSPnMTSMMpUUx9/CzKdz+MQHhxiZfSwkXAkdNboHsUvNZkjOD3UB9ho6mYevO/QlOWN1zKWfFpd9CE+Op3HE2CrOG0KeBhUMBYKMip1LDiQqJ+jPlYGL9ceXg2Td4mp/uJDQVh14V0UodGfhI0+LEYZlF83v5ONyF7A+yL+fPFb5TwQiQ0lsUJeXVBqGscw156FOovKKYI+JXX18/KiMUpZYMLBOv3VyqBCgH4YYNBkPOBlkXcrSGr8Fs7B9KRFbPVfS6BtZM9GjXyUh3XKL3qEbIIexBj1QJzimzSGXquK8dzJ2MyT4YlnjbWieGFTQZyAMr+Wxj3qt6lmXnOh1cDWPAMVBht3hnNRqfkGkFArItFcjBKTqsxWmc7HOmiudU4QlJQHGeqvp4OJU4pynU2LtzqF5dnOtYb8vmIvkrrRwTVlgjt4zCptXHpv54RGQ8bGBoR1kh1rabzxBEQ8ghbIrd0qWkaXDo8CDnw8iprbbhH4+TkBKenp+j7Hnt7e/EI28NDtG0bjp5lcAwbQTobAZB0hfOYDWwfT31iw2E2mwHQN3aTocwYICJ0XaeWEe3t7WFvby/MWPCMwHq9xr179/DYY4/h9PQUbdvi/us3cOnSpXDU7mq1CscBp8uVjDHobHJjN3jJDKHv3QwS+Tsw0iVjrv6OMda2x2JnB13fYSVP3CIKe2rYOJvNZmjbFoeHh6E+q7NzPPXUU7h79za6rsPe3h6Ojq5gb28P8/k8nOIlGbt0xLBsS9MYdTBApN0xD5+EpTbTUz7bQULBpPsENFgaP+0leZniLzfQnDQcNVyUEWLr09Q8Skvfe1++PPmkRG+alk1RUFQHpdJTr3EK5Ma8lsWp1MQIlJRz3AbwDSnycpln9VBC3leK68YKoTTLkC7PK3mm85Dzx1QgH+M1GLsgsZqvUP4s//NDtsbpyftRZF4JI7ZotZwxGqKyBtjeij0f3xdpEnyZlVm0F/W3AJaS/GJeVfJH6zbwEQG3KGA8vK6ZhLwJBof1BjW8nPPoZgoH1+Kk47f6DeV6sjFQboN6fmmZ0stbd9jU8yl+l7K66CDKeSLQItLr8lKQXm6TpBi1xFPSE2xBBdRSVMVGsrTqxnud6+aMJqu+yRxUuUL/5m0WnbkuvedB61aRbCI1tKFY55PwUwg+Y4yThYUmMIaE7ijrrigPWfpwvRD+2iRP2dPW9tFI5qIYXHEa9yXoXB7DKS8FIyh0bSrj8rYp8RepODLdsP5ODcL8W+E1z/zw90y9BcQxGKYfbztMj6ZCeFAkAztDoA8DobcWXeeAajNrcfnqFVy6fKS8/Hxr+Gq1wvG9E9y9exd3797F2ekpDBns7u7ivvvuw2KxCBvSu74DKJ4CBQB9F28CZ8C6tj0MDODBKxsqFhZrcZcGz2SwkZMe+xpmQsTN5ru7u3j44Yfj3g7vKeNjafk43rZtce3aNVy5cgWLxUKB7KZpwoUpveWTqAjGNGH/CAA3qwGo2RyuR9/3WHXrUI/QU8ldH7Kf+Hffu5mPo6tXcHT5CIYQ9qfcuXMHjz56B3fv3sX+/n64jJA33QPR4JD5kzFBwMm7Txg4dv4ywuybyIf/awtLoP44Ql01bZKDTlm/23Y8yJwoEYoXDZNAd6GsohgiGm8oFtqjBkIhqb1oP4wQNDneZqWXmqMCuzbKd5MQAC5iuxcpoFTVVYBdIV9pC5in00EKgNnKXowEUFKE7ALn5qk25LVh+i6QVBob7FH0vyXQJUDXW5U5DNpTQ1RuqA9AamPCHY21cpV+4bpE9BvLHHF2VIuvOjgmZ6GON2ZKQz4KGgpvclIgO7/UTCVcG48ZVZEOCz7+t2zelAOZaNrXhldNnmrRnRpYonvAl/5VaBhxULnQQ2q41H8wHCTS5aXYHMqmtqxb0iuApyTOBvDbDeR4GJ+STypjQZKJpG14LArDdBNhIq+UzvTJUDYTi3AzkhcTb2THFtr78KqfOSkWXFwn7PbIA0AGYvt+DZDefM3MHzxhPj7fe8G/rbXqPot+3YUbx8/Pz7FcLnHnzh0cn5xgtV6h6zpcunQJ165dw97uvr9h28+IwIZ7OKhPgDaiEOcZB1muq0ecGZH7IeSN5TzD0bYtqLfK0893WhBROEFquVzi7OwMp2dnWPeubrtzdwQvGxbuhnB/IpUH4Tbc4h2XX8l2ze/D0CFdOiTzDu9sD+vbzu256WFMi/V6HYxBay3Ozs6CIWWMwaVLl3BwcBDS9LYHhfT62FzjZ2xKRk/Kd66i+b0nnMYtAQliceOQXsZowROIGiQFb6TV6WRGJaM7KKKQuDwM9ZrQZDOg1YM+nXZ3qaLgGguDbT0StyYLAKg7GlxiPT0MgrrV1HqXT2Ywie+pxzvyhC1+Hw/6ElE52xbrZar1jOVERbjJLFq+xtj1GyW8NkXM5zNT4/3fUw2IxvKY71M6avEz5xfjSYvisr8pQXvecz6RL+pe8mFDfurMUSlYuPXiFrGOvFByKF+ewYxu1mgts7MpBTJBTxGFJUMlvO93QGZjKFCsDBbKjoWVMxFNiXfDyoG8XlNmhy46g1S7PTo4KilPP5wfkErUWr+FvkjrLces97g7/VaRV6Is8v1OXAevIwxRZgSRL0u+CAYjUS7/SvJSE67AOI+ROB/v77wIPvW4JnlshivKUuvLcXo5zJYQA/O6XA03stu4uJPrwKcWpjMEaZmyboEuePuC/EwNv0t0tp45c/nK1nAYCSFO+EmatlRn67w1L5XkcYPCLAfpOEGWiDDl+otyPyZO9YLh+7c+aTzzjY63LYXSNFVvw0q/2BP+R9O0udczeZb3WMgZCCDOSBAI8LMM56slur5D0zbYPzzAzt5uoGc2m7klPv0aS3/Z3fHJMU7vnaJpW1y5chmXL11GY+JdEl3foRNedLmpWwJwaSxJ+nhvAder6zrPINFDy6dacX26rgvPu3u76Lt46WDTNDg9PcXt27dxenoGAFgs5rh27RqapkXTtm6zve3ReQOITwPjy/jSQSOZWH7n53Q5F5FbTpZerNi28SJB7ruDgwPs7+8HY6vrOhwfH+P09BTrrsPu/l5YRmaMCTNBzgAlrFb+OGG42RumM53ZMII2yX9E/lSPeLRJEPhDPBy+E4XBG/IE4iZmpIMyDv7a6lAQxaWFfZDoo0Er/CgcS3Szl1CBYVsCqAUabf5e19EiQb1eftbbVBpp/Jc4ba3uTD/HDXXTtLrTQ+Ma9rRKZUNhCOzlm8proaQApsargt/EULXWeyZVdAaZ8g2PAmHgZGWkmqlQvngZ2jSbj4r9qWqegJn82cfjzaCFZiu2pBuE4TH3OBP/X78rZjXM/3m/lJY71fLWz+nBpjmAHQneA8EnkJPcvmXh5ZMro2OelkQk/Bbbm3tOyCvuatKe8FRXuLEhwKzIsQSOas86paRTkp7yXb0NKUSNktfQ0FK1ugMiH13uLYU2F/vsPJ18YpFsO9m2lNBeckhwehKJDcn9ElEOyAXsRSeCMiTcPgQg6rJQfDgJTNCWcS488wn9QQCsxgW6XkDsPwvJc5rMzD2QDyTBI/EwIICSPYJqHwkbAZ5kUjFsWOYUYDPHoxgvOFSkcU68P0fLSaVZKZo8TsW5+ZY4pmT93X+9tf70VAb0+UmkbvxFtSkWdoU4gXuthZEoJMHnYyHnqcI4mZBPGja6GXyTkG6osnwmNrmJKinISqcapd75FAyTiXk7kOqe5/O5opeBcdf3IEOYL+Y4oIOwxGd3dxeN33DOMwpn52dY9324WZwvA0yBNxseKTCXQDy2gVOa6fKmdPahaRq01AIzDXT5Dgw2TPjYYGstzk7P3K3o6xXIGCwWi7CnRc7GlNqZyy55qGUdUo+IpJl/83c2jvh913WhvXk5VtM0ODk5CTNRXD+evQkzPlbvlVGb0Av1iN8csNee82EeDnUpvA/GhuDpWPBQpkn+LDFKFUiC7hNSfFOcUBeKJMbVioDflfq7SL7MR9bF5aYqUZURGomoHGR+VjyQoFULV68OEuNJi95KPw14KKWgnirrxuJJw7f2baQE9WS5zJCONWSiyFONNiGkNMYdFimAqLM7mVRJylk7+SFmUhtzIpMinTwec1iYp8myTFJSgSeHxsNYCLkpJZ/H0wZoDsciiEudBjHDEF8kroN9CUz8m3Rsjs3CpTi08CuloTwOdbHpNxIVi+2Q5CLEkmw7BmflelScDjarmk5X+0vlFnCvczmlaclloPxGGl0mcfJxWSxHsAvTRKRPaWIRoseBMARTFsnqIWmI9Ndmfinl3UooGVJ6v1NJsGj1Ko1kAKCAQwUNLiJCNTKHrOsHPnpAlU1CQqb15aTyIeQLhLtlKszH8SRkKLh5XKuQwIuAMK0uFri8UpUuEi5maAzwtY+sBqJjOH8cq2JaUoxX8/xJgCm92jL/micy3E4uwPrOzk5I3zQNYBFmUBzA7cN+CL6Fu+u6cFkhGxcM5HlzdWmqLYB16E7n+OkdFXIpERGFJUYM3rXx4kLfd+i6NfpujYZaGGKAv8ZyucLp6SnYCON9INJoS8FQedmJ9hLJvjLGGZI13NQ0DXZ2dlwufjq5aRqcrNbuuOOuDxOptnd0Hx8fw1qLnZ1dzGdzf3oDAuc3hkK/lWge9Egnz0WyCy+H+NUlKeUU3zk+IK00hNAcB/++bgKkaeMKShsHL+SIeCiDcv29LLYIIJv1e0kJy7CR8Mt1TQZ60nGVll1XTCkgL8ktrYDHgCYfn5jRWqhK3TDztNk0bqlu6birH8dqHYFV2hWIF+0oZ/oEgeU6SFAr9WdQ2Ij1CnyV01ALNomXHUpKcaniYJ7WO8NirNHyL2SACh7NRrOsP+XfI/+JDEaN0zxYlTdFg5WzzIzvHNw7UO+Nz4Ku4PqUfodeK+CGlM9q8ntQRnkZp9rL/y3rMk17LmYpOjoClqkJufyVftDtwzM2sn1tIfsQn9KitHHKXxhjKeAr0yXtp2Il8oP/EvJ2J5LllUJgVF0+58WZML1JfdMg8aOU+0F3ShkpaxfEkC2/h2g/3wGM0vR4iaep8VjRBNqsq+VzGD+ifkx7yYDWPJvWS4aSESeNElU50bZKA43mWx5yBRwwEqZf2MdsniyHcMRoBSUtP7lswRkblKUpgedUQMjlSqV00vsvQ29tUThzfLn3YrFYYD6f4xIAGAqzB8YYN9Nxdha88E3T4ODgQHngrbXBEJGboskrP3mztzxxS9ZT1k0uzUrj9GK/xO7uDubzmUrTweLs7BQnJ+64WqaXDZb1eu02znddWMbljgi2isbQ/2JQswGk+ylQmbU1p2Ggbcit0Nzb2cGhX2LF37uuw73jE9x64km0bYt5O0OzWAAAVut1mP3Y3d0NwjPt+6LAEpSl33trs+FnUyE2aIgxqMrRQlAAw82j2qj2TYtS9RHslcnSFEB6bawUlbEvTCxmEsCT/ymADVuv6vi5XZp+IlT7l414mSbvqyRdcmmTrmcNLAHplL34ECprrG6j1NAg5rUa8Ele6/qUZyQ1b/TpR6FzbLHccn55sIhLduqBy8jHgmtdUsqZPepjVGV9Ed6HjEIJxfgJT/QqtlbO042N8li1iE0gY5XnhyJ4yWV9PEw1fBIoJo4PEmXktFoxGOM7EQ96eRQQx5yklrL618GhDhp0Oh6gsrwSv4tjqJK3Hie8jl8CyyFgjKR9pE4rORvie6k5jK+da8f0mFqXbwnolgGlNxokXQVZpvrN0zUm22v8rZczkTA00ngJncH4tELekhc9pGiNmZSBch5s0k7R6cGcLB1vZfpEGWLHdD4WY78z3qEkRkHNhsAnVinM68dRTaLIYRB5L+onNnKKh2dkMkHLMalpuRzNFprXy/gp4TeZu5xZHwkb7NGQnktdwNgSAALUcbHc8ASo5Uj8XRoVqaeDg1yao/IV8cJsRpJ/+tzZzjOQCUemddYfIUvuPRHh0qVLODo6EkDc7SHoug5nZ6e4e/cYd+7cwWq1CvsUeC8CWXc5YLiZ3BsK+v4Mq4S+TeiVBgBRPLUpNUp6D75msxkuX17g8uXLbvAYAyKD5XKJmzdv4tatWzDG4Pr16/4ukx2/R6ILx9YCPp21sLZTZTVNE/ZmhGUumQCMPMK/5alaHE8ukTs8PMTh4SGsdad39X2P27dv44knnsDp6SkODg7CcckyX+NPtLLWwva9EB4XAFek6yBnq7K0HlRJwDBkNCBQROrF0LId9oY5WSSgC+m1/FqRkTur2+r61caUymBEUaXjrl5RuaI0CmuoX/I888L6aps6LHQuki7Jb1FJFZSs6F9fagD6VJBrg/2i3yCAwHKCxDTTeVWqBm6XEkvpsvLEthgvj1Br2cH+nRg0yCAU7RBJUkJMnH3QY2a6UZB+hDJiweAXFUMyJBnWdSJ6Tocd6fcSzaGddO2DzHPZOpBTYBDH426d/RAPR7qj/I6jM4Z8vFuRJiNdpSeKm5p7N6hV2XHijNTfnF5dvATD0QcS+5IBYN3YSMATywAxHNVJWUFGpJ4KRDYitz6/SrdMr2ZO4vsgmYgrGusb8yvLaSWjIa5GyegYCHFIZKwVQbG7F4IfLUXnab5XRhsyygAt0hRlfuTHlN9cO+sxVKuMT+nbLe2Oxr/loRQ3MFlRaloPLlOPz6jp8jqmYJ84vSCoNJtJnJb0fhvbq44R9c/lSuSLSBuPDtnJrtxeUK/TyPpMCRsZGroQQlw2oUtkwiVAs9aGzcQAgoKX93MAjjmnWOPpSUrGmMxTSMaETTYcJ6uVteF4W1DvO4oSC7JH0xCs7cKt5hEgu+f5fIbr16/ixo1roSw2KE5PT3Dq7wc5PT1Vp2Ht7O6ImZBwrhHQNHGYScBfUYYK0MOxryGCNeQNJqeS+n4Naztcu3YFDzxwX6xh3+Pk5Dhc2Hd+fo7Dw0NcvnzZn4rFxxHHE7XW63XY/O6MoEivpCe93I/jy3qkfczPp6enABDuLAEQNrqfnLkN8ufn55jNZmGGCRZYd/4Cxq4PRikbanx3Sijb/2eMwbr3G+phi/wi+S/cNi88EJYsOmsxN60uQ0qZoFD9q6wUSVVMFk+AcO/4MiALaQQlYzED3/p9dgt7RDKyYM/ncZnfmCHlBYBLm8VLjQY5bEt56nf+rj50PGxFHaMRNe3kKecp9GKUlZkvLl2uqdJUgl6OM1SLgfyCvOcU8TBNpwvGwa7MdxQcp7gxoalUXolmDMjujF+o3h4ufqFsr0SLvJei2sG844Vh3LJdATNK+gH405iG8x0K5WN4a3khuFX5Pg3GmoqmMOsRT3pMg5xZz/vSG+SQeef6PK14lCnqiscIgKLyAiHhpUo7SFCbllXyCjtspuWUhHtSf+ojfKWuSS/Pdf95iO9xjhuQYYlZCTFSpX+rdfIfe257m8XzrlTVfmEfFMn9orouqZ5gsEz6RaE9uPVSGZbL66wewoEcC55y4aUVtCUnM4KXnjP9kh5hhGU8ncumfGgKHCdItqrvI/aOLWdVWpmfrE/mKQlkJgfsCBmklnwaYaYq2hlrML8nM/qhwrLMWF7usPNjyAIktru7mnB93I3ixlA8tGSiDuIwfelUcnIRKxYWTJlRIRTM1BAxzniaUaBTiFfyvhKR2sRYUowKxA/US8bjY3mN35y9M5/j8uXLKk8+1vaJJ57Axz72MaxWK+zu7uLo8mUcHB65Y2Nnc3RdF05mckpSL6mSMwISdPGyMXkHCC876vseq9Uq1In3rywW7jhdnk0wxuD8/BxPPHkLdzyon8/nuP/++3H58uVAm6trA4DCBvT0xCumLd1ALy/v43Zfr9fhxDCuH7cd75cxxuDq1ashLwDheN2zszN3UeKN+0Ie8sJFbjcO7uhdi8bvuwkmn6+LnNng9uqtRS9ob5sGMITz9crNpkke47TGwHbDAtilSUFuwbew4WAvl1Nag1+P+99DiM4FciDsArKmFgZwUJ0eKKgFFBTypiEo8AI1w/XU5W9KCRXInypr87xyWcuOkI9f4NExEAqfGVBcJDwTfJfxMFsWMk4pnXbTZnlGfZDrsk3oqs9cRuNvo/xQ0qXDNJV7tuKmEe2YnnBUix/4nPS+SZnfVFqnBrrwpT8amI+1/2QepRLraaFQymvCqKvQU89bAeiBzIt1GxMBYsATCflNY0nr7S0xTr29h/UDEUJlCXLxpKA7/C6cEjYSsrGq9F1qoMVZZCWX7Ab8FLKaKHFe/fPnsGoqJWUWLbxsAgCCEeJeFMsorUCuDaSQVxoSAD6UR6QcgumcJdmLZ0l/LCYvpxaYqSWzpCBXngzVti1MO8O9e6e49eQtB+5nLfb39rG3t4fFYqGNC6M3dkuG773Dia9JTNtAgn2mTc7GkHWzTKv1GrB62ZYxBnfu3MGdO3fCrMLh4SVcvnyE2WyG1apTN7kbY9A0Bl23VsaGpJvvKuB2KbYlt3kTj0GWg1saOYv5AufnSxzfvYuTe/dARDi6dAmHh4cA19F7IHpvCHR9Fwyipm3DsbTWuuVvIL90r2d6bLzjxLjD5cJxyf6ENTdzZsWSP/c1eNNZwvNz4VhfPlaQUv6DVfwqeYxgBhVZ5mGs8LX73Q/y/VRAWotTA0FxjMZ4LK5rNlLZc5tkSPGLOLHRw/vceHFZJnLI/xsNDTtqBGb1TIknX37BRTou4JOlqIq6mMfosrCCk7CE1yRwBMUjaGP23I4xX6u8k9PCxmDeIhjrJXAox5BT6AN7vBIGLBlQquiQjx/ZGe3S25nzWWhT8sLbOn4g5PeP9K6igJAfHBrh2XS2SGwHEnXSINGCvbPsRMxpls+AlL38qWSwxgSx1CEjxah+S/nVe7N7i3j/QGnM9jFuQjfTwm0jzXOW6zlpKT/nYysGq+LGT6IfWPySf0aUPWFDAYm8JN3klsVZ26v+Ki/ZoliOAnHxm+ztWHedYOiO3FL99HcJaW1s+/BS1jEfM+k4Zj2gwXIkgQaYUBsU8cFtBI/9QKyjyfFQ1LOaxLiSBGLc5GWn/S16G6DYRyyjey/Pw7G8si99elM4kCWOe0cHj3FyA46JzkY1/IWBpPIQjaarDQD4G88fv6ts8oyG9dKjzGfp+vV8A1D0FgwrjBTI1IQQM9mQb1h6oFNhKA0fqXT8x1HaSrTW3llr/XKP+I0BJwN83m/haAZWqxXatsWlo0t+mY7BrJ2FE666rsPjjz8OAFjsuGN4eYaEPfBN46566vveLaMq0Cfv/5AhLNfyhsfMl8sefl42xUfusiHBd2PcuXMXt249BWttOLbWbZAn9P4yQiBuanf94/aQqHZLlovJdu78DI3cr8P14Q3usG6p1t7+PuZ+X8furrtn5e7duzg5OcG8bbG/v4fd3V10sGj9RYSz2czdqm7FMqOgNAi97SCVW9sa9BYwJGb/vNBw+0eksvRsRvG1E2u5xzcITKvflcBiBliSNGn/kpe4JY7PvZl6LBcN94qxkJZfCoPfU9HhG3A6/qSk/cXRqxWxlBobNm1/NjMGAHiRkhSYChLTeM/UrNUm70rLW6QHsFhG8VnK1HrclJ5Ulo45daQzKC1Oyn02CglC4YsUJbAfcpOaN/teq0sEyDp+ubXK+aqFM9V44VG9TjyeVs4i5PlbFkjQcsonHRzbaW3kHoc06DsRhvaOuNzK5UnhGY0WXTemJs2zTJX7LuVcjaZq9gk4k/0l68Cz44jyJ0srCixunC7zgosu6C8OtjQv/zfxe5BgqnRmfViWi/olNMpkpL6VHUOShhhvkz4d3i/HbW/Bfp2E/7lEgjBOXJ+k2WonQAVDcp2KJEVFpGSw5VoLPrc8crUxq6sn9bUsRteP0wed6OPQwDjYNGx0YV+pw0qefrWZMgUpLlI5/6nlW/aKxfVtYx5EuQYyeJOZEZEvnap5KnIvb5KuWr7OQ3rr070AThC7jekLf+KS4XYld5yttR0WC2dYLHbm4U6N8/NznJ2dYe1PvlrMdtw3iM3kZEAE8L3aDOgBuE3UVpzwZf3Mgt8h1cMf/+Z3gJm2xbxxh9MSkTu+1lUW88UcFsBiZwembbHuO5zfO8PdO7cxm82wu7uL+XyuDAVr87Wnsq3lSV28+ZtbjYjQUNz/0fc9YF095vN5MILYWGqaxm0qFzMrZ+dnuHPnDnZ3d7G3t6doY6Uob4VngJMurQrt6vttcIZcjJkS7xQbBBADppw6eFkCCJNCWijoBITH9Fxs5vcogj9Z902A9tTAAn9cUpTKiHUX8C/+W4rOP21e/1JZRATbd7nDsEhPOTvdruI2XpK9bEXfFAgeLkIpszEjRAF4U1gnX0RHUPq6UIL/HGdZU6O2ZGwEevkbCFYofJ1HlLsp+NP4K7iaZNOgZn1KI0LLpzReueYyHw3e5NiMeo4pU+aG7B8B6OU4F6JB6beYfw7slPHhQRjYWQKK2H5k/CrgSJJrZe2okIZjyZjJbEWsdcyT+53fKY9sZVwkdWAHD7FxVq2iOJQg6WPHx1D7QgV5qlzy9ZJZmKRfS8cvxxexv9gIlPl5FRzqYtOZThvbk8J4SegkgMIYFWUhiVdoo3R8ZL/V8BpyYERwTT6xwl0ifWnMhUlhX5hRZcXKEHncIhx6pKKwrtT0pjpf7bOAGLuhHNFHQV7JdtBtYYLsl9UQ1lEhRJVRcBjIojwdBhTzTWiL9eAdG3q+bKou3+gejZpnSTZ2EO5WvPfxDJkAQkv5yFBalgFEFVUWVzq+Bj6eKME4rLNK4CjdlD7kXax9q4FECU5lPP0saOGTqbzhZnwlLh0dOnDtT29aLpdYr9fuv76H6TrMW1fOcrnE+fk5rLVYLBbOq2+s24DO5VoWcJBjMApwpqdJlvUQRdqsQd91mC1muLy4jL6Pt7mv12ucL5dYLpcAEPaArNdrnJ+fY71eo21b7O7uhjZga1z2Ec8skOenQD/InzAiZkr8UixpFPAsEu9JITiDgDe7n5+fRxqIcHZ2FvaE7O7uBuMjHxO6/91sjPvAU65yg7Hy1iQCylc68gwSTSB5atTrLcEYJ5HCucbXwwZ8LUwRPlPyVeNCCEpKvk8rpxJ3g+rlioxUl0RlBR2nnqNSIiqfUGcLeVts9E6llkalnrZccwb4QNLOCR0hvq0cjiBzFz+VNzMpI/AiCD2V6Sh5bKM+EQZEaCP3kMt8/T20ScL3qo2SsSLzLXtf86Ep6a6FvN2FXmOgD8T6pnT6cm3yrKtRMiZrTB/biZLospxRJ4JixSjHAqdaEVemHaAn0JGkS4GkIDmA+ZIDJNXZEpbIfs+DVXFyPq0MuCSUliClkiL0n3hvxS/ZjtGZKkFvrsMjrb5Ea0FJGbF8NjJFsBDjIM2T+Vkf1BPL03HzvTMlkJ73iy47lVnJF9KbvTnf3JHh3wcDkEJdY26ibz1hYw5uI9W40hXxhZRTpTx08PKz4AcJcZPZlqJDXI4LP7Um2yTV/cbLaXf20QQGT8L0GQ053vscJJe8LKnCaIzb1862ddpJJRARBHwgokLeAONz7iVFSgkXhOeCt29MwOqO0kra+s3GAIJXnUFzupHb2ng0LxGpfQywcJ5FcqdK8aZuTr+3t4e9/f3oKewJ5+fnYZkQAFy6dAn7+/swBrh3cg8gt5G5bVoPJpwBwpvHeXM0L3FietK9EVxXni2Q+z/4dKqDgwMcHR6g9zevW2txcnKCO3fuYL1eh2OB2QDhNs3ym89U+1tr0ds++pvIza7Im8VlP3E9iAi8kYWIsLu7i4ceeigsAzs+OcHdu3dxenoalmPt7+87w2jlDCM2pLq+h7HxRC7XR15EFcoX3OPvwkqBR+Qt5n8tiFMtENNaka6oRLis7Es5XtqG8l0JFKoy0vq4j8XySl72bNyNGgcjETaXk6MJS3KQScnVaT0PGx8CIkt5J08Xc9UODP86s340R8hZiVIfpzTGunnlW4oXCdOeWgHUmeVTr3ypPGlkSLYPXl8LFDeRyGBrDyPGqKIrb59sjHhFFlVJzgGie7O8wk1UIYNIXQQKQSI4fVpoPw1PY7vX66VnVgPYEEXWjA0StLoT3zSImsRPtXfSaCX9IvBDajgIHsnuo0p/ePAkMFharBBXeT48I0yCr+t1KoA+mY80JYqCo+wMCONoo8CGRHl8FulUM4iSznK9anKRUgO4MARJlFE2loOAS2iMaDHuQrAqJSjWmgSzOAODjYpcTvJYi+Mg76do6ImZgkxP57wseTCpShaICr2dwwFZIvhrNFRy3Z7XoyQbbZHWoTDZ0Ois1WdgQxy66Ae58ZKopqzCNBh080o/2aAAg8jbfZxKfpUZmLLk4yAYyPOOBgS3RTpjIb2BDJblfRTpUqqGHD6wXTyViWmzrpHd5mWRNw8gALBchnWby69fv44bN24o4+Wpp57Chz70IfR9jytXruDq1avY2d8HYHF2dh42pvN+DPLGxXq9Vic9SWHCxhO3C1c7bMrzyy94+ZIxJhg+TBdfkPjYY4/h3r0zzP2JXZcvH4WN8LP5HKvVShhnmud42V7pNC651InBHd9jYrxBs16v0fc95vMZbty4EfJomgZnZ2d49NFHsV6uPF3uCGA2znjPirUWpjHZPhJ5dLIElmQtLFG4biqgVGmBK2bMhUVqQESRl3s2pFosGQU1QVRbIjUZTFjLlwwrz7qMmx4EoBVJyKjYLKk3nf8Nd40UqSzQHfKrt1FKW9ZmxX6TVCW0ezqdCtVra4eWphVpyzFDtdwS/fJdsW8rr4pLTzQqAaANEAfThhxBvAZax2mgdRIF66pGW6o2xAgZ0CcuX8mTw2UAEeSUwQMDNg2CYQFivhF8orSVbDdy+/+sAAVNUqDtBR1ki22ULt4M6iZxvcvZNUlL0OoskyrARTsSZPvotkqzCFJtgHl5NjuewUnBOAvgKshSG2cVamCu9jvtL78u1sGfoX2lpXcR38SS5IyA0FtBGcS05DGXzN+tTIhgUBtMab8j9Lzql9K+kPBPXJooZygZ8GsD2tGhZzLLgSDGeOCDXM5FeVx2EFjxKvClH1PhgtAUD4aYse6ybZDINPLj09pIh2QnozCk5vf8ueRcU7UR3zW/6HR85I+kW7ZZigoScnwwJFf0FAwhNV6nadPJp059zS+caVBnoTY4W2vRkD4CN/N+kZuk6yVtlqcRfTcXG9DXy+pZCWo0U0fhZEORoqZ67aSSZEYJAW7eWsuwNRnYRALXkFbTym2VeujkRXUBZFmLdedAKkJ9SDFf3/eZQulRsEy7VGHrtuFZC95kvlqt8NRTT+Hxxx8HEeH69es4OjqCEacv9X2Pbr1WklMaWFyfPswU6BvRWzLRGBHESF7i9EQN0Bg0xqDvejx15zYee/Sj6GDx8MMPY75YwCSnT3Ee6C0MNRld3FchDeLU4No6Y4Hbg5dm8X/r9ToYO7brg8F09+5dPP744+gt8NBDD2F/f9/PZHWZR7oR0MH6EyPCmlwLb2zwDBYry8hrrt2sOpY5cgZ/dzkGJWJz3rAExX/V4MeKBP9lb5wfxQmtmYDthYlDDPJ0kaqsVMgHLWJDTWOlXBtog0kY4gXkzVEZg0jlrSLAZHTa9FfNuEhCpoRItJd1AC/yqEiXgG9W4JI/okz0PNfVjbZocEbeUVWivK91Xiy5k3pxMwiZqHWnV64BROXlZzxWEMqG75oIhfuxpQqM6TkKMTIMJJEHDmWA7PoiugDULIzkTxsv0ZMKWcaNBgjLAa1XyfMwI2Gmm0IxEkDaUF2uT2kkBw9o4JPke2K0R8dWjBHBVQ3s+vFIuS5XKl8xQuQe9gBLYwNAtO9Mvn+i79lhpLpT5Cn/ZYMg9glJIF9U+DF/qYM1/JLtZEXfl/MCrFgXH3MxIh6/y3FJ5J2A4y1AQjQR15V1DCx6SCeFIimcaCRVgByL0Zj0dRDvZNyklxH7VuIX1me5rBEaBNzNRZpFG/EhN2mPSKeSRR/IYQMgxY06X97/S6FtOP9OtH+pj8nTZFieh66UUtKXpEVQAfjrizYVj/v20ixroWXLQPsJ2rhf5NDKeVFX0pJvGwL+t4fGFd70421/4VyMKEmkVJlewGQ0xvhhEAqgTxSBftfFE4hU8IJMKnaSylkwcgTT8VvY6AMTmSx+VQWpJxZCfUzDHptM2MiOlnkIyZMqz9RLaW30W9iYOE9rc29uGj+2cZ0RUgDL7cdgn2co7p2d4+bNJ3Dnzm1cvnSIBx54APv7+1iv11guly6uuCCxZ2BKFC5TDOKoF+WRqJcYeZIte1g0npZ118MEL6BbNsbLwowxuHbtGnZ39wC49ZHrrovijtwSrPPVErPZLN6PAXFjrbitndvA+tkjCxtnd4hgSJ8c1jQNbNdjPp/j5OQEjz76KADg8uXLuHLlCtq2xWq1cjNCXmoojvbCw7R8EWAPPxEU5BTHz2ZO/EyQvL+ll7eCq+UzJVhXYxBWLR5AMRhKojGXhdHnx5uV40T2M6slIYtFkT5dDupiDK9A/Hs+8YMY8CgAzcVWakxufMuZBE2UHBvybYFyqxWxUthCSsTXJgAeDmygB2CSODZyUkg1rTY0Yr3DOBM3ycoZMC2zxIl8hmDIoEdf7KuQ0CegJIYznv2T1Akk/OiZHMplpdQ07FBqOB0En5S7S/FhUSJmyjnGcuPMO06g+yv0N8FXVNaJj6TWDWNVw0XZL4ltiEBi+jOKx9jZcsahUm2wESENuyBLEp2ptHl44KVc/kkc983xnDFhPfAXdBTUT9yn2YOXqkSjK91E7Mciny6VjBWuC4U8uXLpPoGKLAn5OSdPblQnm9F5CKm0gpBATNLuKcECKIe8JVkF4z4F1OTLd5u5NWolD1IBhFNypYrXJTIt8jhdTpPu+WBZEuVzLDNfesf5MwyhpB2Tymn5Idg1PdaZBL/axGgJM0FctohHIb2oaGiGiEkM+GZzIWCk/BNM7jiZL1ik4BDQjm7ORIy1qNSTusn4iO3GbePHBHHtknI079TxY2zzaAD7GmQGVlZt0Sz/23OeweNtNfF6sKbfXCNLNEKh1dVUrLLU3G8nxApqgGLe8YX01EWhl+MJ5nJKOiUXsJlDUnCmtSxQfdqS90tlLwdyWamUlFqgKvVAi0GfKkvLhkeqnIWbYopNSbKeAvTPZ3M88MADeOCB+zFrTNgbcvPmTTz11FNYLBa4fPkyLl26FPLq+x7nq5WbNfAeWgIAQ2hME2Y55EyOFR52a6Mnxvr8WOh3tkdD7hjbo6MjHB4eomncpYPWAk898RQee+wxLBYL3LhxAweH+4CxODvvwmwJz1wYorDviPeNLJfLYFAACMsTeK9I0zTo1vFoYJ7tMHB7YhaLBR588EE3g+H3bDz11FO4desW9vb2cO3aNcznM6zFJYIGhK5bu43njTfQKO6LYcNosViEyxaZd7gteRkeG0wEA+sRtJ5hqC8PlIGNBpZ7JPhe8rFhYCpAsQI+YljbZM9AiY6wDJOZshSIT2bRYyeqoYECxGvLcoOA8mx8OQO3tEkrfn4v4xTTCZkgly7opSW6dCVOVQwbxmykRXrC0tvfc9lFIl2gwfIsbQk8yOzk5nXOX1AnKxDkeKVNa32tCmdNHvssfhEzBkkZzMvViojyS3REwKVPO5TvQZT0RYNgNAp6LPIyMi8xRbAoSQ7GY0JiuUbiBCYBtJRGEjJfpzRJM+nBoTytqg52sJmJa+iAgqhXzRHQy4Qae4iKKH0IOQZs1t5ZP1uK4DXES/GFKCWjpSAHRHUikMsFzBQ5HOO5fxtZblZ/bq8Ud6T08N8yrzsHViqLYmFpqsTWCWVaS6Fvq8ObND/JuhUptHKGLpdlMQ8KPJbRm71wf9yMRFqR1BDX6RtI+RCziysQ+mx8yXES84x8CHjTRtonQi77LIoMlM4qAjl+jHqc65LO6Iql2FbUX/JRXnQxXNDQuED8Rii3ioDN1pCnypBkF9gIfAZoUA1kkQmcYhrEPhVf3LOgNc8nrVe5jLE13invTDMQhhWnXC40lj7MrIi4TUN+JgFojIH1l+Lt7++7I2L9UbHGGLf86vZt3Lt3z900fniI+WwBEND7GSu5zCm98ZyfwxI9IRSNMeh6vyTJOEOgNZGNl0u3b2NnZwc3btxA27Z+JmGN89U5bt26ja7vcOnSJRweHrh9FeLkLSDOFjC4B5yq6ntniPDJXuG+DABkgJYawFrvLLCYzTxdHhjs7C5wrbnmaJq1ODk5xrHfoL+3v+c2wbezUKbcXxKW5hGFzf9pv/FSMHV4ANzSNV5io6ZzkQuOlDuikKfCV5GH/Evp8pBy3ul3WQ//UcjXymAKek8rbvY9aYMjUe7RYeQuZPIPHCsbK0GRUujTDLzYvE+KZKv65PlERZF0llBm5WU+Mu+anMkdH6V4WT0KjisZN6M1jev/pUKZaRhtN+4H9iFloK6UdpiX6kaG22smZ6at50xpJHLcALYT/eHI5SUv9fpFvrKKx0pAuVYHWWfHkxoFBr0wWnddhwhKYhWct9r6H4LeMIzz9syMpBK/GEnhlNDr9ovCq9BPaZ3jZu4qepO0VetAaEg7OkgKm7Rs6HUgIUsxDRjqktEg8y2jv4gr8wzS+usgl2R68BuKik7NiK+oUJY0Lmq869EW6SVM3CNB6FoZX8o5Daa1g0W3QdqINblnsu9F71OxLmG8+YJZ51ogGG6prIxL+WI/SBEx5vyQGDfEsJqfEheBexPkeaJ7ZAIkM4NlVhwNFzY0pilQHWoiY9O8nBjQHVYzVsbp0BakeA0GOj4znV5+GwklMrLlDEnRYwZRLe1QvLJxNEwPD1wyxs042LgJHdZiPp+HC/AAxMsC2xaz+RzzxcJfJAicnp3h5OQeWtOGI3bdVRj5ul/A71sRBlL04umL/Po+egbcngtnkBwdHYU83YlfJpx+1TYtCITl+RKnp6cA3HG3fON58EQIry4LiTDwDfmNlox23E93KaHee2N9W/H+Dm7mtmlgGkfXarXC6ekpzs/Pcfny5exwAX7mzfj8nojCZnPexB7otAjluVmvAjj1//C4qgYFgnRfUfIs7RINDqNSTfPQQFWUUaVHK2wAbiOtLt6XGfPlOAxQa3IpGytspJnKd0E3FdrKZVEfgzrPOB6l4ZXmPTQzyuVlZYxoi1oeQ2BliiNj7FCoIRqSjwJAi9cJvYWEg8Cr9l6m0f1XHi010m0wNnQ5NcDDRusUA2OoHvIQFgja47/D6Tm+bgcEmRKIlV59X9dKK8d/Zf8lcqAGEBV9qvyUdm34pEHybB5jeJyOxYt7BzhOzpcS1FFqLTP95N5nPBIFWk5DjZ/S3JPZ2NikiUwBoyTRx+k4UqSXNoUPhFB2olv8vw7rpaiN+a88lrSxP0Xe8nPMP+fD4brETzaMD05jFF1CrqvsrJaTRIUT+zQtEkuQ7hrIJ3lIQW1Y6f6ONCnaNsC9MmxwYV86SJikPE5JP7v3BUAxFjw3ZeIkKJq6wpDf9OBJuyKnq8yApS7UYcxokp7pWhia8ZBll+pXy4+No2p5cVSUaae4JI5BL1vpAGB73scAGNPg8PAQ+/sHfqO5wXK1wnK5wvL8HLa1/pZwA2vXWC7PsVq542Dn8znm85nbXwBkgJrL4+VKRITeRlAflg5Zt1wrxDcNFo1RAJ5PiXKnVwHWussR1+s1zs7O/CV/flM4KOQnDYCsD0T/au9KNIx55sHVde42swM4PzvH6empu2fE8/b5mbhfZG8XsHHfSBD+7BTyhlDf9WgaA9M0bu+BDaa58vNHni6D81LIFYF8P8C34jvxmb+BFG2ohSGaeLESStRTlM0U6it8Yu6v4HEKifLlJNnY97nIDZUQqUJxKYUF4J0aBEPygvtKifYkfZpGqxLRrjpibN6azPMRrPhdjDfxnfR4Tg1Z+41kII1JV6Z+T4TBPOo8LHi31P5JHxa5tcIfQzSofYpp3OQ5Ww3Avxnwl0CsjxGzq+s8CZSrywUFsHLgORrIRV2ZlWWzuHkb6bJt8i7SCkhHRF2GDOl8+Zz0MVdX8loGGnU5dayS/uAcGNjn6UtIpJaPTMA6XH/wZQiZrPpV5aH5JsumGISjJC2bom5MjdWQlOSDfKlBMBdB4R0XW+9HTlOkNyFgOB+qfnL14ziRY528Tvs1zoIQ4DFHsRSHNUQFcjHPLWFDviTjFeUPVP+XOG2qs0OGjW4GLxIlgpWgYSBe/j31zLn/AjgWDBpTjnscat/Z26CEcRI2MIV03sIbXqJlDGAMpQ1lTKSFiNAVvJFZGQVApHAgUdg7IQF2wxuqOwAMJAigsJ/Addty2aEH4eDgEEeXjkCIewru3r2HmzdvYrlchr0Ls9kuVqsOZ2dnYZMzzzSs12ugc5sye+uWOPG+H16vbYyBbSw6R5hXvD2sjXeY8IzD3t4e9vf3wHy7XrsTpG7fvo3Lly/j+vUrAAirVYdu5Td9z1p1iha3qSEDvoFVbqSXxgnfKcLLo/j2dVi31Or69euYzWbo1x2WyyWeuHkT6/Ualy9fxsH+Pu6d3gt94GaK3G++c8QYg5YvFLRKjQThFvpbKI7U25GNtqK08+MySC/BR5KdeJ2vfxfW/fZW5BXXkge7l5MVBHdMpWnq+buNJ9TE/T41I94lbkpl2EhAyUFgRRuXgqxHTjSPJ6hIro+EdFKbbws0pmUmtFVQrp/Z0cvyIolWnB/gjezkduFi2SKPbAOnkH2lMkuyMe1rSxJQIbRl2GwuZBmXn1+iOBbyE3qksywzyEBqrJXKk4ZwqW7xnah/AAqFfEoJC2UFbVwASWO0ZMkAuNvqhbxQ7eI2jUvDOxgQCU1ZxYC4VGqgvyI9XAedN4+d1EgqBzGuUcYBAQCT5ssmazuJKDQGKjk3Q/wa2APT7zZ6M43pahfJKiQ+SjzlxrJY5pfQwfSr+rNYT+SzNg7lAIxxc2PcFvt2tI8YSAtHaERubEkiQEQps6cO+TJv2OQbyypPgZhFKxqyVOAky/Et+O4fhx2G2rxAY6Fuct9MqS4uTznma9g5l+8XMSpK4cJLp0pCKj37vpKTariSZ1i2WNjnX9DmudIf8hpI7RT0Q3zH3ppC3np6WKRJtVCFrpTG0SAYtaiMCvkMezjz92NLzNI4vDGa7wCRFw0aY8JZ7QCwWq3QNE3YWG2tOx2mt37ZlY1Hxe7t7eH5z3++KrfrLD72sY/hiSeewOHhoQPZBwfOuGniSU+z+UzxXN/3QO+WbbVtG5YQuZOYCE3jLtxbrVbuFKtw8WAH7tu2bXD9+nVcvnzZl2VwfHyMW7du4fT0FNeuXcO169fQ+XzlhvambdBVxgDvnZjNZmppkxTKjWlh4Taiz9sZmqbBs5/97FDn1WqFO3fu4Mknn8RznvMcdepU27axDSCPq+Xx5qfv3c8gcKYZ1LVYrGRyhRm9KXkI/Ebl8VAC9KU40bFR+e7L8C+ETZMKkjLI8JFH6XIGnC+zK/e/lieBpFLTVdPlDhnRzhvMEmtZKNazS6IqNEzO2ybPlSCBszIaC9UhoYWpQKeiIQpyhK33GyrNiyhZ1ZaD8YC8krpP074tyW33nOfD2DYCaJt9z3V6iVKrvvOsqfweoFagM88lB+PlGa78nR18THWl7HoJ+MdxQa3bUj2p26OUTzV/iSkFrKm3Qw54y/H0s7V1emq0EtUwR2GvUTFT/SVNI6RfAF8qisRYSbtmdRR9yv1dwzohz6IR6b5Jvej4Ms9LGx0xXikEv1rIVLsHSjyXs3W6yLk2fv3pXxk21rnnY6KuL7QIs1p3lqmt5sVhuqExUEyIQ7lnfFLeBQVaBPcEAEYBpaE8yzTFjpcWvgXE6Sg5aMpLEufdDCi9iwQC8lMP0jgjbc31D7M3A+ChpsDk+9VqFWYWOHCcdeeOfG1MA4Awm7Xouh7L5RJEFLz2QelRD2v74NnuOt7c7Lxifd/j+vXrePDBB9H5TedEcB7+J57Axz72MVy5cgWXr17B7u4udnbmANxSqK7rorPD15FPlkIPoFtjxmfvr93GcYNoy6/XK78Ey6Dv1+g6i52dOR588AG40zOcVLrz1G089thj4TLBw8NDNGTQJyCB7+PgY4BnM3ejubzAL3pgXfu0psFyuUTbtsEg4zyvXbuGa9fchvJ79+7h1q1bOD8/x97eHm7cuBFOuArjSfzLv7KTbkv8I34Mc/ZmADddCkOYZjSXvpeMGUp+TInzdIMEl9KIqicYy/ECMrSgPAJdQ7JCNEZcDuL/SfslQPakDKY6XVIzVI3kNBsbmzAYiFkzTeQLT2zY4F8VkxrpCK/s5oyx2ayJBh5T+jvl+fi3cMiyP22INyyHma3wPR9j0RuegxYmNRja6nvFCTdYF4CnQpLJm0JeuQyTIepJW4zCbTEWcikhP5TST+mzoW9UKVPshbFMP5AfEaMfpcc9QyuUj1tO4/rbZvlT9i8UtamY081k1QtCbF8FYIvBxlSU9x9jCMnD3UWwF+U0mkJ/5UaO/ssPigS+08TaRPakPCoM4RKJ/j+bvKRkz048N4BxBCV95nKpuRXTmWdNa5QjeUWnC73J92j8v36JT995usGzXGX2QRoa1tpwQUr8ZrzutOo8+Fo+Q7MsqZKMlz6VwU62ttEDT9qA0acsjaptviy9l/ll3xMjo7gZjQerX8pTKpff8d4CTtd1XfDQx3XxdZpZsHXeMJGzIvzdipM21KbmEAc4Ozt3JzfNWxhDuH37Dh5//Cbu3buHS5cu4erVq9hd7KglS+gtet6oLmZngHifJhtFDOyZRvaea4zsjAemr+97HB8f4+bNm1gsFrjvvvswn89VW/BpVnwjOreP5FWeneB2kzMUTMtsNsP5+bkyCNnAcLep3ws3vRMZdGvft5SOpTjOauDemeUV/nbMleWX8mcKwkKf9vEixOybSF8MXnnaGNG9hlC1PptUApSWHoZ7clJHh9XAq2oEyeVgoewxuZCCtuHXWTRJS5+P7U3yStMV5VQ4j1+PaeZDJX/KuM+l93QNlT3mIZbLo3IZk5RXmL0N+TBg6Tv1fihUPcKiHWqOnEC3yeuSgX/K65bVJT26uECjOv43GAzhq6cXGNutL/MMy9L4bhHR9trJkdAibx/0Ia+/rlMZCPlv4Tbw+E7OrIx1ZwTbvSdL8wf/Jj+ep+hv+a5WvuwPZBjHvZPXjJbK0TS6XImgmi/s8zDutbG6/8NOMMGzqeji+MFDL/ovaHzR1ll/Wqi6VPuE+KSrAd4Ixcc6cHVz9KHrkJbFfMuBHX15WtHvqnwqyNde6cSaPI3tn+5J4nrHPmUtnNmZFXzIhoaSF00ej9MbRZouK3NscBQRvujBCTJzuqGxTlJWdKRoHL20wQvK7Eh3QmxMTTBv8iWQvpHRZ2vCIEEYCNbq2xTH9ktIwMnB+roNAR4nl9PvZYXhvmuaxgwtGa/2rfRelSnjWn1x2lg5pXZL4/F+BzZARC3SWiVU1fvE2ngngOtLk9EU2s64k6DW6w4rf1/HbDbDbNbi/PQcd+7cwfHxMXZ3d3F4cIi9nZ1i3/ceDEtlzqA/7Sd55K0xclW/S8Mbt3d25rh37wy3b9/GcrnCzs4Cly9fwc7OHKen56ENOA/reZ3Lc3cdlkFT27b6CGDEfQjn5+cA4ozJ8fEJTk6OQUR44IEHwnK2ruuAvvfeCvI3oMe+CqDJv+Jy2KBp2xa2i8vG2KhL70ax0U0c6I9cQd7rUx83kj8sIS7RI8BSXD5lEpZy9oF/mbmqeE02d0P0PKXjguNIGsMBBbI+IZnU0PFRAn8uU6Mj6Ge/fLdPDB2ORfKhoIeCoiEKt887OkSRnDeDFMTfTJQsnoR8y9qp1nciA9UGFwT0eWB57+tgo95xdIZ7ugM5QUcFtBcNliFezABzmWoFFriBNWiYVs/YXhG42+Rb1p/ie0jfRxCdG2Px0kuRU0KH1rthXCSeZY5g+SI+eCBVqLstGEiyDCDOxrNHNa5F1+DQVz58y04oIluoo8xPfq7VnTFNvsk7pZ9Q7lNemw/ISw9LQ8HfiUTcvrGsdBwTQ9UwZFP6fTkJQtTGBnTeiNmFOlmEwzDCvX6lfrVdvDyVIxVkDzdpiKPaPRmvTG/aTCK2bvvIL+kRy6r/mN380YPFSwFd5vA2hXK6ZXJE4d0iy+lvvm+zeEIGExDau+8t0Dt5Z2Q/INZN0ZXlCaTjnWfCXbtIWclGX7gxyOl4pPID+MJnPaMX9ulnW3gn49qk0SUITzGsbBjlNRYtkllvkCAwFeZczjCYT70WOlI5jaxOnnWdtbLsJynR8filugBSGfi2gBAJQtkMedPkd36XGiEyvWZ0DibLY3ypTO45KhlWzrhxxs58Pg/9TSC0bYu9vT1veMywu7NA2zRYrdzFeaenpzg4OMDR0SW0swa91YaUvotC1Ea8N0aDk6ZpghHQdW5Pxt7eHnZ33f0bbdvg5OQennjiCbRti4ODAywWRo0JOYsi24tnYniPTK2feBaF0+3t7WI+n4HItcnZ2RmefPJJ7Ozs4NLBvjMYYLHiW9KpSfLmk8RMMFDkhYdG8IRsO6aJvDRN+SQqjvIYzD23/JDUu5BHUCY2/x7y9+9JyQ4dlBenQGOG7gF10plKrDJJXiQ2h6ax/E0XOhClcFGWGoOhPeV3X75VOMHLvPIsRppvOs4VPyfvXFll4D4mp3TfyzdR+5dARqgj/51QdnxXMzJS2afbPgUAU5xFaZ5UelfQdfq3B13KyKiA7wFeK4+iAf1qdd25uhqsFdKnv7nNC7zKr6UxrHIkW61TzvPD/coOMJk2xzJ1Per6IDdkdFyx3GaAl9L3JdKlMVE8OjczlNxfk4wp4r8WsEbHlf0ajPtU/GVDNtkXloxRXQeRD3IZo7/FQlm/lMaLTAuKzjQg2RAvnrgeWVWqct1y9nmZ4fuEk8hUOmcMELh+0SiQaUYddiVjSf3OeaIinieHzTaDWy0kmFeHwHwJVJbAZvyevfH/RsjgbBgbTyApDPZUqJfKyRhW8EjuqaSkrChkx4yGWFcNaqQ3I/6uDDRRhPTKxfdWlRXbH+o5xPSZTDd4BPOpI9e4TnVAwLyDCtNKr3ip3Cov+eKD0LIu8753oHxvby+U705Udf9rGoN21sA00SO3Xp3j+PgEq9UKe3t72NvbQzQAXPlxiVhdoRi4k7763nn4d3Z2kjs/+nAMLy+ROj8/D0uhDg4O/KxBBznojZ+9SWmptbu1cZnVfD6DMQ2s7f3Gd6Bp/J0cXYez8zOc+X0ei8UcgEXXhbVEYawYQ1it1nFDe/AaxzaQMxuRO8pgiOtXM5YzTsj4I/XK5XxnrY0nUSExwOFVCfMldF6i5KhyBB+lgHnKzEwxJDIsKIOao4STcHkVQ2m02Aow1XRAt1eF78v5a2PJt5LIbUo+JbCuUrpY3ugZaovcmRT8eQBsrJ/gx9w4sVCdNUD/ePuKKjAiKQLXVPmneaVe9vQbz1blAKKkQMuymJV9UkJKO+MBC+jboAWNLFNJj7+sBvwpA0NRj4Z7c0Qf5eCvxDfD7/PvqcGSAH/i8YGg4KRRWgaBwg0igaMAyWXA6dK6PiJklwH5PkjbMYzlBDMo+uTnSFyQ9T3pdGzoSf5Te0QoBe8y3ySvrI6yugx6IkDXdYl1ky6sFB9l5UFcCGzj2FZyJB8ioc/En6yCbntJxJGybbUUtAXKQi6Bn0zgsXyMh/i+jUp4PTiJRImSR+LhkAUeDXxAyQKBaYpnsqFhoNdExz6Iq8ys/FAI7G2eSpxL48uPYxDWAj35pRSyYWU5BQGahxowsGFKtldxfU0HvG81UJyWKeuW/ub0qWArK74YP81ftnOoo9VshAq9ubfRRiVSKCedfcoBCQI4sqLMMWWc1lO952VVnoKw/Mfmp8y4ywZ7UEM4unwJV8zl8K3r3VGyJyfHfsN2C6I9dF2H5XLlLgQkCkfspnTGE55c2a1pAL/Eir8x8N7Z2QkbwufzGc7Pl1gul+Eo3729PT/zcBoMhdlsJmZSej9rwksZI6+z4nF84qZY4z4Xf1LXrMWNG9cw80cTL5dLnJ6d4fT0FPv7+2hbg9PTU6xW7hjeduZmQ7gurMiNIVjv+2KjRva7NCxSL9SUZXppG1vkoJuFX/w3TytFeKCRl18lQ0XqhaygZKxJIyM1osbAS9GTnQwrqeNqQY2dSkzPGVmaqmFRMOZDXc3Qavk0fyHDGJwEGTSeh6ZjCIwUZpACcBjI0+i2I15R4NPrPi2DlCH6gSmGJwHUaxCaRWUaUt4vyeGaHnHaO/SDiqgNpzJ/sNNBtJGgL6XdhIhWf0fkiZx3LWpMTwmtqk+SJovfYn4lfSlp12VlryAguogY0+txHx0EQ3IgzGx4fUyQbQTPgzmN2pHkZTGVZ5RTPV860ibmaR2QLckFWCi5JKNYK/Y2cENbFafAvWCjIZ8R0vAqAmdAgl5ijEZh8aQqJ8Lp2viIuokyIzJ+1zxp89marISIR7J2EK/YgSlhf5+MKyKCsbrtS0edk0nSgeJ4FzIo1rEwG4IY1wR5k7ddQ/UlbENh4+Nt2eCoBhsHJVuF0ZIWQD0wVN5NmtkEwPDpWZZY33h+2ZoYrHrWoFQX6UXPlTFiHYi7RXi8BK0631gfWYfcEyHrrRlgOFhBmxxEUjHGuDU6A31JnunSJ0mX9a0Q2qICBmIbMA9ECoJADjSU67uJR9havWGa6bI27rNwe0kIRMbdB2L9Mbu+LNv32NnZwYMPPqjuuzg7O8Pt23dxfHyM2WwW7riYzRp3r0YA345ePvHKAkDhng0iCkfSrlYrrNfuuNvLly/j0qVLoQ6r1QpPPfUUrLW4evUqFosFiNwmeMAtr2LDIy2fN5xzOfJ0K/7NR//ypYGLxSL8Xq1WePzxx9H1FpePLqP1RhHgTh6bz+exvRNAxftGuB7GmDDO++T8/aH+LhsfueK2bGRJDFuYeudlI/IliVw0jJDOFCFHNCUJbfm631K9SqFmaGkax/OQlKXAO82pZOzVaJZtk9FTql+guzxLSeWGkuSKeGWgni+ry9tKicmkbJs8u6jimNZAv6ZqylKnsuEZc446IeZN+oWiQ0ERnoUu1ZXf2gK4Ceho2FCqe0r97MFIGtYjeU0K8VV+dbq0Lsr5mMTb4HBRIEoygZYDQ4ag099aH4Y8Ke+zkE6Uwf/Gi/fKsi7qRt/jFRmi43g5y2BZJgoznbEVInWKWBVDOwni+6J4EvWnAqDXJVqZymOPtExdz8GllJrFPR7U+4YigE5agWQcpt19104FSTGPP1GeiJCyAcl8I9BSmZCiQ/BL4HfyBus4n+qyc/7ieJx/1Qee5w42XOR4TfHrlLCRoREZIApeRXNxYIqqy4bO4sVIztiLno/Y/4lXnwVoA/To3SU6XEboqHyPgPauEEDWH3HKXgZPNxHaEDemzxFP2fQq1S81rjIhhrSt07RSEOR56CTSs6I3srElb60Nc3LZ4GWSrPUePyX1c6HJ5SeNERk0H6mZaps+CmI9KF0vbkHhVBe/fIYNi2T2Af6d9cCbgToRhSVUxjwr0NY0DW7fvoOPfexjwRA4OroUZilmxuD8fIkGBo3x92oQBYPg7OzML2eaB5plHfhCv4ceegjWxo3fd+8e4/HHH8d6vcbzn/987O7uYL3uwl0ebFxw4E3bsl25v5bLZVi+JduNfz/wwANo5+7I4PV6jZOTEzz11FMAejz00EOYNS1WqxU628cLAnsbNrav12usxXghcpvXrK9j2CwoxqF8Vt+AjDdlmgkckgtjigowZEMpJEnGpvIgeZ/RhJmYIkVDcfxYde0WjdTJ+Vn9bMW/U2lI+4WDvPyzlF4ZJQnYTgpA4obTn0PZ+YxYWl64qC/RoBb1OpZAogm31VuQ95GmJaqZy6xKU/o9rzZZBssDxp/8xvJC1yYrB8l3dXLOCO0p4KJCnDwPDW5r5ZTBey3EuDXjmAHZEF0lMFt+zullOkidNmFDn6XkuvfIvwsQxHqpXPbYWLWxfEpANcezMW5IWgLoLPGyvkiUuMDKTTB9fXrvold9k9Y9qyOCsEj7RusCHouxHdIRSECY2ZCVTw0SCT2KBzlI4RXe6TrJh1K720T+uKjcVpxHDfvFSyAteeM06AKZq8DPoeyKnBMFGNhQ79TIExUOdBUdQkkdS3Wohad5M7hX1ur56YeaV2iqoASQCaUI6PgdwNAirtHztSEqDpRnKjxT7TSU9xA4uUj5AZyREkFFAZHYUipsZkaMUhWPNwSh98elCstU0+g3UoebxuH3TACgplE5S/DNm68dH/XY39/Hww8/7A0Gt4/j9HSJJ5+8hcc/+jE873nPw9HRJazXHZqmDbMrxhjs7u4GA2C9XgfAzyBGHq3rZj3c8+7uLh5++OHAy8vlCh/72MewXC6xu7uLy5ePsL+/h7MzPZPDS6fYYJGnZkkDjYiwXC7jhYjrzi2V8QaXuzDRtcmTt27h5PgY8/kcR0dHWMznOF+eqdmVtmm8jZpu/Nuwh+mZ5hmduVpHKz8NJtMy6cJ7M0R+Jc//kMyrZ4YUIzyt9ts0/TMp2aRBM9YWbDxMaq+Pn/gdKTdvzWj0TsogSz9WRslLq6MPcjoiMJ4WxO1SwyQO0CDHU9lOHcu/tOxNO1s2CTKfMJMg6jjKcwFzXJzxgg2x0WB0YLW0aEriyClOBx91WrFZzDEeHMpHt3vAIJvKxQkhYkLmlUJdRo6AnlAKNh1T1ZwqDp/4XbRt6vwlCuMr+jDG63ZRuje/sI/0AOOOnxrG1mdLq1xMnuhvnI8cBP537619I+iKnnweeOzxEjWzNhyn5zL0hdu4PlVQktUrgCn2HEXrK6QIZVZud0q9Ap7iYv1LHV5kAjs+NsiygSAmnWtLV6iuRpQHSLqKIevjrXICSjca1DzFOn8fegBdFEQNEaxhPugTXgMaf3keA/+Op1uZd8QGayIqejAdcAdmM3cC1L177uSllhpcv3IVV44uuZOfyOLs7B5uPfUU+r7D4eEhrl6/ivPzJQD4k7Lc8HObtHtfpmslNkK4DjxjsVwuAy03btwQ3wxOT8/w+OM3cX5+jsPDw3DqFpFbCsZ58aWLsq5EpGY4emvRr1bhPcfv+x4HB/s4PDgIeZ+enuLxjz2G8/NzPPDAAzg4OACaNrk4MC65y2T3BLCTxqvxiPGWieMy7XmM3m9EFiRSRz+qmRRBQckbyv4lvVRJxKsJbjUgjYvHspCieqVCPUdngWw8vpAKJARveCKiSs6imhe5RE+oMllB//jJU6XA9xkZET/kn8hImzxkNMpHIp1G0cX3+cREJV5I6zIpFARwIxtd5JmCYf4ZwW66DFBv6My++zys1e2f1kMlqc0cFEP0sPrSsxgkXM6luun3uce3RAPvQuDusgDcnSIy7jCgq3nRAw0kyyy0GZzjKdLp6I93wXF/leuf1zcZS4oXdH1Ca3mvniNdrCGHaD+OLxilPKGYz/5EY88fO8/xmHbRR+lRsrqO7p0+bBpBDukkEuTrdifxW+cfAyE0fTBWSnv8SrS6enhsWWCdsMcCGdGIMyWSbo85lWwSo6Qwlm2oP9QVChB8SmKPmSndNJjSpVSUEopePowZP/lx1Mx7U8yI6TMa1qJHD5ApNNKwMqopqyELSnqUiwzCxfpGNv4kJO7iqOQKG30kD4nBEQ0nF8FaMZAUcck7FlBCoMp1oko42HRY5Aom8rgWylwPa6EAxCgYCLlpY4LjhzQDfaOVQhnAxPK0klA4zCKM1sg+ejBlBqg/uUK+MgBMQ/6eAYrKpuclcFYNRvJ1stYZQeQrIpVN2EQnjBFud/I/LJ8saxqQ3wQNBp0EzBdzkDFYrtdo5zNcvXYVANDO3MzG3bt3cfPmkzg6OsSVK1fCkis2BNrWAfSmcTedB5FlAdv1bura3fYV7pmxsFj3PWAMrly5AqK4cf34+BjHx8cAgOvXr4v6dUEBujJ69J3rlwYNyJA7cKG3bl+LVzhN0wBiSQ8v27px4wa6rsP+/j6ICE88+SSOj4/Rti2Ojo5wcLCHVefuGWlIb6hPZwXSMV8Hetz2Fr0Y+zBRkPfwRxFLPrdSKXjl55WYvCWe+UYKeA49GwVE8XADjh+JLNLtzsEqOCOKADCOhZLhm4GTAPz8iVEGaKjJZS3BKVTrY9d0jBjssvyqM4DzhlKnit6a1E/lZAko5vXlcsvAQNYj5i9ks4c+lummuGY+6KBCufViNLB0L/NlS72NbpYa8M/GgdXfWUcxfWVHlL4QNafX0Ro/5b2jHEiQui22l5LhiS4wXJ9C7nIcMqs5mRqNbiaL6ZCrmNIqxbZPaBRynvtIlQcHJXhIuM20RqVL2yLFFq6u0XGhjYIyfwqRlF08F/vairgyz9JyOFvsayn7tCHCbZUaNZo++TutBvnOlRhF90FCC2Lb29jgYMNA1jfDD6Rpc7ojoUcYdxzdVNqDyyCy6DruBRMxWMpfLJcg9yqn/FZ4B58uGRuAu7xT6hzjMyF4fvXvLXgfamxneX2ZrGIu70m1u46XYr26rIvjgX/XL8SWYbKhYcNNiix8I8DTQr4kqPLXYQ1aCpL9O5JZZg2BsN7bZWOBPnYIN6hiZuQMEL2tKXC2Il7a6OmG7OSr1e3kmFYvUSFfYFAQKh/NsMEbK8AYb4IHUYFRHM25cGIOo5zZRMOxByAOcCmZENKnozsMhgS4sNC1ImJjDTrboW0Jq3XnB0EE+S6dY+AGfDma9WvjgX7dg5oGFr0DbdQEBdESoTGE5cotVeoD6XEttJu9Mugk4b6NG8NnaPQwDaHrO+4I9LZ3oFIeJs7giwAi4y97dKYOtQ1mTRsEf98Di8Uurl69hvm8RdO0WK873Lt3gtPTU8xmLa5cveKOnoUfc5ZPkaBo2IQSeCwGaYrZfA5DfiO2BXYWO+B9SqYxMK3Bk088gZOTuzg8PMTh/oHbHN71IPR+r4Xbd7Fadx6o83j1l9X52SKmwRKhnc8wwxwwhHXXY7GYg+gATWMwm7nb0I/vHuPk5Bj3Xb+Bpmkd1rbumOpOjg3BzxY2eKccXxoxQxlwsnvfW1hjQIY3pjsHRN/zxXeOSRoQYJzcIH+ZnbXx+EAjRiTBz5JZwcVqcy17l5ggyxBfjw8BOizKYJuYpxABJIiiZ98XqXJPdTkbgfyZCuuaWR75cdqTVMRSObrCDHtmmdNYwAagEymK3acBgFawOXAqyfiawgsyAvmcqASCUr7HHtLgwCC2M4i/6pjl/CuBWFdOqItvNpu99HXzgJuBXBgDTAexwo//pfnoED3+Ccnqb+xE3TdubFhY8oY9yXkFzwfkvOVr28P4S2oJ8L4lQu/vLQhGFizcXQaOu/ji1D7wvNPtfFEYifp2fR97kygATKaa9+VxFQgMwGOj87xkHPdednunauBjrzvZaCSKh0hEJ5hzADm9HkEiA1l2ipEBrKWgOnp24hrvuOi9rM0whtyfIw9/kTqaENzuIS6A4JSSHCD7V8tUxipW5SHHkQw2GTtyFCWB8WPACbnc4Dw5F+cc9PumfFsSGc9uoSOTcmQeuq8U3aI0Q/EG8yABuDMF/eFEp/Ap7SdfTxvLS7LQ41Xos7QuYayD+SjJKzSc1a1O/o3XbQT+6/GfrL7sA0Qe0ThRSFAh36c6YKbPaPAUrRKisZNdf1QK5TEKqZz8h6SBuRECKC/IS0KcXg+Cmb1uGQ220DHiq9XWaRDgAcjpBNrjVKpoBIAZ3TJtyNkLZx7kEsME+mMHW5EmrZumw5cp2UeAGGX9hoGoBwzXMcT1gDks8bBp62h6Q4skkRxopjjAuB8lU5NTAgY9bL/24t/AGHf/hbU9QE44u98Uj0C2PVoDr8D8cbpEbkN7D5ePVzF96HdfrlcahpWoiTd2s7ED67wK1hhQH4U9eb6xtg+zKU4Zx/7b2dnF3t6eB8L+CAJPN3srVusV7p2coG0aLOYLtI2b9bCd88z3sN4L78aBZe8fGbAhZXsH0OezOWbzuffAu162ZNGTdXrRuD4/PzvDvZN72N/bQ7szA9k+gAFLBGukChDjnUR5hrzyt9jd3cHu7k4Yl+5ELrfMrDEO/N47vYfVaoV21mLub22PN8wLkBiWw0WFqGcbDVxlXIze9s7tybxlvNz3PNfD3yROvSgnMLlSxOShaDQyoBSNoNKLMwYX/D4PbDiWjp3lIKVP+NZLVVLIm+TZSeXAMwphw6Eoj43YBDcK0RHbKso/OX4E/UIESkXpvjGsTOVevT3SfKSnr5xGOFsCUBTARNXcjdMif6PWi7UQeUUaROlMBYAwE6agjyJP60lFB0WwEsGHLpcjWiu9jkn9lW5OvyceWO43CqwIduBA8EnHPwgOq3dcjncaGPbWcn/w5ns/WMMRnr0HlZ4W6f2GB/uSPhLGMJKxIxvO6keXloGhc050Xe9GPo8DAdB4fFvrbkCPl5YKEEcE6uOyKkZ8fGCGr2nU5xAnFEpZE7pF8wCRxBlCdnlDg5eN5sBCtNUQY3tdFvOIbctPkXKr01mBHUR5LEfZicn947WuwD7aQIDtwR3BzhEFztMDFgZkkfquBp5r0wBHFIZS0UJ6jpe6jeQxtVlRXG+bzqABonFdxHBRXLlegB9fqoI2Ro4gM+obz7wC8cL48UwFulMeY8d9Kq/HwgabwW1QUlFKaFIse8yrolkKQtEKGwROmVayPG1cVljyG9PK+zM0PpADOEls46Y3vUxKZSDKSvOs08RMz/xTXD4mmWjEquTuqoMCy1XK8qp6FRF4VuQjFV4cjVIo8Ug11PhlNwZ9L4QmAbZ3QLolC/QrnJ7cAQAsdnYwW+wAsxarZQd/XQWW6x5Exi0RWfWAXYO6FfoeMLMZLDXcy+j6HnNj0PdA0yAYEIYIZAy63nu4WRiSgbXOGHCGgJhOh1WzQWzwBC8ji+RgPUtQYPzFgi0uXbqES5cOXf7G4uz8HE/dvoO9/T3MFztulmC1wup85e7UaBuYtoGF2PhNPYxpnY62zqhy3+C9QE5LrbsOh0eXcenyJRgiGDJYrdauzDu3MZ/tYH+/wbJbY7VaO4XbNJjv7qDru3hpYZiBYE9kHwBgesww8+/h4SEODg7Q+g3yp6enuHfvHnb39rC7v4++73F2doamacKSMiJSm9o5/wBWySn6rrO+7V15TeMVru08eGgBNOjh9sN0PZ8bH/mTLCMjweHEM46sJAWvWk4b9yTp2d3hMDTW0iVcQ3kUxb0Esan88CggLhmpjPHEQNgkzthsxJT3wakxkSb9LsqgKHqjERVmVSA0vooMoWOlRivRI79GHafBewIKM/VXks0pkIxlBrBT6RqSVVJdn+SVleV+5zrUAyrrlpvxunDlbPIDqrc9qOWT6ADb5W3W+/rznkp5CEvc39e72VlW+h7gGF+GMeRnkCHSiD7wS0wDcPW6KeBSkisPAAbJxhjYLoIqngkJbSrlhpfpTWPQraN7EuRkEC+1cbPhgGngLnNlNvAGc8MHafReH1nBW4LFIk/FJXHub/wujS8mOIsX/tZ5TD1XnsIII5kmznxm/GXZQOMlQL4/BB/xvJvGLDxbxfWxkKOSC8yGA/dbr5rRly3GZwQnIS/+V67uYD2qS2IGlVJbyBph7MmWC3kCCNMcgu5CVURg+SXwp5RXmWGKeMId8X4bC2uiwSu3ekjZweMAsHC3A8jVOdOU3cb3aITlTarODP1TBhzIT4rhQuQ4RZh9EIMnp2/KzvmclhjKS01tMf84iUkcK6t4XEoVB7rHaYpupVSJB5oWAtwmVnKBrIcAWnnQArX0rW4gFgLLP6HQShYuAy+53tl6BicQbN/5uy0AYxpQa3B2eo5m3WF3p4HtzvGHv//fYAh46DkPYffKNZyugcXuHtb9GtQbgAx6a9FZi8UMmKHH+//g99DO5zi68SDa3QP0HtjPZg0ass7LRj2MB54E52m3ZAFj3EA0But+jcYYtKYJswR914E5mAAY45RD5wWVKWxyR2gr640ccUqWN1D7vgdZws7OHh567iEsnAI6P1/izp07OL5zB5eOLuHajevoYdH5E6ncHSFA161hLdCSQdP48kDoLSssg653m8mbZgbqe3RdD2sJB0eXcf3Gfbh3fIpm3qA7XePRxx7HcrXCpaMj3Le3G+74aMi1T9/pi/riyVmrcDO6As/GYL1eo+s6tG2Lq1evuPtDyG1WPz09xc2bNzGbzXDjxg3M53N0XeeO0u17zOazkGdYKmEB26/RUIvOz/i0sxmsXTnlDrfHhNhoYDqZeckbtn0H4w4BhFuoIa/stCDqPP+yQnAgw3hk0fB8CxkHZSpDKd2Lwr81n/AykWQ8yT1HGZjw75nRCt/SMop5CRmWi/ky6K89V/dxjBoJ4+83ySvs1eINVtz3iHAiLHcq6BQJdoo0JE8U/pWp8/hJa8V2F7xdDqK/q+3DwFjryrrxVjdr4+xRzMewsSDzIMCSW5bKxHe9t+O8kQJDIONkIMKRwrEv2Kgg9FivV6C2dV+sARmD1lisOwvTWAA9DBo3Uwkgm60yxOaRJ9KKvz3izKSTjTCE9dK4JU1NCyL/2yIYHk0LdB0A27v7lLoe697Nklq4s0mo7bDu15iZeQTMlkCNwcp2ESyDl0V6GtfOc9+SX/KZ9EpNP7Mh6NhcOEDjFIE+1p3fUeTr9JCFsLqBot4KADtpZjmSXH5Ayf1BvumtRZxxzuoicVXETsYQ3IyYQmuB0pCmUBfA4Tq54lXBWG9nEDWSHX2+TFciI8U7Vx63L1+OKWWGWP4bCBJtL1Zic/bEYya8iKwa6sAOv7QRvaeTwKs8osOPC4rOCscvBn0Avzapm/uvR9fxbySGRpNSkIWNDY04MPNvve8l2Z6y7oExpB5ErhdDI2QAtsBkbJBIwBtmW2RZ+eBT9bHina65r6OoR0KXBtu6k0oKPXr+JX1iKtACdYNpSHkXFIgiuNSOfpmQH+C1YqUxEYoKyiv2myhdl8hpjOdnG4fRvJ15sWZx9+Qufu1X/j12bY+/+nl/CWf3nsIH3v2fcfOxR/E7ixYdET7tRS/G/c9+Dn7v9/4An/3n/iIO9o/QweLs5Dbe//734ff+239Ff36MvYPLeM4LPg0PPO+TsDi8irV1E4arDgD6MNCahuvup2jJGSWmJeztzrFe9+jXHRrfTtEDTKE9WECu4dePZv2TdY9o2ygEnDd/7pSMtVh2zjt4dO0qDo+OsLszRzs3+PCHP4qbN2/i6OgI169dx2J3xx2F27v1rB2fxoUGBoQOvZvh8bMBa18fY1oY73lbrnq08x0sO6CdL/D8T3xe8NBZa3F+7xwf+MAHsLezi/vuuw87YrmTPGFqZ2eB1WodblRnA6Xve8xmM7TknoncpvV15y4/5JOyAGA2a3F8fIwnnngS5+fnuP/++zGbz9A0jbuLpGmdwei1Rt+7e3SIgH69hlO8zigJyto6kWhN6wEIt3sHa1wbOQaV6r0PY9XpXYrKzvep2kPhmUE5LMrdrsaLHJliaCUPDOiiMLJcpiyrACbLgTOPcjkbrxV6h96NfWNZlZI4YlMMBm0UVOou+olkZT0PqfIL8jzLTmp9CQYSHZdyQOpdlsVFIzrNX5RK+p2W/d7zG048qvWZzDPXy+UgdzTEN4R4RDwfymAAoAFWyxVmhrwzhABjsFwD5O0H8oqbl2QZAa1bf9cQL6cMMyHovWyBaCseh14e+C7pPcCIwFcvzeSu6wHYnoAGOF/1mLcNbAd0XY/WEGYz48SCBRpDoIbQdWt30iEAazvMZg1Mh8BLfd+hbRoYMm65Zks4X3VoGuP2iQV9yxjGLWNprEXfdbA8IwMejwX9LuuS9tbg2CzHUWCWIgc6MCo5OeHJ4IDJyUlnHkyQybxw2RmmvFy5IQbZBLeCAPHkMs9f/F+cCYtkyVnlcEe6T+Dsbs/BYRZayz2FwwLZadu7MVYSs0ybMoTSdhY4Ip7KJmSXgmrR0NdkMP1cGj/7Wtv4zYk76RhMDFE4Y4Kp760NvOn+OqObZ9n8MPTO1fFw4Xs0SrjJyN5GbNwwTRMakhlB+32CTuV/khMpVNkWYQouZtEL5smnCzkxt2+cMIjMqg2GQEyML+0TlXfe4Kl1nXuStICvewALhkJBiJSMndz4iMSr6bEQwadRjE75oIr4BBJV5UaXpMBZ9mRs3BRIDbq+A/U9dmaEg+YMf/je38bZRz6C3/mVt+Krvur/iQd3gf1Dg+PjJ/He970XT/zBf8aNBx7Ch9//GF788MO4TYQ7945xfOcpvO+//me8/7f+L7zgMz8T/+V//1Uc7u3gWQ8+iLk5AtBguYq3V6+6DrOZGwK9XzLVzFr0nZtxACzOz7pwSlVvO7cEx8/GEJwy6fveXehEBmSNanHNezau3rB8opXJDJN116OzwGLHoO8adL0bP+28wbqzwAq4cvkarl65Ho7NW531uH37Np568klcv34V9913Fctlh/W6A8iibRp0nUXXW8z8zeCdV2ZN04CXUvddj/W6D5fxWTiDpzEG8/kcL/ikT/YXGjolfPv2bdy6dQvr9TrcLdJ1Vs1oSO/Her0GmSYsh4pLrdxsh0vfYbVaY2dnN1xcuFqt0LYt3ve+98EYg4ee/SDmOwt0fvZk1u7AWsJqtfb3kjSwtoftezRoggiGNeg7hCUXTuK36LGE83h3QggRyPLsRuv5NwI9CwsYi94bHzwMUt/wKH4TIbErdD4sT0XcNMiFX5NUQG0z5cchRA9YadaVaz4MntIgZw+npdBtHER6Uv8hx0AWNmi7cOym0T1tnPdFHI1aAzJjREnBHdfDF+mVnt+qUair1zlU7WSW39dg4A5YcG3plsJ0K7estW3d7GLnd5ZZS7CN62eeveAT8Aw5OWRZ/Vig61ZoGoO2ceNuteyw2GmwXMb4QDzIIQA7G/PRYJkpjfshLABj3SESvPezbf0SHiIHBP3MBnns362XQX67Ayd6rE/XmC0WAAiLdoG+s+hWHcgQTGuwXK7Rzuaw/RqrvvMA1IR9G51l5iA3dUJ6OUveN9KAKvcd/61dNUkicu/3nFDpu8xT8KUsg0NVLgk8ZeRmerYDLOLK1dQ4qNGjSiQVh8R/pQxc+d4ZBtYJYeGWj+PHUVgWRaoe6fjgJb2yFE1VQpwMwvBh7MlAvswGRr2nMLMXS2TqnfEm4H4Pd3iK5/+4JNq5Dno28K0BURNkd2eta6MNvUIbGxpymVCtrBRoOvBJGQcq5hQCVnaxbMkYXwPbAOgpNjT/p0+c4rQJwJc0JFyZLpmKThNd+Th7IDvbs3JmYMTfekZTniRRal+/UZk3y4kItqA0FBOS+JG0Yzi7w38S1QhJsraRz2qwlWesQnqy7r/eHyMHt5G4IYfzupXF857zbLz3998Na1f42f/v/wd/4X/9szg5u4P/33/5P7G/1+LeU4/hBCd48We8CP/u3/xLnBOhWcyAbo0nHv0QgLvYNyugu4fnPvs6Lu036FZ3YNFgp5m5hTGmgbGNXwpk0RjXF7Z3U9sN3BIo6xbLesDtKrpeW3QgzBqnKNgCdWv405aP7RTaNQhpEzwLvIyqbRt//CvQr9y4Cd4+v1m8W3VoTYMoaNz3o4MjHB0eYrGYYbUCjo9P8cQTT6DrOly9ehXXrl/Fak1uNqNtA+jpuw5db9E2LWYzg2XXowFgGlffzgK279F6LcBGCgAcHBxgf38f1lrs7s7RNMAHP/gxHB8fY39/H5cuXcLu7i5ms1nwTPZdvMk8HM9p3PIpzpd5mvl6sVhg3XV47nOfC2stZjN3O/nx3Tu4+cQTuHr1Bq7fuOEAg6cxOjzgJyniEd2sz1nDhY2obCaE4eRlBXwmFE+lYlVpCX7J1DgyrQG6snJ27a+Xcw5BC1fZKHmgZKJyejAtwokxlO/UtbhD8UtevTyOp2YCyJfOJJYzCE8uRp65WNtNOjolgmuoylPqEuksP6fOM33Md+yR8eVjnMM0y8jFdApXbVHIyvEOgqQsTtLALX2lxjmiyDOrc0I46ts54e7deyAizBc76K3FfDZXZqXt+7BBPNDhnQumNTD+8s++c06A5Vnn7hQ6X2Mxb+JsSm+x7jssZq079ao3aAKgi52tsUt0MNrOopkB/Ro4PzuH7SwW8xnIGvQrtyekWwONcbPwvTcWYHu0AGjmZOr5skM7bzGD2wPXWwv0Fot5i64HGmpBphcjzu+l6y2W1mJuGsxaNyvjNpiXnAHMw2VjIyzZidEKXBDjxhOy8viuhDqGydMkYwNw4ykABYcB5GyUCwm/q48So5Bi9dQpUJp5yVZbWH90vCK+j/QJwmO7kB+XgDgKMTieGPvEsrxssiUaxAEjori0myQ8TFs1GGXiXORgtAUwJ2Wq11q8HKq3ypK1QSm6Q2Us2eC7t94h4GwRlzeZKbOgLmy+dCoLEuCmgNTqRszkmI0Cj6Jy4T4tTR3LMqQnOM5e6L9jdQnYL1nmFEMfaQIgPYCabQTDBQb1HaGUvPQGMFDkUxg8DQnQ1yEyLQ//MkSIjJbfDMBHybp0RkzxRMUt8rSyzm6ZjQ1HXvrBF2QDM4DfuMdZhFOL3Br4BgatAbp1H04sAgG7uwd4yf/j8/Hsq5dx7+aH8c7/9A68422/gp12jcOjHdy9dwv7OwSyd/ChD/5nHJ+tcd71QOMGB3Ud/m+f9Zl4z397J17w6S/As+6/gsMFoWst+gZY92vYrsO73/0+/KkXvBAH+ztYL0/RrZdojTuN6mMffQz37t7Fyck9fOIn/SlQM8PKAvPdfaCZh6OVeyKYxq0Fc8uu4BRt1l8C8HLbEsCbx3kNqhXOlFnjbuc2fvrcWg/QjQmC1PnSYxGNMSDTwPYGne2xmO/4S/0sdhZzNAQ8dfcOnrz1FA4P3Mbsud/3YG2P1XoFQ34PCwHWrsNG/YaMW1oA582MlwRFfnQzET2Oji5hf3/P35w+R9+v8eSTT+L09BQ3btyHg/0dWGu8x8TxV28tmsYdg8s3pUuDxhg3VmZtC153Dmqws3+A++cLLBa7WPc9bt66iYYIVy4foZ21WK97rPsOpjGwxHeP8JHFLHDh1zA3MH2jppzDqCFEozN4now/4dsIKZEoZJRDccmCYhuxlNJ3cg8xLkkABAWQ48VzrGysRfDI8lrreKGpkIXJlGUY0yy8e783SaSrO1F0XvHdsHyWs191mSyDkG3MFplHRFEo/hYAQJDNMpmcdRY5peX4EO/HcP2V3csS0oqNyRmdOkTHVdmIkvoz0iOX1ul08jhjly7txwBXEI3XuESKHYPrbgWi6PRwmJrQGIPGuH1jJ3fvYrFY4GD/EKsVsD7vsJgboHN5rb0YQONmBgw1YN3SmNaNM1+5WUtu+PbADhmnu8g5y9ZY49yuYYiwxhotWsyoQaTenQgkHXS8x8r2PVbrNbqzc+zO5yBY/MHvvw/PftaDuHrlCsgQlssVbj7+BB569gNYna/Qzhq0jcF6vcK667BY7GC17jBrGvQd751zNFoL2FWPtjVYL9doCGibBiDe2+ecTACAjuBsKjbg0n6VfRTlgMIGAXDWQswn7uMhxWcRh8VxzYe/W5IIIZ4MpugK/1FOiJe/RCSM3RS8RzIVd4o2iWgmr5eezeM6+fzVVJFVF42G9PwfEYhKEt67p4QxHmogBQbxUrGIA1R1/N+IBvNvVtAv5S8RwTZWFqwzhw2z9+HUqdDX3sA3fuae76b27Ua9wyRdD6xXwLpz9bCW/H+9d+jNMBYmGxp8IR4glUvecFr22qDcWFmli6WUCFT5yNkEiIFEkAzJ9Mj4ksZRbxAS5irkwRFZkIbBl+aTo4WCMBAKzoP0zBNAJQWuFW8wuCCNnKRuBFDDTFEyRlSp2pNQiJ4OMJmBagumrSRcAKD36z17v2TAG4zuJKAG1+57Fv7M//o5+I1f+QV06x6H1y5jd8fizt01Ts6AxlgQllgub2FnZ47VyT2QbbG/f4BFM8etWx/B8573AO6eP4X/6/94G47uezbMYg9mtoP9wyO8553/FX27g0/9hIdw5/aj+IPf/108/tGPYKdt8ZyHHsbv/rf34vq1+/Ced78XT37kA1j3wMHla/jUP/NnMd+/hKaZg+2KXh47BVbNkpFjy8W9KQ5U93waC7HwdsuU3L43N8sSNlFaIfjCAex9kC1x1t1tMu8BNLMZmtb5341xy4pmbYPD/QPs7e5gMXfLi+6dnOL03j1YANeuXo1rZInc8b3eCLZBkEUQLPu585vD27ZB2zZ+c7jj2b29PTSNe28BnJ2f4vbtO/6m8QPs7Oy5k1u8YcGnTLV+mRdfDChvb7eG0JgFmtkOLNxyr8Vi7mYJjcXZ+SnunZ6BjMFiZwftfA70bjkVUVzTHRYMWKCxvBY57OIIfdSj98ZF6jOjsBETYiN4NEjKIZ0t1bOS3NLxm9734QcpMf8EYkKZwcnBADURWPlsbQXckziRDwxKhFxP6lOqSwyV5TwbhlCWqG/6Kz7XTgMs94wcwZm8reg66SSLc0o25lUqqgDwY1kSNOaJg6gW3/TvyDsafDGd3JsWhexDXeJfq9rEAWm4pZBkAT+TCDKwaNCvV2gXrZtR6Du4t+7469XKLSHqyZ051bspQcAa2L5zS5G63u2J63im2LVpt1pjRg0+/MgHsLszx+VrV9HszOBmJXv06GD94Rx8Op7xg8kCDiD7c9DDKTyWgL4DLc8wQ4f/+B//d3zqp3wyTm8/AVy7jFl/iLt37uKd7/wdPPLIB/D5n/9SvPe978H1G9fwsY99FI8/9hgIwEPPex5e/L98Fj7ykY9hZ7GHp558EteuXcN8scD58gyHR4eYmRlsv8atJ57A4eEBdvec3FvByTxjWjGebcKHNaM+fpf8YgpMVzKY43tScfiNeuYxUBNqTLc3INL0IYY4rkxWjSiPT4IoEgOex1ptfEn5xPWL7RnbzEFLG2bVEjHpxyOBT0FLGy/W0UZFLGWqyFOJraAfKOQTY3r5IR/DDzGTwPml9fcrBeKqAPJYk7zsB6y/98V9omCxBceIG5KurA6whtB7I3jdW6xWndsX+kwaGqgJJNGRShCzkaUaxIMXpApN7a93cZLCygaDjcJa2x6CeXXH5IA7ZVQxqyDrmC7BspFipXBKCD3EY6I092QpiI/bjbMfDvhZFTkMIisSco7EPOS8Kr243EjSII2ctIllf7q+pAKxeXumQDSCnFiAIcCufesbE25wBhksrcXh9fsxP7oGs3OI2d4hYM6wtg1MO0fXLdF153j2cx7C3ZO7OKUehDVa626d/siH/wAv+sz/BR/83ffjP/+nJ3Bw+Rqa+S6oWeDKlRt4/CMfBe3s4w+fewUf+tAH8Xvv+W947EMfwsK0uPVJfxp3bh/j6vz/T9x/R0uSnYed4O/eMGlfPu9N+epqW9XewTQaAAFagKQoWlmOdKSVtJKoHY7M0e7MSDxnuZJmVxpqhnKkCFIURYAEQICwBBpotLdV3V3evKrnbeZLn2Hv/nEjIiPzvSo09uicjT5dLzPyxnXx3c8byfrVC+wu30Rk8hy79wGMBx9EqAApNeMe45UYQSSIoh9UE2av95z0uvaJ5DeI40EkKozrbOj3GCPPRPCOEWhSRCQkQb8RRVBKZ+RCQSaTJZspYJgSKYTO6ORrbZ5pmNo9IAxwHIc4eMwwDAzTIoxqiKQZ4/S51IQyKg4Y/Y3bFItFcrkcQghtZfCDngDyWMhoNBrkclmdxjfxK5RJPwnijChSDJehH2CYgkIxrxkfAX4YEMbEIToDzWYT2zDJZOzIFUynnvR8F1NqxkgKXYfFQEEYEIYBHccjny/iBYGOZYm0rvEJjnqKGK34fXZdEr5/cHaK8ManqAtcfeDURboi/f0g3JYCqjRznkLHPYx/Gh/sw2Wi343mzpmzYjTTQ0AFPe1vuy8pfNw/bnw/HqNn7O/LBB0wVOrcdenGfnzYZcbuxMCTRgq9S+lpm352H5fQZYwEPfM44BXvh6+I84np7J2ugwUVlZqfSL4LiPzAu5YNwzRwXBfbNjCkgeu45LNF6o0allmi2axhKIUlDfAD/LaLbZsIQqSAQGlHVYVOUe11AuysSdB22NzeYHRijEw+r92nFLiOS3l3m9de+C4njh9loJjDsmU3TWcQYEhJKI1uWt2IDiK0iy5Kx+kJBAYCt9NhZ22VlWtXGBkp8dLX/xR/b5N2q8l0KctGc48rl6/xxptv4PkBZ1/Nce3aFcZGR7h27RrK8xkeHuLGxXcpWYKOD36guH71BqcfOM3wyDCVvTKmmqRTC/E9lzdeeYXBwSHuuvtepmZmQWhhI86EFWe76tLqg95j/9lLnbS+R/Yz7z0AeyBv13vWD37+IN4nOtkJ/0HaWqBIMyyRkNrtKz4bcbmBJNuVSK2N+JjHbm+q+44PvFQPvpFxHZfU/qlIIO1HuTE60agmrSjfhzB7FPCJIB/Ra11/q6v06b6emD9V0XkNu/guWrcglcJA9f5N4mW6QTAk0dBKacE7hDAUgEESXhGtJ3IkJFRBlCKexGKRLnTr+9qi4fvgBeB5Ia7r43nebfa89/r/MRg89lvrJy5pVrbrV96TWitp2wOhPxBtSJ4N+wA71YuImLtuBeUuMB+kbUsj6xgIYyIca4l7d0Azbkm8hFI9gNuzuO5oQOQm06/F7D/IcfCZoHf/kkPXzdIgVL+GUBBXr9Prou9KS/q9B6er1exFIpJu9p7bWn3Yj5BiS1g3EYDsBoJFawyJ3DSkzsnqeh6hG3DPQ49z4exZVlauIbwaWqecRXm6qvj46BRbGzsIXxGELuXWNqY0sWyL8xfeRCHx3Srl5gZCWChMNrF48qkP8sqrr/P8l1fY2tzEaTaQfogvLG6crXLPfQ/i7G4ifRfLNZmYW+DQoQVK+RyugEAFJEXiiBFeF3UJiMyVB+2NrggbhrHbVAQVKmZW9bsIlELIGGFEmToCnRnCMI2EQGh/49iFSs9BSF1RPQyJ/CkjtzIZaQyFJAjiwlomhWKRwkBBw7ohCHxPF9NzHSxLW4qMTJYgCHAdJxE+DmIuY0tE+twrpRJLRZxFJpvNks1mIxjRsSeO06FW20PKITIZmzDUQeFK6RiNuA/DiJl8kZwHKbvhqCLS4OgxctoCIQw67TbVvTojAyUMS1trAs9DqQDl+7ihT+B3IHSxDYVJiPI9XNenWqszu3ACM18ijN5Ub8G1AKmi6r/RnkPkAhseTMi7Z65LzHp+UjGhjs5cQmVFD65Kn+CeYZSO/UnzHDHh6hLsLnGK7yQzi9cX/U1r8/YLyV08GHcQMwPpK3b4TM+n/+pq3fYz9L3PdAugJUum6/t+J2t2v4Y4cQVU+3GYXlf8HNHcDsJ9IsVNda+0m1JP3wlHmJprrECAlHtHzCgdoIBLS43vY509AlHye18sY7y2/r1Q0Xiqm5k2V8jR2mliWgJDGrTaLfJ2lt3NTQaLFpffPcfo2CgjpRJ4Hu16naGZCUJchDRwfYGUlq6F4/u0ah3a5T28Vp1XX3qBDz37YTLmFMLWrp+O2+Hdt17jle98neHcJ7nr5FHwLZA6HiNod1C5PLZp03FdlKEnHr8WKQIIg6iWT4AMJX6zzrVzb/Gn//V3OXJkjurNq7yyt0a702TQ8mg227z11llM2+bEiZMsXnwL2xAsXbyJU61y/333s7CwwB/+wWf5wu9s8eSzz3JzdZ2lxWUWJoaxgg5rSzdxaps0mlWajT3+7GtfR0qLj370kzz0+JMURsYojY4TCu0GJuMqaoqe89K9wkhh1cvzJDCRMKTxez0gEyJpELw9f5bwAkr14I30+Vb0BkH38xUIkQprEAncimgtaTZeKYWIXGXj09zlNyOamTpnaatzz9gx8Uxahrr+ipCEKS8PUya5qbQVSKUEBKHnqruUUbKCWMHVu5s6wYvo2VedyUkmXgKaj9TKQJniteLDFheB1OsX0W2R4JBAdXmCMErYEqreuDM9tqZFQaif0ckTuklvEKCE0ol4lIEX+FHiGL1O7dqsCKPELmGoCJQkDDXv4PuhtmgE76fa0w8Yo3G7TCExDPcoVRKASt5D8iEBwRhYenFht3nMmEWERzMt9BC4/fNMDSZ6CV2sudrPIO1nxvuZ6f0IXiSAGLdPV2A9mBlP2NADGH1S7VN7Az3j9LESqTUflKGkO0Z8cLvt0sJX/37oDekXkeLMDKK/bdzz99XaaubBEEJn4DCMKD92l0j7KkRaJlJIJmYWuPvBxzDuvY+l82+weOEtrOwgQRjy6OkHePfcm3ScDrl8hoGijR/67NVqeB1P12DwPALfw5QmmWyBTKaA6/q8+NxXKA4OUNm6ivA8TLdNPltgaGSCTkfQabc59/I5ho+e4lM//4vMHT1OaGXxhEj8abtbllpzzGOK7j51GRTR2yjZLxG9k6i+hpRJbsiAMNLUaaFGhIpMxkQrERRISewBHuEHUN14H723urCfRky6kTAh9LrEKNbu+WEASCzLZnBwCKV0sT4rEmzqew1WV9bIZDJMT0+Ty+WSdWhLhR8JARwocIAWKjIZm07HQUqZxGIA2LbN8eNHcRytJWk0GtRqNYJAMTU1RS6XjbJKSfxAz1UXflQglPaFRgsiWkujhVjDMHVxRAQL09MUshb1apWdchm31WYgn2F8ZIS33nidyxfP0m7s4XcauM06XrsNZhbMLHMnz/DnfumvIA2BH1EaaQgEASoIuswBRuosdInEQQkb9Js84NwIEhe5HuYwYvD6NXyxUCLioNrk3fb6UvcOtZ9J6Z/D97vuxMzfrp0QXZE6ff0g2nc9vf2Eo7+HOylFuv1wgJTWz0ikRkjxNem9jbWh/QzI/n7Ugb932/XiCnGHZ/bPdT9t63nPCc5Pt+kXgCLVSTorYggxQ2gYhnaZkNomUBoaIvB9PNcjaxhUNjfYXL7J7EiOF7/xVe5/8AyTo0MUMhm8TlMLBJEQGQbaymASEgYBfrvJ7/3Wb3JsYZrVlSX2No5jS8gXi+SyGbx6hfr2OpZq4zV3CVplHNXBDRWhMKhWqoSOx+TsnMYHocKPVi2lwnMDhFBYRkTjVMjoyCBz0+OETpMrb77KzOEp1tduEvpt3nrhz3DCEBnCfSdPs3TrEv/wH/5DXnrhBb7w1otksznOv/US7772AvcfP8qLL77IrUtvYI2MUyoOU12/QWPzFmfPnaXjtfCDNlvra5RKgzQrdb78O/+BF7/xdR748Ef5pV/+6/hKV89QoUAXtRMJTPmRNt51PWzbOhA+RfL+NMzsY/hjGNhHx/t76r77NPSk4yPSiCYe96BLN0u1Q0RZxESieNKPawt7JmMnxyztupiAcoTnk6J0fQqRgwRrLZjFSUT8pH3amquNCYpemSwSVCIapmMmU9aa7qIQUibCQxxuaRgGQah0zI2IFRoG8dmWGARBlLgkimONXXr9IBK+Ym/cKK0yEFkbtJUvCESSkT0uJq4VvAI/lHQ6IYGvOw/DKA8P2pKvPR20kBEEYZRWP4z4iK4Fx/e1gjUIw8jVEZAmpnx/IoRQ74c7BP7nF7uI+nYEs3t1tTIGvQJKiOgByDvGDvT1raCXabkdYB9A2O+0SNE/jzsSz9Sx6+s0pHdffqC1HSA8HfS8vrVfQOh/N7FvYKwPiYWVZP+SfsSBc03PLryDYNe9HyONO61Dw4UKfaRhoaTEjw6gijP6CKF9ev2QrGVqrXOrzsW3X+PS2dfJ0uHo7Cif/9xnyNoBntfAsEIMGzCUTlmbyeI7PoYC33GwpIEfBLh+SLE0RGlkhPWtdUqDeXzXwzJyeB1FqxkyMXsXTz/7Y9x1+mnyw1O0ffANg9Aw8FCEkXa8K3qlrEmqK7n3BO4esF+xlj/RVoTx+9PCViDRAhcaiYR+lEZSaG2CaUoQoc6iRBzcGxPPOF2j0K4JQiOxuA/9fjUjEWs4hBAEyo8yckWpK1NCqQoVoFPhuq6LlBLTNGg2W5TLZTqdDuPj4wwODiKEwHGcJKgb6AnqDpXfE29hGGaU3UL1wHG3OB9YloHvK5aXl2m1WszNzZEvFHQq4CAgn7MIXC+1v1rQCEKtxbEyBpKAMPTIWQYb6ys4rRZDxQITwyWGbJN3X/sef/alz2PLgNB1qO2Wqe7uIewixVOn+R/+wT+BbIm2j67FISBUPlKE6AJeVlSjpSt8a3bh9jCQnArRe1ZE/E5TV5x6s78fYu0zqXMXv7fkP7oVlnueP7jYUoJDU3MTUQqStFvYvucQXabiDvhCif10RLtApF0D+wWUvv5UdzuETLlaJO1vMwe1bxsP6F8lCD5tQU/vcW+gd3QOhbiNb7zYhwdvt7Zk5/sA585C3Z33PL5krOhK9d1vnYrbxO6ZiZU7Wl8QBBimBClwOi6GMKmWKzSrFXAd3n75Je675xi/+xv/bx5+5oM88cEPMzN/mEbL58biGqceuB+jkNFKG0/gtlzWb92iXtnm8NwUL37nm9T3timVSszPzeN5AZcvX2Z1+RYPnr6Xb331T/j0T/4Y3/7m1wiCAMcL8EMJwiZv5fi1//A7NIOQobEhOl6AErrYn1I6Y6DruhSyGQS6endGBJSXrvPCn3yeb335c7idGpgKfAcjl8HKZhFS0u44aC2PwLRtjh45TLPZJGPZZDMZFhdvgiHoeE2OHDnC7vYe7abL8PAYZ86c4cknH+d//qf/E8K2yWVzdBptfvjTP8uDTz6DsvPcdeZhPBkllpAyOnjRoRW6QGDMsAYqUuZENUoOABe6mviDr/2eFxFfRVog7TL6kWh4hz7S93u77hVqtMAShJomWKapazSEkZtQXOUx4eC7c0tgMbauSCJ6HA2VwCzJWuIrTjQCOn29ELr4olAxboyLs/bivhjfCRFbBNIKgO6CVditU6GtIglJTvYkjKwe8VxjRZxl6binIFQIFcf86f2OrVEhQmeARGd1c13NNrhud6t8DxzHx3FcfD/ACwJcNyBnZ5O1I0Tiqq6VhClfCqXjqGK+QNNvvR4/ylYjhOzZk3/8YftAGOjZnh9E0OhO5mBCEG9m4j/ODy5opF/CPmLc1/YHETS6sz+gff9c3oegIfo6VKovWPP/T4JG/FkLGl1SmGYOflBBo2+pt1lL3Pf+3/cRWKnn5wSA0sWQdLFWhZAhhArl+hQyWUwTPMfDCAKCZo0bF87xu7/xrwjdPTBdcjmFog3SQxha6g5DReiF5K0MuYyF22njeS5mJsvgyAhrmzsgBUHoks0VMYw8nm8xMn6IX/xLf4ux+ZO0giy+zBFaGXwhCFSQZKboso8RMoy2U6SQ/Z0Eje77iNr6ISqMiDdCu5IZAj9UEOo61aYQSYkHpUCJUDO60TiJ5ivCjiJ6v7oQnYpqcaTEI83pIQ2NTP0grmveFVJj5iIeM22hSL/bOFhbSkk+b7K312JrawvQ6W9LpQHy+QyuqwWLWNBI4E6BYZh0Og6WZSVwna4iHrc1TRPHcXShP9+nXq9Rre0xkM8zPz+L7wW4HRfLsMjaBllbgArZ2twln7f4L7/7n9hdX+ZDH/4g9993L4Hnce61V3nxT/+EoZFB9rY3CXZ2UIbBXQ8+zLM/9imO3vcQ9cCkKTN0lIkwM3iBigLUBaALBAohCFVUGTx+zzGk9J2xnu9if+0NlPqBBI24nkp/HzFzEIoINntAUnCQS0XSL3cWNOL3n750BpbeGLyDcPxBgkY0SDLJfkvyfouGbqoZl34cdeeMVQdV3e5p38fcwP796xU0dPv3K2j0DLVPyIg+iP37dvvr+2foirA970fQ0N/DA37X84q9DAwpaTccbCnZXl3h7Zdf5snTd/O5P/jPTE8N8farL3Ho7vt4+AMfYWhsiivXV/jEj34KJyrgZ7g+ymnxyvPf5saV8/zIJ57lN/7N/0ZpoMjRIyd54vEneO6b32Z3e4dD87PcXLzE6PgAly+9CypABCGOGzA6tcBjH/goTz/7SQbGZ9iqVGm5DiGKbC5HoTRALlfAcaHtuEgUmYyFbSiyIuDKm6/xO//6X9DYXeWZZ57izEP38Xv/5bep1vYQQuAHPp12m4ydjZQlYeR2GWJnMkxOTHL48BGe+9Y3yBWz2LaJiY3T8XEcj0DpQqZTMxNsrG8Agmx2ACMzQK40xuD4DGZplF/65b/G6OSU1oKj8H0tTNgZC9/3I1yog3Fjb4DbgMsPKGiQvO/bCRpah/CDCxr9vFIsaMTWCAGEUbYugRZkkxpMEGW47MMFUR0qhOjBt7cTNHzfx7atqA09QoNEYEgByktoXDzlMKVsg+6cujtE8g5URECTpSqt3Iv5eyPl+aOUtix0eTX9Pa1kMWT35YahjmcKAi1cOG5Aq+niuiF+KPTfQLszua6H78XxlTpLoyHBNM3kf8Mwkpek9yJMMkz28vegs0xGwoWMShKgkmf+4YczB8JA+nr/rlMqnaArDUjpwF9FnPc/kWLFfiTbw4CJbqcikUFiQpYiOHoS3bbELiUHXKoriaZuHajFgjjITSVpwOI5QFeb39M+Fu8joEivp5cwxvty8DSTHvsFokTSPIhg6TloYIglzN6x4japrb3dyJEfcGS6U11SdNDYtxOc0oJl3O9+/UrcVqACgWFLRBBgm9olyBSCWqPK0tISxXyW44eOoAKHz3/pTzl69CjHDh3CskyKU7P8g1//16zfuk57b4Nvf+MLuE4Fw3Dx3QZ0Gpy6914unL+InckDIYZh6eUFIbVKFRFKhkYmGR4ZY2VxhVbTZ+743Tz+Q59iaPYUriwQyDy+kAQIghCUMnTlaVS3/Fsfs5RopYmQvIreQorhSptgNZ0QCAN9gKX2U9ZpXw0sw4gyUIUYoXZZIAjwVAjSIIzyXYeCWKkdaR2jeWjfIQwDLFN/932fjG3he74uyhPoBxIFmp55T6q9GBKCIExcotLwYJoGQpgoBZ1OkLhWSSkxDE22Wi2X8l6FIAiYGB8lkzFQSgeG60QFIdLQFgIVai2Laen/gyCIzpCMstzo8U3LYGBogPxADtswcVyHRrVO2HE5+/qbrF6+iFetgKlQzSo//tM/SvnsCwwM5nnzq/+N17+sz0/oh/jtJuVrFUonTvDTf/dXKY1PE5oZjFyeDZXBEwZ+IMDQ5n0pzSiDlkJXX9em6Niy1Kvv0iQrrd1KnxeBVsh0NR7oFMo95ybFAKTbqVhoPUDISLRugkTn1y+opHCsviH3M/QJzhUgFUL0nfUE6SSiaoKDiAVqlcKSCWHQbWJc3x22y+T0MLg9zEaKAYrv9Ez7AGwf06SU9rY7pEg1iIMxUwJG8lzvCN93TIj2K00j0gxczEyk5qP2j3Z7ISKhyLdt1wdJfXPrApMQ6RXsx/Wa0dBMohc4hIHCMjKYpoXfcRjIFrj76GH+3a//c1qdXTqVEk6zjPIa7KzfJJvP8rGPfQAROuSMPJWdTZavnufNl57jxpVzuPVtbp39UzwVsLHt8Us/+zOce/N1tpaX6LQaXK1tsb21hMkEzfomhmEiQpviwDhHj9/NqdMPkRsa4cbKKuOT0+TDHH/8uc+ysDDPyMgYl65e5Ud/8qfJZSSV3TKWytNoNVAmOLUae7tlDGnw4ksvMTU7guc5BIGLEArLMigUSlR2y5w4cYKrVy5HNUEsAr/JyvI1tjeXyeRMVOjQaDQYGhhGygCFy/DwMM9+9KNUKmU21tfIGhma1T181UJUGviB4Cef+Tjf/urXeODBR7l45TJXFm9w5uEHefKpJ8llLYRhdt9KqDXdXUVBH0yn3uXBsJMWpLuQAqnzLrtwoc9EL0+i6If/PnhJ/9vfrgc9phI7SLAMGdUQifBHzJoAkq6HRjyJnq4joaDLwmn3I9s0dMbBGJ9IiRm5F4EODw19vfiAQKO1RIqL4zFFxPP1YQ8dhkEcrhCma08EIHx0mljPSyrad639mvZ2XIVpx3RV8xy+rwh9HZvpuh5+oBKLhu8HtNsurqdrYBmmTT6fp5iT+H6I09GB2gqQQiEJUCj80Cf0Q5362bKwbW1NktIg8Ekd+4gupJQtXd5TCxkBAUr5wH9HQSOmkN3c6ndAfKoXyGOmOSYo/Zo5obqSXXqR+vnuWPoF9xLoA2dwwA/9t9JoVB7QKD3vAxnsPj6iNy9zzIR2P6f7hTsLHwdaGNIHvIex7xWh0mNpILuNMCbSrehK6hH2OIhx4XZ70dtw/1Ap5kAI7SvreyGWNLANuPjeRbY3NijmskxPjnHt8gWGZMhAqchgziBjBKjQZa/R4sKVqxyeX2BwagHbtjnz6DOcP/sSjdomQhSRwPTYPJXxOoYBu7ubTE9N4Lsdtre2GR8bJ+tJKjs1AjnEqYeeYXLmCDOH72Ly8F20lYVSJr4wCASEQrsYSTTCk0og4yJKURYJJVKHMgqYjRHdQcxCAgOhQqF9+6UAz9PuRqYUhIFHtbyFLQ2a1T1Wl2/hdjp86IMfQvkBVq6IL0yIctgHRN5XIkaJYSSIKgh0iKwpDaRUhJ4Loa7JgZAoESZVcLviqYisHl2UYxhSB4wB3YxQMVJViVVDSoFhdKuCx76xxWIR0zQizZJgb69KrVbHsiympycJw279jHiP4s+GqXPTx/AXqiASqgTS1MUAOx0Hz3UZHijw+CNnaByaxtnbxRIeI3mD3Z1l7KCB4Xi0qjXa9TqEguzgGB/+yMe4+94HqCAZO3wSsgU6SuIZJoaVxXcDDNOIxAoSjXAYaRbDINSZuVQM5+nzmo7d4vt+7sJNSqBLt03Y5djiFBOBdPue6LTUXPYzy3e60oz5wUoUPbcY36mkfV//Yv9YPcxAP+Pdc90eFyYtosH3WW5T7buyUPyhy1Sp272LaKbJPvTh1+4aumxVfwD8fobuoDXEAt8B+3RbhdPBNOZ2be/UZ9rCqhk/6KUr2kVHSM3kGFLiey5u6GMbFnYmg+h0cJ029douH/rQQ1T31hkfPc7U3AQLM2PMz4xhKpdXX3iO0uAwnfoeLz/3FVavv4ffqWAIh7brcubhx3n7rfNMjQ7x7e118jmDE0dPYpshX//qu3TaNnMz42SyeVZvbjI5MYxpBLz99ssMjA1y9fJ5vvOtr/CJjzxDfXOZxeo2q7bNzeUlVu8/werWNtNTs0yVDvHlr3yJlatXcFt1iqVBlN+iXlnnm1/9OrVaXSfkCEO8jkfoe9iWwc72BrYpcV2XkaFRwjCkXC7jew62ZdFy2oQK2u0OvhMwMjTC5Mwsr776Gp7vopR2ec1msyCz+Ni0m20Wry+ycOIUld0yw4PD/NDHPs70/CyZTDZiUEWk+BTYtk72QZpv6sERt4ed28HFfstaOpYUujWiVE+s5m3HOACWe8aKuPE4tixmQHw/wDCiiuuxAk11O+wdV/Sjh+R8p3EPEY1KxwTGP8TWhRiJdXGvgLh4HVqeCD2h675EgkSougHWvh+ghM6eFteL1YbBAKft4jkdrl27zvjEGGOjoxjSiGpyhSBMhIziJCPNcRgKlC8JQ11kN1QqUVz6ITiuzgSlkHSaDu2OF8Un6ku7N5sYhiCXyfXw0l0aJSLBR7tlp9ej9zCKtYxrnog0LJggvn9qW/iBgsG7hE1faU1KH5Ldl4a1F4v34bAeYOwCIBFQdUldP9Sm55Kmn2mtXy9h7TLl0V4lt5M5qtinWfuapApA9jzUtbh0v+8nbF3C33sYNaPaJRL7j2OciSeaUmr+3WfuJJB0rUAp5uOAsfrnKGKuof+K3svtkMrBPtV6rX0NUWEYue9oC1gum6W8tclyeZvW5BiX336VvSvnuPuh0zS2lllqVcgaimJpCETA5csXGR0eZmywyMn7HsR12qwvXcNt1QhzLQLXZm7uONeuXUCYGQpDwwgV4iuDgcFxRBs2VxucPHwfDzzxDGPTh8iVRrFy2v8+FIbO2iWEdvNCJa5ICchEGhglIjeQKD9GfDDj99blbbrwIqPkPUJFMS0K/EAXtRsdHSWbsQiVT7VT5+bSTXY212lUK3iuw/PNXe596FEmZg9rhBPpeNIqHq3xUUgZJAhCu7SEhMpHCMnG7gbDw6OYGZsgEjqE1Br6IJJYUnxHwljHcBkjrV4zawrWROrsRUxKNpuNBBCNlKWUZLNZTFNbQwxDsrtbxrIsisVCD3zHZlrD0My+iHCDimFXghcqsrksdtZiuDCGMVagvp1l5doFbt5cYXt9EcuGIPQxMxlmRieZnTvC1MIxjt99BmVnyLQ61BodMiKLtC2UEoRBEFmfNPNqSplanxY4pWHoehwJuPee1e9/9Zd162XyoMsUx133CBgHyP8JM9CPiw/Sm/TNcb840n2XBzHM++Z4pyvpLmIIDhAy0oqeA7tIYCOtdOmffRcue5gOutCdVJVO/bZvbbdRrqSb97gv7ptHmhHsfSppozhw/NsJJP1z7H5OaXvj+XN7BZHoAxCRftd946ggJHB8AuVjmLoonxKSZqdN3jBRBnQ8B2FDs1GmWd/BCzwCIRgcGSVfGOC1V17n3fcuUCpkcOo7bC5dw2/tYEkPy9B+4Luba4Suw6X3zuE7DUZHiwjpsra+jJ0Fz29Syg+QzxpYZkCzvsnqUpvOEjjOJqsbO6xcuc6ZQ0N0yrfIDJTwpKS6fJGrb3+XG0sr7B06zEzp4+ys3eLqhfcoZrPcc/8Zjh2Z5xtf/WPWVq5RGMoR+G0C3yeXsRkZHmZrY5NWraH3NFA47U50JrTSpjhQou12wNOW5zAw8HxJrdZhdW0LJXxsy2R8cpKdrQp2rkAo8zTdgGvXb1J3FUOj4zz+9JOMTI6TyeeQSZbBbna0MMbRB5Hq9LuMufTb8FsHw5E6uF367KQUz/vOaYKfYsFA7O8sPv8RDfQDn1dfeplnPvwBlpdXsCyDoaEhCgMDffgrmkGPIqd3HSJFD+NmhpQIoQgChRmXi4+3RRDVxdJ4XUY3tQCimXrPC/GCUGddCmOGPCpm54cEvvYWUEKiiOIcAs3nSAFu2+fWzWXK5TqGmcM0Cth2RrssK0UQOghDF9olSpIipIFQRgRbAmEYCHT/SgWEQgs2um6WtnzEafFjJWKaT5RSYtuxyzIk2xR/hij2RSck0K5XIupPhw3FGEUKlSgV38/1/gUN2YuwuiiyiyElqSj+GCj7mWHVfbv7BIz+SyX/JHFRiYkt3V+3sR4vTbziufaY4ONB6QXinqFV94Ao1fVHibW9kTCVBFqnOu93LTlI8Ng3F9L99179AkePloHeeXWfSR9E1dvqgL1O9rWfM0nN7U7uVPt/26/X02db6Vznhpm47szNzrIzPck7N6/y1qVz7K3eYO2iQz7rs7VTxlMS21TMLhzDae6xvrpJMWdjTY1B6DE8OUej1qQRmJRGptnZbjA8XsLzFYadAcNGCoGdK4GRxbQscqUJ7jv9JIeO34+VL+ELCw8TYUUm0kjAiMxtgIh0G7Lr1iLQBaAEcWbZ3pomyfsRyb6neQCBFgAMKXA6Dpsba+RsE+nbdOplmrtrbC9fYWt1CeW1KZZKVNZqXM+bZDIWxdFpTFMjnjg8XQvKIZIQw1CEvoMKdL2KIAi4fvUKE5OT3Lh0kbvvvZfR8XFsSwc2x8x6nBK6y4zp9QeKSKspEg1R+t0nqYxjbbLoMsKh0ikLY8FKp7jNkcsXEGjCKaSg0+kkmpMwDHFdhyAIsO1MVAQwgi0RRT8oAJ0dK5QOxUKG0GmztrFB0KxS3VrhnTdf4vr5txksWkhT4CtFcWycY6fOcOaRp5g7fJIQi1fffJOW46C2dykNjzA6PkFuYIBaq43jBUxMzaC91oxEg25E6QWJYEJnHQl7cF6v9Wf/eemP5ek956kz3X0g+R4LWz3HLIZPVDKn3kul5Ib957aXMY4HFF2QjsdIrSWNb/vn0n+pZG1EMHI7YSI9p74+9uH9vrmmGO59aTdVb6B9VwnQP+/uRsdkoH9NEUYnjPBmfMYPtoILYoVNvwzS06RLPHvGOzCmpWfN/X2m6WB/MPrB6473rWf+Md5SoPwA1+lQLOXxwxA/9PA9HycMEaGHtEHJgKvXLoBfx3Ud2NkhCBUrSytcuHKDTrvJulfDb+yQzdmY0kGoAOVD6Hpcu3ARyLFy8wZOq4oI22ys77K4eIVMTuA4TRq1AL/TQuCws30TuWcgMxavb18mwCCstrj01nM0dxfJqVEwTUR7i6tvP89WuUJ55TInp8dRfpOMbTA6NsaDjzzO2OgQg6+/RM428FSbankTESqymTxZM4fywkhR4jI8NEyIwnV0NK5m3gSDpRHclovjCIaHR8nlB+h0XFAmYegT2ibSsJg/fIyp2aOYmUF2qx0yg6M0Wh3mDg0wPjGGNE0dYBzFBgRBiGFptyLfD5Psej0cc+r1C7Uft/Rf+wVV9mGUOykh0m5NPTAUTSR2G0ysD/EVWxDQQdqNaoPz757ngXvvYWN9nWw2RzaToTQwEDt2E1tUNN8dM0Wxiqb3rCYwG12mBM/z2dkuMzo6jGVniGNKpaGtECpO7xRlbgwCheeD44R0nADX9VFInWAlSjbi+doC43s6KYkSOo4hCEN81yX0A1ABbtvhnXMXGBsfpVyuE3iCXDZP23XI5wvUG01KQ0OYto00BHFFY60olFH1bgOULhvr+zq1rI55DLUCL8p6pQUDA8OQGFJTCN/zQBmERuRtkNAAbY33lYgUKvp/KbUHg+4DTAMMo5tZz5DaCqLrd31/YeMHSm8b/1WR3aiPPHZTqIq0QNL9K4SI3EX6j0S3j/h2mnELIqYnJpoJ3Kek4vQcu16L2iUlSI+0D0ETBfmKg3j87oFJseqKtIY7Ejx6lnOQIJFaX/L5AA3oPuTQpe63NaErukSQ+PnuQUwTNZF+KB5ZxcKIoGuNinqK3YSI0YfqwWvxXxUPoOLUc6n1K9V9n4A0dApXEQpCFZLN2Dxw+n7MTp3nl66QGxygXW9T3lojcDp4PqzeuMz6yjIXL1xj4fBx7r/3HhqNGpcuX6G1t0e17uC5sHBolmtX3qHRaTA6PsnW7ir1WgPXcdjZKjMxkyOXH+fI3fdTyA3gtFywQ2TWRAgL3w8QlklIEK01iPgDCYGIqkJHMTIR7lQi5Tcar1uJVEb/uF2yrVGQt4Zn2xS0lcvOxhqyU8eWIXs7a5Q3lslailxQZWP5OiN3n+Ljn/gkv/WZz5HPZrjrdBYjFyKEjW1nCVR08FWAEfooz6FW3qJW2SZw24jA5/O/+xnOPPIwS2urjJdgOHeKbKFEICxcHxwfzGwxwuaq+/6URnihABGqfcCthY9UdrOYkERMSxCGCNMAX6eUNKTW0oVKdWlOCFPT0xqRGRLXadNsNnGcDiMjo5QGstT2mgggY9so38XrOIShjykFbn0PJ29S3dnkjZe+x/qt63itKm6nzuDgIAaOThksoDQ8zPjMLIWRcdohGJZkYLCEt7vDu+fexmm3OXrsOCfuupultXU2tnb51M/9Am60bj86JlJKJArHcchmsxo73IG2316h0gcn7NvinjZpJUd83pLf4j8q+uegflLoIXGb2Sex9H0RBweCdgXNbp2NfVcKr+lYj26/Bw3dVUjdmVFKTzS9X7d35+jb7HhyyXP03VPdf5M96wrh8Z1e5uZgZj3dn+a7eueS4I++Fxb3mSZR8Rx6l6l6+ow1zyIWcHrG7wJMz1yFZjSTMHcFKtR4zzIlEkm53GJ4uES93qTV8SjmswRum/beFn6nCjiEQQcRuAwN5mm0fa5deJvQuEC2UCJvG1SrW1jSQ3keKtTZcRzfJ/QVI4NjBFiMjpZ47Y1VdrbWQfhgKlw/xHN8mrUalqFxcagCDAwyls7q0+r45AZzvPbyt7AMi3p5BdMwyOayLF97j0AIKisu5179Lo3dPWxbMDY1zszMNF/60hfZ3avxzAeeZvnmFfIZG99p4bsO6+tbhKFAiBC31eLw6QfwwoCtnW0qe1VUELKxtsbJu+8lPz/I9WurHDp8kvGJaTa2NtjZqZDPZggsk1s31/ibf+cfcP+Zx8gWRvCxaLkBtXaH4dFRmo0Wg2NDOsGJG1lNpMQUNm4QRGsXicdFD7sn0m86fomk8EbqzKf5lz44Tng41RUcknHSSrOoly7fpSIhgx5Y6woHIqmhBRCGAZtrG8xPz3Hp/BWcTpuMYRE4HoHjYNo2juuDEBjSxHN0EL5pGVim1RV0ItypkjEFKgDP9QiUS7MZcPH8JY4ePcrU9DiZbIZQ6VTlKlIke6FO/e574Hoa3hw3wPVCbbkIQ+3SpCRBJGgEYagtE6GugSGldiPutF2qlV1812F3c4P33j3HkSOHsU2DjJ0hlyvg+gGHDh+hUqlSGhgia2UxLJMgKiIbqgA/dPG8ABVGAhFdhZ5hGhiRZUGzF5qvMKXANCSmlAgRRsHuisALCPwAlEqsEmHoo0IBKtQChimxDIkhozaRe7BQClPoIHXTEBhmrxLtTtf7zjr1z1/2o2wABlIaUTGQ2H9Lm4qklAnQHeQLrAlixG1FtCZuJmWcPisGTu2SIhF4gc624EWBoLGGTqioKFbC3EHMBAohkpzy2swV9Z3K1NAtwqcSDaqeSxQQmbYExK5FkRClYof4lBASxFO4HYPQdx2Ujg4VmcH6G6cJRfQ5qVUQl3oL432PU5ZFk1GxeJTa2z5xpuuGEGX3iQphBVG6oq60H7s+iaias/49jCsiR+OJQPVmWSDUjLdQWlOjtKnRkgYyDHQ4UbvB1s2rvPXSd3jpG18CIySXtxGGwQMPP8rQyCTPv/Q6T3/wYwyPjPP53/99Dp04yZkHH8K2LCo7mqGWYZOv/dffZurwOK1WhVarhgKsXJFcYRhpDfKX/srf4vnnX6PlGRTGpzl+32nueuAMTgCBFPgECKkIQk9bHTAglERhuwQBKKmzNgVRFJVpmihf2xeit0AoSWI4kveuBMJXZE1QvodlCMq7m3z9y5/n2puvUhzIc+LoLKsrVylv3CKXUYyODeI6bTY2d/D9PL/yj/45vlVkfbdBpjjEoWPHcN0gckUS1HYrXLnwHiuLF9nbWcZrV1FOk9Vrl8ESYFl84MPPYFh5Wo5iYHia9Z0GIjfMT/y5n8fHIFRJhLj2DzUkcd3x+F13+bJIAJVduI6FCAWRxlf/YqquPBsKCJNgWV0LQ/NLKiGEITrLjVAhz3/nu4yOjHBk4RC76xtcOHuWtVs3Ua5DY2OV0Ktj2BLVaiCcNpZtMn7kMD/z059mbfU63/jGV7CzWUSmwENPfZSnPvKjNJ2AMPQZLQ3QrOzyja/8CRfeehu345AfGKTpBAQdn7//L/41vpnDlya+NKK9CBEoTDR+8BE6rkf1s4ups5dSjKRjCTRwRBQ6PrP9eDSl3RZoQTWky1+KuE2ase9jurs+yiQ47aB2+yf/fjLOHExOerTx3CF2LNVWSrHv7PS2i3vT43YtGAfPT6jw9u9E9M68+2yYzCmtRU2wa8ysie6+x4xYvyru/bpB7bPax8x/VIQr3T5mLrTAcLC0qK0Z+jchE/1wtCad0U0rhrTLpaAbFer7IbVqi2w2h2kY1Go1GrUqpjAYGhhgoJjn7Fuv4rTKlFev8+LX/piBvCBs7CKDDhDiBj6+EijTAENqJjEMcBoNjp44Sa1ep93uoJTAtvP8zb/5f2Fnt8zv/d7vRynAFQjNBFmGoF6vIaXGxKEKQCpM28S0DBrNDna2QOAF5KNaSioqbCaFmWijO9U2SmY5dOQuAmVhF4Z5+IkPcuTYEf7Fr/+vqFaVv/srf5t81uLsm29y88Z1Zmcm+c5z3wZ8/KADUnD02DFM22Jra5tGval99Ns+f+Wv/y3+9Mt/hudLMtkivq8wLIPHPvAYFy9fZmx4jJMn70YJi7HxKe4/fZp6s8VnPvN7PPrYExi2wb2n78PM2pT3yrTabY6fOIlhmfhJvSVBpN7XVuiIzkZIoKuEDLvvOx1HF+mBNA7p431EdC+OL5OIJIV0F/bSOC7yAACUCiJY0wN0eScdfxgEAttQKB867YDdnTLf+uafsbG2zvzsDG+89iqmaXL33Xfz9NOPc98Dd3HxyjJCGszOz3Lpyg1qtTozM2OcOD4f8Y5g2gIniDJHCQOJpNPscPXCIhfPX+QnfvRHee3VV7h89RJnHjrD6YfOYGZNAiFwPIHrQ6cNXifEdXw8PyBAW/ljTlAKSeCD6wZ0XA/PDyP3Yz+qByPI2LauNr+5QWV3m7tPHePLX/gsl86/i+854LkMDg4zNbdAqTTE1NwC4xMz3H3vfRiWhed5BCpEmIKQAMfzCHxdRM9zo1iNCL/rd0nk2qStGFJIDKGtGUoFOuCbIOJxNc4ypIiyYSlU6GHZEtvUMZxSKKQgSiCiFc35gokUSsdYWhLT0LTLsuCJge/P8L5vi4YldOexA4kCAqLg0ZhPCLqCR6wXiWBQ+5QFAdIwEXGRDy2RABAGOrdx3FWcYz/2nRVC51tOE0midgKBaUbMfqAPllIKQxjJwTAMkdSfTGd1UqpLoPpTd8ZSu5QiCYLt/kaPIBK3P0BJpr8eQCDiRjL1UDrA87YkNlSRoBaL770CUzwJQXc6/YJLWo8YhCGWJXVmBF9hWwaO42FIiWlozbPOOBQBtmEkdRHiAjLEGbBSWhbfDyJtmkY6RsQUxYXdbNvSMCMN/DCg4we0pcXcXffBN78OnsPp049w/cZVLp47T2loi0Ozcxw+fIhO2+Xk3Xfx1NMfQFhZMCzswgCXL73HpXcvYYxNsrG5TcZ0KeRyCClwgoBqZRfV3uHmjSvUaxWqzYDQyrC7vcXqygrj03M6OwUBdsZGBF2h0jAMVKDfs2lqTVoYkgQ+SxnldkhtvBRJTq9eGIiCr+yMhSkChnIG95+YJ9vZ4dSxQ3z5S39Eq7mLQYfhyTGGBzO8985F7jp2F6sbNf79v/11Wh3BYx/8CAMj43zzy79Ps93i1KlT/MLP/hyvv/0dXn3xBfKZEEO1Wbt+nrC+RzZn02nWAMkLX/4sIlsiPzRNaXCGzeurPPELv8y777zDkbvuwbCyCVNlSIlPzGCltWAJQKU0aSLGDEkb2QeDXSEj9XwUVCCU0jAu0XniI4opIqXD7NwcpVKRgj2HpQJsFJ1ajcm7T/LC5/8rQdPn1CMP8fRHPsKx48fZ3tpia3OFN99+j0azw5njx7HzRUq5DLXdHW6tb/HFL32J9upSpNWBrGmSy2aZnZnhR37ipxiZOcxeKPClIIz+13oNA/AThjMmvwfxfO8vVqN7SRUJqymBoT92IbEyprnS5NNBjGcvQysOeO6gK7ac/Pe5vt9YMR6984gHuX3c0Zz0ffrov5eOo+vV3Kmuvkf0P5OOB9kft9fTx/eZR0/bSKElUuNpgSRM6Z4OWns3s04izBsxixjRae0WrpcV6N/jvkzDoFQqYhoGGctE+QYvfutlPvTY41x76xW++51vMlCwGB/J06xtYRguxazNXq2D57e1IiWbwbZN7GyGXD5PtVolcHzI2ayurkQ1IXTwa6ft8Vuf+Qyba2uasW01yZUKZPN5gsCjWa9x6NA8y8vLBISYlolhSpQK6LQ75DJZJmdmeOaZZ/mjP/yvBJ6PNAQKnSXHMLPUK1VGx8ZxXZ+VpWtg5BDmFuurazz49JMsLMyzdHWP//03/g2EHpYhydoZNrbWUUj+zt/7Ff7jf/pNWu0GS8srAAR+qEmgtMAs8tu/+dvM3fUARw+d4IH7zzA9NcO3vvVNPvLsJ3np1bc4eeJ+ri/eIlTwyosv8m//xf+TiUOHWLl6AzyHa4uLPPL4I6zeusHm5ianH38Sww3Il0o4nsvQyCjbu7sMDQ8zOT2jz6eI+JtI0Ig0NgnyjWEmfe577/UJ5kIghEwdRZGMk0DQASCn+agwKvzWvWcILWQYwPZGHd9VrC2v8Gff+Dpex2FmZoorly7xsWef5ZWXXubcW2+TsSzmZw9x4vARtnfLvHf2IoZlsrG6zt5uBbcd4HQaFEpZTtx9FCtj4UZlsIWSZO0sp04e4e1Xz7F8Y5V777qXJ594EsO2WFpd5dyFiwxPTLFw+BShMum0fXwviBRsOstXEPgsL9+iUqkwN7eAwIwyUYoo+6Oj67QI7cKkolS9gwMF3GaFjeVFJkcHyT9wirXVZU7ff5oTJ+5ieGSUielZDDNLy3VR+NqCIyUZy9SZrJSiUMzScQOksAmCiLkiVgzoTI2+72Mbms9WYYAhDWzbxjIzKOUjpC4jYEojogqaztkZSSFn4wfaPSpj6wxcUmnhRQjNpxhmhFpjhVYkiATvE92+b4vGz/3Ll9jZ3dVIwvfJZnOMjIwyPTvL9PQ0+UIey7QihKgvDZsRoo1m54UhQaRBEqFejVTamiFE7MsdA2u30JcQQlcxTB2AIAgR0fNBqANYjMhPDbQQIoVMBJ44s05aIFBaqtm/MRGRSAs2aUtH/LCKtEEKUBJUxICItONirF2MJfuYSYu1BRFxUlEe4zhzTcyExbEiKpmw3ssed4lIaIuFlGT/4/FTjEKfeISIBAkhtMSeaD1UJPAFYbL2EIUbBghT72MYrUHE2Zh0yTcMQ+F6IaYlcQIfGWeRCEKt71cAXVcLKQW+61CvlKlXttldvsm5V16kU63y5KOPoZRiu1xhbHqG+WMnWF5Z4utf/BymZfPQE09z+uEnmJiaZXNri5dfeI5H7l3gM//q15Bmm0JGEoYezVYLFcDpp55leuEk3/jSN/nEz/wiJ888xsDYNNgFXCVR0kBakmbHRRpRqtdQr8+QutKnUgGGpU9ioFRUOE5hG1qI1sa2MMm9HyIIYq0IgpypeOftN/EaFQazgmZ5gz/76p8wPTHE5toSzc01zLyNZUEmI5AyoFnfY3R0jHKljVNro+w8Ri6HsCLBXYSEnke2UMKpNlg4fIj67gaB12J0coxr775H3raZnpyi3mjR7Cg6gUVgFs7l0WgAAQAASURBVBmfv4u/8ff+EWFhlJoHmXwhSp8bMZlhGAkHMSBFjEoiXGjLg5GGrUjzgogZZv2bESsX0L7tMW6I6aJQuno8ES7AEHQcl2vXrnHirpOowNdCsALpK0QQIhVIfCwjRBghHc+NkKuBDD2E0+Srf/gZ3n7luxQzJq7j46ssWCX8wCJou4zfezc/9eM/QcY2OHf2bXZ3d1k4cownP/wRPMOiGQpcM0MgDI3D0OZkQ4FJgCC2bySn9sBrn0UjYgATQn+wfNDddr21PUqF+EoEQZX6KY0n0oKISOGW8IABRe86vr+GPj3YwZdSKqm10dtZf6ajg/tJLyvN6fdhPNJNEgsJ/S5P3TWEqXKrmkTcmfFPix1ppk2PEzkfHRDDAgdlw+qlFTFFT26n+u+SlZiWqN5n+/tDc4Yy4gr1KQ20EK8JFihBHGYqZVQUNNDFL13Pw7QsAtflyrvv8NK3vklW+Vx9/SWefPpRCD2Wlq6xW9nA95tI6eG0qxQLFq1mnSAIGBocBSSdjkMYhjrbW7QoO1fA90MsO0M2XyQMFa7jcfr0ac6/9y4/9PGPce3aFdbXV7Esk82tdQwjzhwUuU2ZBqYhkErXC/KFgWlnCH2P6elpWo0W5fIeCjCtHKVCkUajRugrQmUwO3+Mu+55iPGpQ5x95x0uXXiLDzz9MG+/+SqTYyMIJaiUK3Q6HTzX5Z57TtHuNFi8dhk/BKSJZWaZmphjaHiCs2+d49TDj3H4xH2MTcxw/PgJSsUin/3D/8rC/BR/+J//E8WJMRQKt1rDc1wwbEQYMjI+TXmvBqZFIVfg+NGj3HPvvRQHBvnsH3+O+06fYWl1hc31dX7mF3+RJz/0IcYmJlBS6SyJ0FV0pYTPHjcooZV+Xdjs4pMUe9ED4wmXKNMgKZI4c5mCw4AgZRkhcvOJLPkRg7pya4uN1W1qe1Uq5R2+8pUv8dFnn8H3PWrVKo16jfJumd3dXcJQ8fDDj2DbNr4KqdZrmLbF+MQUw0MjlMsV/NDlr/2Nv4iwdABzq9lhdXmTq5dusr6ywfbaFu+dPcvgYAErZ1EolZicnWf+yAlypVEmpg7T7ri4Qai9EhR4nkulXGZ56QY3rl9jZHSYB888RL5QwDBsECZBqJCmhdKx17hOi0sXzrO3s40IffBajA7mOX3PKSwTTGli21mENDFMi5HxcbAMEEZ0PgIMYXDh/AXeee8cP/OzP83kzCQBOhZIIJGyW4PK8zyEVJimxPMcBHoMQ5oEPqyurvLKKy/zl//qz2LbhrYmGloxL2VU8TsMsW2JbcWJajT9sE1BEKXmFVKBCLq4CEHghwipeGrw+xfse98WjTNnzuC6bmIB0CYbAylNAqVot9pUOhX29vaoVqs0GnVarRaNZh3HcZgYHWN6dpaB4WEGhgYpDhSj4ly6GqIBWGZUkCSEuFKyqTQqNSM/nDDUCDxUoc63HAGzKTWDm9ZoxYCeuBEpleRnVqk2htTOR2F8IoiRuj6QOrI/JYykT2b31KW0WaL7mx64555IAhb6iF7cMlIbJHRGiJ7f6buvR9BjdItrpQly3C+J63NCsEVEhFLWHDMS8jSwSYQhEX6os0QZ6FSjhsD1PUxDajeREEwhkei9CvwQ29YVuS3DiHwbowJnfoApTIIgCuJVOnMChkVxeJTi4ACHFg6xu7vHWL6I02jSabfwQ4PFWyuMzc3jeR0MI6RT32UgZ2FbsLm5wvKtFe6/714unH+DwvgktmhihA6+12a0kGdyao7Fmze4tbbDM5/8BI1mg/PvnCNTWqY4PMGJex7AFzrLhCkkhtCFbWL674faJUwJAYSRjKorZpsm2tdR60EQRNpGROQqol9E6IWEUlDd22Xj1lWa26s0tlfw6mWCEYsjR2Z56Mc+wXPPfZvt7TVaTYdiMcs9dz+A43Qo795iYGiAYydOsL6+xm5lh0w+i+d7hK5LSIfxkWEmR3Pg2Wxu7LK1toohJY889iTvnX2PesslEDmyg2OcuO8RnvnhnyI7OEoTm5xtESCTnN+xsCFFl7CkU/pq16fofKasHd04ndhMr3qOjUyOjiDJ5haBbOBrjYvreHRch+GRAY4dOxZld9LMeYCmWkIYCQ+tDAgCF2nZSCnxfZetlVW+87U/Ye3SOSbHJxgeKLCyvI5tDXD3Q0/zwY/+CB4WjlIMlQZpteoMTh+mNHOYQ0eP4VpZmq6Pb9sEQlszukRWRLugDc09Abe3YVbT7lPEuyVUb/Pb8LlpZjj9d1+jFLPckxK8v30fM7t/rumm+xvtH/9ODHoKZ91WHoktzfufSye1EKIb8N7fpn9uXTTdK+B05y6S99gzkz5a0tP6Byqm113b7bM/RXNPpiGiTNkHte+6FXbpRd+76qM/PbKMiN1t9boNA11vRwhMQxF4CkMJwtDHEoLAdXCbDXDaGE6H65feQSiHS+deJfBdGo0K+UKObCbHbnkPYUCr1cHruOSKRer1OjPT88xMl7h4/rzWrpsmjz3xOFeu3qBWa+AHOqg2n8/juT5Hjh7m3Ouv8u3n/gzX7eD7XpI2O0o0ShAGGKaJEJIwCAkDLRTZ2SzSsgkCm63tCgoDwx4gDAWDI+NUtjeRGPiBh5XJsr1bZvflFxmfuMXP//zP4TlbvPn6SwRum5VbFVQoENLCtnNksgYX3nmPn/65n2JjeZl6u8Pc3AIz0wtUKy08T/H3f/Uf8/t/9Mc8PTtHvjjIy6+8xNrqCo8+fJrP/t7vMnPkEH/xr/0yv/+ffov85AyPPfkU95y6m3arzW/99md4+AMfJAjh7ddep9XucOXSZRavXydTGiBfLPDTf/5nKBYGmD96mNLQUPJOExViWrEguhbQtDW0e44O/ht/EcSsjup2HMMbEQ4XvbjBlJHrsFLaWobAMqHV8Ag8j0IuS3lnl53tTVaWlrh06QKPPvIw595+i4999GN8+OmnuXbtKq+/9jqhF3D//fczf+gQV65cIZ/PMj11goFSibGJCSYmJgGD7373u2RsiRcFz1V29+i0OszPzbIwe4ictHGadebmZljb2mB6bp65w8fI5IfIFkdxnZDybk3DE4LNjXW2NtdxWg0211dYvn4Z5cyyWLBxXY/NzR0MI8NDDz9KaWgIPwzYruwwPj7KiSPztMcHuHXlIq+/8F1Gp8Y5+9JznDp5FyMjo+zuVlDCIFsosF0pM390gdJACYRidnqWarnKuTfeYOnmDa6dPsaDpz9JqyMQAxn8QFcRtyxBGILjCLa2dpmfGwMsAl/zl5YlUGGA0yjykQ8+gdvaZWhglE7HxTYk+VwWzwPL1jEZOowg0LxcxOyEga4fYme0dwoRnRcyJW3ewQU2fb1vQcPIZcjlMikpVSWVFQ0gYxvIrImZtxkcG8LzfALfxw88giDEtm2ymQz5XB7Lsgkdn3Klyl6lwtraOrVajcGhAQaHhhgZGWVoaIhMJkPGNvEDHZASBIH2PRNRkTJItD8Q/4m0+lLoDUkXaUH7piXBNKiUm0Yc6RBh+ojJ0tWqSTQAyWgp5p/owKGUttJ01QnRCxHJ13i6QnT76KoREhYtqqBOcj+WEvZpq0gJTjJmWoiMJanA1BQiSQd3iXjesaYxWnMYKGxLA9Fz3/wm46VBJsZG8UOfnUad7ECRucOHdVYCBYaQNGs1Ntc3aLabnHn4QbzQ0y4HUpvYVAgqUChh4intUygQEEaaDmmAYSCxKJiCrXKdVrVDzjSYm5ljPmtzbfEae9UdqrVtLFMRmorq7io3Lxm4fojvBnQocfexo9x8702qG1uYlsLO2gjLpNpqU61UeeiJM4yNTvDKq2dxxDLF0UlGp2vkC0PMHj6KE/iYViQEKaVNsWhTpmEJHZgV6mraet90NpC0MKcZ0Qj2lIq0imDYGnjHxse5efEsm8tLWE6duZkpPKfFTrPKWT9gdGSU2ekp8vkMQii2NlZZvbUBoeSHPvZxrl67ytT4GKVClltLt/C8DspXeJ5PSwmWrl3B81yEH9Bqt5DS5sqlm9Tqig9+4qewi+OUJmaZOnScoZnDdIRF2w8jhBImBZtiQVUKravtnoSuO1SYake09l6mM9a+dnXSaTE5/V0JMC2dOEIAlpSEbkDGkBAGCKHtBlJE2S8U4AfkbQvhu9y4fpWL599jr1JG+R7tWpX1xct4O2sUxk+xXd7j5JmHmTh8N8OzJ8jOzGGFBnag8JXCymQ5dF+BZqtNQwlywiIwtdapJ7ZAROsUKetivJYexrT3fHfdNbsMoOrRevd0FdN1elw1RfotxLe0hSXBTaJ/n6NuD+Bd3w+jvE9GeZ/MdcKVpG8l+Gh/H7dPxZ16EI2vwvisxcLrvnpGKnEdEqn9TP/tWgcOnkscNpP0mfR9gOAV94emGX3od59klj5PIhYyYjqehqH4R9H7/tJut922MvW5Sx/jfyWGzo4W3VQRrfN9D8/xMaXkxee/y2CphG1b1Os1RkolvFabvZ1d3LbD+MgAe+V1giDkyLHjOJ6P4zgcPT7J9cvnCFEImcP3BNnMAK4bUK+3GBubpLpXZnRsjJs3Ful0OgCcOHGSmdlZXnrpJaSUNBoNpudm2djewPc8hNAWY6V8hFBIQ6fW7Y9Z8n0fr92Edocf+Ymf5J13L7G+tMno0ASnTj+CYVp879vfwtvb4dDJu6lUWwRIhoaHGRsb4pVXvkOjtkO7XcMQIblMBs9T5HNFTp68m7feegsPWF5dY2RykmyrRafZ4PqlC3TaCqTN1WuXePCB+7h0/iyO5+O6Dir0ee/c69T3dlDCJ1Mo8chHfojNzV0uLa6ztlnj6Q9/mE//4l+iMFRiu7zL0XvuZnRkFNu2qO1VKQwPMTg0zODoCNlsFiuTIZRSK30inkjrZ8PU2Rc9gkWSgU70HsleAaWrLOmi8RQsqigTFl3WJg3WQYSCpIgyGgUBlpC8d+48BpKR4SHm5kYYGsxgmiHV6jY72xt4jsvu5hbe3DyNvToiUOQyNrXqHieOf5QvfvGLDA0P4fk+xQEtaAwMlHA6LhMT40i0Fn5lbZOMbXL48AyEBgQh33vuRW7cvMbwSIm1m7dotVzMTInZQ4N0Oi4XLl5gY3uLgYEBDi0sUBrII8MR9nZ8GC5Szkrae5us3QxwHIed7QooSdb0mZ8/xPjUFMpt4DQkI0MDDIwUCGZGWVuYxJCK5m6NTqPM0KF5ZqemubW8zIXLl8gW8kyOlHj33XO0mg0WiwMM5Ado1bbxWmX8zh55C9x2G9M0yZo6JkMKUBIc1+HiubeYm3yW4WELlMDpKNZWt7h8+SqlwhRCuMxPT1Nv1Hj37YvU6g0WFqZ49LEHcNwQIcIIx+nU8VJGeDNUIHTwuE6Xq5WuQagL85YrVcrlMk89foLvd71vQSM0SLSOMfDFkfpCaNOrsA3sfLZHsx/jTqW0RlwiESH4rocnTbJ2lsGBEoaQFAt5CtkclpR4nQ6tep1Wq0m5XEEa2udsYGCAfKFAJpvFzuWQhuwhHIkVIxYmVJcZMlJnqZ8AxJJ7D9MvYk1B9ySlSV18xUiuez5jlWL6Oz2nMa1BS0hECjmkeYFkzITjOGAS9N4/qGhh3zBJ7z3yTOTKYURM3MbGDttbW2xcvUwWRa6YZ2h2lquXzpMzJLOz8wilqO3tsb21yebGOrV6jUcfupdWo87Syiq5YpGR4VHykTuOp0KUYSACPbJM7bMOIBYESnLy7vtQba1NU4aJmckwOT1JubJDrVbBc9qEfoel65fYWr2JZVlMTEyzfOEN7r7nHjrNBiAZHB5mdGIYacLq+jpBqCjmiwgFhxcOYeRK5EbGyA2OYhk6paBlRm4wPQBCEuAWhGGSaSlN67sVTLuMS+waoyUtDViKkNnZOdzTD5IPHHZuXtF+n6GgslOmtrPL0SNHIZOh0/YJAg9pZAlDA9/psL25zebaOoViDqUCTCEYHhmj1WwjDROQ7JX3Eoa/kC8xM3eEvWqHex85zenHPkJ2cILs4ChmYQgHiYOBMLvvIk4lGwuyKoJNzfCqKFmDvkIRM0FpH3V6tP79TOFB/CdRn6YhaDsd6ns1PNchK0fIZm2CICAkQEqwTAOhAmqVCotXruFVawjPY211mcVrV7R/79wcC4ePcHxyhJe+uUWtXqNcbfDEkePM3n0/LVGgJS2CQCEMneTCME2y2TyB1aLZbuMJQweyRmCQRH4l532/9bH7uddR8ba8eb+gcYA0cCBT3vfbvvHVfoyVKBv6+7vt5Lrr7UUdB82RfePtb3TQkN2bd/Lm7aLjrvAQj3lHK0/0Qw9T3z8l0TuHxBWqJ0Vn94kDBa2+uYv0fSEOGDfqO5G8+qfcv1nh/j3oaoySDtKuWrKXi9T4J+wOJ9DaT4HCddtcX7xJMZcldDq89fbrtJstDs3OUspmOX70CFk82s11ikNDFApFBkcnMawstp1lIJ9ld2ubyu6atj76AT4+jbBJoSgYHxun1WrhByG7u2WUYSINkyDwaTTqdNotLMviypXLdFztChJnKBIiqlUktXsMQmKaFkJIhApRvsDzPQLfx5AGu7sVhMgg7RLFkVnuuvcxTGnQboS8/LU/YWpiAcffwspkGRosUitvs7G+B6GDIQMM7ceJEDA6Ospjjz3K2XNvYxsZbt66iWEKQkKkFAyNDDFYGmd7d4833nyNv/CX/yp//Pk/obxbJlfIY9smyzd2IfQ5c+YhRkYneeyD02xu7LC1sYXyfUoTk8yfugcfn4FKhdGRYQqFvBaqlMKwTBQSP6I9cfIZrbTsVzr0wqA44P5BV1cBqvbfj/B4bNVO/he9YJ8I/ULQbDVZurWK22pR3q6wub7NyIgWNOr1GivLN+k0azT2ahyaneHG1SuU19dZW1uj1mhgZTPU63Xeffddzjz4IGNjY6yurbGyusa1K1fJ2Dae6+F2DrFyc4VGq86Nm0sMDw+ysLDA+Og4bruF06myvb5ItTLHkSMLZAeGECqkVqmwubtEx/HJ2SaV3S0mx4cpjAySy0h2OlV2lq7h721RmhxFenWE75IzXBwnYGXxIu3qDms3chgDAzSKebYMQeC2qVW28NwGru8glINUHkuL15ibP8xgMc/c1AT1Vp3m3g5ba4u4rkNtVzI3Pc/s9CinTs7yyJlTWBIyQmGbAjNS/ioF9Xqbd95+m1p5ly99/ov8xI9/nPGxEtV6g52NXWrlBrWdG9QaZT727EnaTRfbsChvVVC+x1NPPICwwQ9AmoIwiNQeoquIjpka3/MJlaDRaNNsOvg+uK7Pm6+9zf/w31PQEFIm5jAN3VIjMEU3aJuuOTsOCE0z0dIQqECbhK2MzVDGZnh0mPlD8xqxy9jvzKXVbNGu19na3mF9Yx3LNCkODPSZsyWh0rn2Hdch8H0t0CSIW1dGtLIZspkstm1hSDNKtZpK+9f1aiFM4WMpRORrn+jl2H8Ee5F69/F9Hs2pz/2/dFt3M46o3hZpdy/66VmacEbsoEhoW8+lVLdNeu797YwoyLtcqTA2Psbi6hKrq0sUCjlOGHDtvXfIBS7jH/0IzWaD7e1tKpUyjUYdz/XYXr7B4q1b3Ly1xOj4BP7cPAOlQUIhyQ0MkC8NRjEAEiW1MBjQzYXlevDEBz7A8pXrrC3dYm1rE6sC09PjhLUdKju7ECgCx2F9ZRGhfAq5LMKtcencO9QrGxRzJmPDc+TzGUZHR8nkbbZ3ywwMDrK5sU4hO8SJk3cxdegY+ZEJAjOLE0i8IMDMWLRd1ZezW2BKCKMAcdOMguIVibUiiD4bMRoWJO56QoWgZCT8KgZLIzz6+NNMDA5w7mWbtcXLCOUTBoqhwQLVapnd3R1arTZCCObmZskVB2k2Wzz//PNIGbK3p2NfMhmb8fEJyrJCEAoM08K0sxjSpFAcYGR0gunZIygjh5kZZq/RwfD3GJQ5ipkSytLVuk3L7M43BbpCJPHZXWhOC1nJ31jH2v23q0mOYTwN193PcUySVCGB51PZ2WZjdQ231UI1xpmemqCYz7NXq1CtVUAFhJ7LxuoKb778Oq1ag6mpSUzbZnJqlkMLCzxw+jSH5mcJnTpn336BvUYTXwnsQhGZzeF0IDAM3CCItOEST/MXhKaFmdNB8EZUO0QmaT+7zLdSKQ1yjyX5YIa5360lFuC6zO4BwgEkUQRxuyTNdsxA9zH53cQS+yawj0nej9MOtnwcuKaexn14v28NXcwYu3P09d6Ds1J9ptbWjXlIZZoSabyX2qeon4Nco/pYs54F976G3nkeNL/ub6JLW5I1aQ1zrwtbSkjou/a/GZHomJJ1iIMYyINpTPyMQCR0PAj0HE0j0n8EISrw6bRaLC8u8vCZ0wjf50/+8Pcp5HOIRpW5ySnuOnkCGbR445VLTEyPMTE5RavtMT0yzeHDxzAl7FW2efn5LSzbhNDD7XTwPJ9MNgvowmLlSgUzYhJn5+ZxXYdzZ99GqJDAc7h58zqe42BZBhDoSUZMvWVZOkZOyshNxEYInfXRD0MypgVkeOl7rzIwPENmYJzS+GEGBqfI2lk+9tFxXv3mN3E7IdPTc4yMj9Np7nH+7ZcYnRzEtkKk0PggCB2ENDEthR90MG0dh1ip7GBnTZx2m+GhEabmp5kYmyU0DM5duEJ1r0qzXqfVbOL7PplchnxhgE6twcMPPUYhV6JTa3Ho0DHuPnU/oMgVMihpUMyZ5AcGYwUyoVARb6LpUTeurQufCXMYvXEZA0is8xRd4TnmAWJeQ6ej7eKQtFCRhvmuLBu7jUbKpWj8tD5VN1MEgUelXGZtaYORoWGuXblGPmfz3lsdqtVd9vYqiFBxaG6BUjHH1toq6zcXaTZbFAaHmJqZZe7QAucvXubnfuEXMAzJ8VqNN998k1s3b9BuNHAaFa6cL3Pp3cNcv3mdldVlMlmbI4cPc+LYcQwhsaWDTZvdzUUeeeJppJmjVt1kfWmJxbUdPvSRj2NmLG4sLlLZXqNT30J5HRqVTa68+wY5wyc7WwK/QUZCkAmRBNhGgPSbnH35VQbn5hkZG8JttajubtGqVzBNRdaSeE6HveoWO9vbVMo7zMzOMTZcYG3lGu++VaaytUKxWKBQHKCQk8zOjXHo0Dy2AW+++jqTk7PUGjVcp83Q0BDZbI61tW0unn8HQsVXvvI9ztx3P1nLorJboVou4zktrl29QbNV59KFG4yOzXHk0FEatTZ+0KHT8llZXaLZdBkeGWRsbBzDtKL3qN+/0wkIwwApFdW9BlcuL1LZqZLPFSkWi7z+3Rfh7/z5fTis/3rfgoaKpGgZM+YR0IWxxi5NNGJmVvUSVR1wLAm6uFIHfgvQdQe0RtSQNkXbYmBkiPljhwmDEMsyUFG8BqFmRNqNJjs7O6yurrK9vU29XsdxOqAUlmGSzWYplUqMTU4wOzvL8PAwmUwWgTax+kGgmVtDYGV0QTBh6DgPRVS1uTf6KdGgJb7Z0eEKUZGFp1vFok8W6EUOscCG7itmz2IiaXS3LdnjNBlJ+yPvJ1Wqa2URvf32Enb9JVQx4RLJM34QECIZGRvBadcZeOoxOrXjrF27yne+8DlkzualWxeZLwmuL16jNDKMME3q5T0GBof53je+zGuvvs4DDz5II3S4Ud2m3mpSbzV57PGnmJyZJVMYJFcYIIwLuaFjf0xpodwAFQS88dabmAJqe1Vct0WukGd27hBvvfgikzOH2FkNCP0WEOK5DRavvoM0XcpbN/nkD/8IQhi8+cZr7GyvMnNoHss0mZuZZm3lJoHrU27UcEzBQjFHNpchQBFKgRfonOwmURBbvMsh+KHAMiwMVFQ4SSAJ8L0AYVoY6DR3CElASFzcMc6srKSg2egQSIGyBDMLJyjYGS4ODnPu1e+Rzxa5975TvPPO27hOiJ3JY5gW6xs7SMPCyhdwmx5B4OukCaHAUSGV3QqNRptavc345CTTc0cYm5xhenaBoZFxzr13kY88+xT//v/4LarVJsrK89QzH+fJZz6Gnc1ghOD5IUSxNnHFba1RgyAUCQEJY+gRKjkPXau8SOIv9P/RmZBdYVoLXr1BsumUoY16ne31NXbWllEdh7WL73F4dppHH3mYG++e4/XXX2FvdxtLgiUN6HgcefBRPvXpT1MsDaFEJBIoRZ2A/MAQYSZHLmOhAqELFCEo5LOgQkIRRmmXtSBpSEHoKxzPww4sDGGk1pSqMYAAEWgBUkT66WQfes/Z7a7ohCYwlrCvfY/JNF8b46B+Rj2NKFLaEZlCRgkdoZcpTyypCfPeN//E73O/sCRTn/dr+vezzrHQtD8wmgOu/Qx6fO+2VozI6pZuf+C8RK+KrPvL/r19P/PTQkFvo9gFUaZwdreIYl9mKpVKE9q3RpkwiSmYSWmf72QRi4u+CRH3HGqLoADX8yFUNGst9naqHD10mHfffpsnHjyN2WkzNT3O3sY6lzZWCJWLH3o4jRr1ehbT2sMPBNtbuxSKwxw5PM+9993HK9/9GgOlEp7bxDUFrutQrVYIfZ9Op4Od05YI12vw1BOPUa03WFpaxLDNqIozBFIRhp5+j3HOSGFg2yaOE2BnMoQuBF4IUhAqicKkkB2g3nQJHUXoG0zNH+LQkbuxskPs7uxwdHocQwmuXLrET/78L7Bw9DAX33sbwoBGbQ8VtoGQwA8YGBhAGibLq9f5P3/zXayMTS6Xo9NuEnYklmVSr1d4/Y2XCTxA5hganeXzX/giXicknx2gWCoxPTfD/MI8L7/wEmfPvUtoFXnu+Ze4597T3H33vbiBx9DIEMVSkdHxEZQK8DwfwzQxLVNbz6P3Hie1SVuc0wJnnFpbqAjz9uktYpiJlWOxcJ9WZXZhMQVvqssjJCgBuimoYxKpVKRME4yNjfKBDzzGreubvPfOu1SrVWplj92l60gJ+VIRyzSYHhvhwrvvcPrBMwwOj7B4a4XpuQWe/tCHGJsY5823L3BjeZUbV69x7OgRTpw4wcjQABffPcv1829w5PAMy9fe5Z233+DWrUWCMOBFBJY0OHrkCMVclsFBmxsX32B16TJeIHE6IVJlGJk7ycSAxXa1yuzEEM9/99s0axXmZ6aYHhvCsAMmZydpVDfZ29tjbHwC1/WRhs3999/LoUNHWV9bxG1WyE4UKZUymG4G4WgX4MFSnt3tJteunucTn/gxNjd2Ofvmy7Q7bSrlHYoDeTpuk7ypGFuYYnQkT62yxZ++8xZr61vsVWv8j//jr/Lt577LtevXeeSRR5ibm2NlZZmZ2Wmef/55RoeGqVYqLF63qJQrXL1ymZdefhkhYHpmln//m3/A3/gbfwMpJRPjY4QE3Fxc59/9u9+lWq3yzLMf4NM/+XFs2yIIddyu78Pacpl2u8mpew6xu73FuddfZ2Nli/GRCQr5PG8+9x3ez/WDFeyLmdYUUMfaFiGIUm8RaYGj7E9hNwBOWkakAdTPxQQnSZEVI9wkpaW+JS0jilnQR0EaAlta2OYQpcFBjh47FlVEpKuJCvXBCSJkrEJFu91md3eX3d1dNrc22dzcolKrMjk9xczsDHOzc4yMjJDNap9439eE1TA0k5UW2WUcDBvRXiW0YBImTEB87mKpStxGGZja066SVAdVR2P0MBjEQk4kgMTMTXekfePcyZc6XlLs2xxGfvEiKgg0MjrK6MggJgHKabE4PcXilUs0L7+HysArf/Yl1lduQcYC0yKXL/LQUx/gtVdewwgNzr76IqaV4SMf/xiHZyZ47bVX+N7Xv8jilSs8/uzH+Imf+hkKAwM0PY/A9RGGjZUpoAwJGYOf/Jmf5NLFCzitFlJAtVbBDSWf/oW/RG1zlcbRo5QKFqtLV7lx5TyFrMnK4jV8w+GPP/sHTM3NghS4nsuVyxewbBvXWWdiYparF9+k2qywXt7kRHmDJz78cYzcKAjwldJ5pQWIMEz8UkN0wKSQOse8ZRhkTEG1XObG4hKn7r8XQ+hc1klV1CjNX1x7REl4/rVXmZycxEQROC2k32Z0apZ6w2F8cIRr167RbDWZmloglxtEGhkeOP0gUxPj/If/8G9RKsBvg+d2dE5saVIuVwkCiWnn2drc4+EnP8bS+jbXlt/l2N338vo712h4NrsbW4RuwPx9R5icnSZbyIE0NEMUdLOmxemTQ0+fUWElAIVQMokHiAteSmRCtETE3MZar97sBLFrmQbWmLmNDQNCKYqDAzzx9KOozn1sLa2zt7nOH/y7/5NXX/4O7VqdUML9Z07zwQ8/w12n7qXp+rjKwFOCjmEQRlnpFCG2ITGEotZuM1LKc3hhgWJpiGw2DyJLtVyhODSM5weYpoFh6GwbYSixbQvbNhL/yySgOOXHnBz4Lmu47+z18oAq9fm2R3P/OY7GUQfci/sVIrJjpHBGMrTa96H7vc9CcFArZFcY2o9T1G36F/vufb/sVXdAV0k/iYteynqQjoXRf1KWkL4+uzLUAeugVwDun+tBrl0HdhPfF/KA958WnlIPiVjg6xWueoW+3nUeOH60ZKWieiRREhVNf0PtRyyg03Gp7lQwBRQyGSaGh3jnzdeYHB7gD373txkcKlCt7FAaG8HO5qjsVRkaGkYaWX7mZ/8CxeIAzbbL9Ru3OH/hIq++8iKdxi7ZUom9vQpB0NEwGeXzHyjlabZqZLIW9Xqd0DR4+52zeL6PNCWhCghcN9r/kMBzdSIYqWPllO/TbrtIKcnni3zwhz7ClStXuXbtKqZlI6SkVqsxO3OU5ZVdHn7ocWaPnWZ05hheAL/7mf9C0CwzMDpIo15mfW2RZqfC6vpNhsYGadZ3ECLENHVaYNdtoxR4XoBpKRA+9cZOlO0qi+v6kdW4QNYusLZeYXhkiH/2a/+S5Zur1OsNdsq7vHPhPb745S9y17ETXLxykUJplM2lWzx85hGOnzhBq93izbNvk81neGrqSW5eXaLttJmamWR8cgyEwvMCLMvENqUuLBd2cS0QVXbuhRMRMwQqVhLdHuf0gFBfo7RCQh38RPfcCZFkWwx8hQokmYzFW2+9xfTkBGceuJ9bN65iCIXvdXj1pRf54uc/zw//2I9x+OgRri/e5Pz585y/dIW24/EjP/5pRkdH+J3//DvMz83yjW98ldGRIQpZk1atTNCp8+iD9/Lc89/i1s3r2PksC3OzCAQbqxtcee9tsrbF8NAg+ekh1tc2cNo+YJMbmOD0qXkevvcYm5UKN24uIjpV9pavk3OqjOVPUiralMvrdJo13Hqd6dEhjhw7imHY3LpxmQvvnSN0W3zsox/loYcf4MI753h15Rp7m8sYGUnGnGR+forqXp3XXvserUZLZ2wCcBsYGIwO5XGae7z5+su88uL3mJiYYnb+MK1Gg1w2y4ljx3E7HoPFAUYGB1m+eZ1vfO2rnLrvHgYKGZ58+oMcP3qEV157nT/9wpd49513GBwf5cd+9IfZ2NzGdRxWV1cZHRlheekW5945R7vdpl5rMj05zc/85I+TLVr4fpi4Lvuuxztn32VoaJDBwQx3nzzB+o1ldlY22Nlc5egjDyPc9sHA1A9b7ze97f/r9TBS7neJWBwDEQNZ160qRo5pl5+4ULxmwXvYjBStVnHHEcB2mfVU27inNK1PVpRunW4verGx0DOKs3ZZUtBudVhfX2dxcZFbt25Rr9cZHR1lenqauZlZRkdGKJVKZLMZvaIY3ytt3gwkUZVoUhpfHUCswpigisR1Ji62AhBExRYUcS0NlWhGVc9+7KfCabcrlWqvhTWp0++qXvIuoqB4XWwuxRAhkjoY8b3A87Atg5Ubi7z3xmv49V1OzU/wva99gU5tl0Z9F6V02mI3VHgYKCw+9ed+nlBJrly5wW6lAkKRsQSd2i67K0uUpqaZWVhg5dYqjUoNmc0ze++D/O2/938DO4unQCmJMA0Na4HOXCWVDhA2CfjiH/0hm8vLlHI2A1nJ2s1rXDn3KqgOqA4DoyWkIXA6bVzXJZPNErgeruNgZ20y+SKOqwgzgxw78xS//Lf+J5phjkBk8IIQS2pXHkmcS9/Ai963KRUbq8tUtrbZ3dpia3MDK2MjhOBTP/4TuoCfIXjv/AUuXbrM1PgEH/zwR/CUdh/Y3Nhkc3WVrG0wPTmC8Jr87//8f8EI6pQGFMPDJQYGxygOjIHMsLa+zeW33mR4ZgzCNnNTw+xurrG9uUEYQMbOgpGlNDxBvd3hyMn7GJ48RGlshuLwCCvrqzzxxBNsbW3RbLW56+57yA0M0VEC38jgAVJYhCFYiLgMpIZfSZRtSQNrsidCa/K9MIwsH7GgkhI00MXGkniXMK4BEzHOopuWUSd5CBBhgFQhtlBYQcDW2gq/99u/xb333sXHP/5xCqVBQmXg+YJAGPjCQCdOlqQ8mZAEGKGL4ezxa//Xv8zY+DCHjt/H/Y9+gNkT9xHaA6xslhmbnED7KsSubjp/ehAE5PP6vAdBEGEvleCZbtB7nHUr/p5CNPSinrjQZnJ+0xrtmBNQPYbj7t/4sbTSIULJSZB5otRIJbTozqRnaiEpl4e+nw8iDAI4SHEh0YU8Sf0e47u4t9hlI87zf9AepIWdrhvp/jnE1CJMW277Nfpiv/DR7WO/8JFe9e2UM+nMPbFw2fOMfhFdXN3XTfdd9wkwaeGUvndNel+jX2P4i8/kPqF0/7ylQcKwSmEiBCxeuM748DBOvcqbr7zI5Xfe5tM/8nF+89/8K3DbzB07yi/+0l+g3uqwvl1hYvYQk5MTNHa3eOG732Zmcop2u83i4g2Wbi2SteCnf+pH+d3f+g2k7GDbIY7bwnNahKGPYdlYlhUxyQK345IvDmCYuv6B53kUcnmEUHRaLXzfg0ihZpgGwjBQocCwTNrNNj/103+ey1eucP78u4yOj/LhD3yAr37pK2RyJYaGZrj/4Q9jl6ZxVIZspsDEyCD/9tf/V6gvkc0LPKlQlq7plDEEpghpd5qEoYNSAcKQelwpcD0vOS+B72Gapk5oogRCGJiGSRBmuf+RZ/jVX/2n/Jv/z2/w1osvcs999/Lwhz/An3z5T3j66ae5eOEKF89d4R//s19naGKGSr1JrdHi3bPnaHba/NCP/DCHjyyQK+hMhuVyhdXVDU6ePIkwpM4olHrT6dS1scDfy2WBMERkWYu4o6Q4cuq8JbxcLyze7uqB7wOEZULNTJsiSkUu4IXnXufLX/4yp07dReB73Lh+lUajzic/8QlKxQEmJqb4tX/2a6zfvEVxoMSho8c4deoUHcfhy1/6Iv/s136NcrXM6OgIpgHnz77O7/2H/4NcTiIMwADHcwk6HSSCfGGA4aFBtjbX8Zw2ge8iDQMhbVRgMDgwwo/9uV8kUyjx3pUrzC8s8M7bZwl8j4FinsDroITH0s2rjAwNsry4SOArhLQpFErMzy8wt3CY+0+f5nOf+yyrVy9hZk1mF2YYHx+hVt+jWqvSaDSo1Woo30cIiZAGpmkyMDCA57icPHmCs6+8won77+PpD36QXK7IhUtXubm0geMFFIslxsdHKZVKlPd2Wd9YYWdnk3Ztj4cef4q/+/f/PguzR7l85TqVcpV6vcXNmze5cP5dLly6yOHDC4xNTpC1cmxtbSNNweNPPMalS5f4lV/5FRYWJtnY2ObS5Uv4vs+Rw4eYnBzmr/7Fv8fVa5dRqsODD53m+LHjDA0Oo4KAamWPxcVFXv/yZ+4AJTFsvV9B440wRYkSDjjRoKs+oEw0ScQHIAZs2UvR+qOI0n6y0GPZ6MGmiqSY374iewKULpOd6q7L2MQ9KXTGGitK6aVCTSzD6H/o1s7ImJqJarXalMtlNtbWWV9fp1wu0+l0UEqRLxUpDQ8yPDLM0MgIg0NDDA0Oks/rgC4gSt+rT118nsNARTHCIskmEFdaB3oK38R7J4gK7UVBqoFKpTqkW/DQwEjWEgsXYRhGVd4lhmVE7btFDLUFKNREPPoulaC2W+bWtUtcfe8s9Y1lVi+dw2+WsUSA53bwg4Bsscj8sWPMHjtJpjhEsThMs+mAkjRrdVaXrlHbXeHpJx7m9dffoNVqMjYxzd5eHcPKcc9Dj9PwQj7+o59ifGYWZUgcP475MQgjTY4EspZFp9WksVdlZ30Nt15lMGfyH3/zf+OuE1NcePdVlN9moJjFc10a9Tq5XA7HbZPJGLheh8npGaoNl9AsMXfXQ5w880EeefqHeO7F13jowYfZWl/GJCBrmwhgfGKC4tAIATotXG1nh8vvnef65SvUq3u0nTaHjx6i3XH40R/+MZaXVzn7zrvsliscOXaMD374o2QLRd45+w7333MvbqfJ4uJV1lZvkjMU2dAlaJV59ZVvs7u1ybET9zAwNEGrE1AqjXDsyFE2NpfZK29y+c1XaHbazB06wrFjJ9jY2MbxBR//xCf5xre+w8d/5FMcvus0VmGYAEm908TMRi4Lvodp2jo4H/CR+EgMaUWCAN36MIAyVBRD42MLI7KyiZ7zFaSsdl1XHX32VSRsALrKOqlzHQkYISRVwgUKoQIsQAY+qzcX+dwf/jd+4id+nPmFWTLZHErahMrSVcwxCKIjHvctURgEmKGDU17hX//Tv8/oQI77HvoAp848zujcMTrC5tb6NoePHIvSWAdIwwClaDsdHNdlIIoNi9P67Wd8VeqTjAwEtyfRsaARM609ioSYkY32X6TQZNctah/X3CNo9Phh9zAeJOOk30xPVwm+7Y8zuDMDHgsa/cHo/a6bKjZ5yf39xIzSQYLGQYwz9O5lX28pQWD/dVDwfLp46+3a997T/ffE10GUsVDs24teUttXZf0gFZIU+/akZ2xxwLzU/vcsRERziGLOYjgOoF1rU9vZpWibmKHH9cvv8rnf/8/4bhPldRgbGcUwTO6+7zQzh47jYrKwcJi58VG+8adfZGR4kFptj82NNVaWb1Kv7vLpH/sEz3/nK+ztbdJq74LUmeKk1MVNnY4LCFzXRRomhmFFgn1A6PuYpkUQBFhp/2EEQkikaVIoDFCp7jFQHML1fJx2BxX6mBmJYUgGB4aoVZs4jqA4Ms+HP/5p7n/wCXZ2dvnmn36ZgulSYI9Ll87h4BNKrVRQvo9tmrQ7TTIZbb4V0ZwR4IcBCMHE1BSNRoNmo4XvBVimiWka+J5HJjeMMoeYnj7CyZOneO/NNwkCn3seOo00JWurq7z36lvkJg/xq//kn4FdwAkEIyNjXHznPR544AHGF4bwQ4kpBK7TYXNzk+3dLR595BGkBf/u3/9HfvbnfpZisajpYpLVP4VLYpiK+KGeWENI4Z3Y9ZWeo3In/NXfRh/TGPC0mUWpEEPnN4NQYSLYK9f57B98jvfeeZd2p8NDD53h0UceQQUB3/3Otzl9/wO0G03abYebNxbZ26tSLA4wNjbGt577M44ePcpAMU+tVsU0Ja7TYndrjb2dVSZGh6g3GmTyOVzXZXh4kE67xerSMrlcFhnFcEpDu80XBwZRymS3XCObL3H4yDHWtjY5dPQIq0vLbK9vEPgemXyWemOPULn89V/+ZV579TXq1QbZTJ6p6VmOHj2GkCbnz1/g8qULFItZKns7TE6MMTc3w8rKCtcXrxE4LcamJ3Edl067w1CUXXV3d5dTp05x6NAhPvvfPksIZLN5FhYOcfzEXexVW1y5fp3trW2KxQKu5zAzN8XExDie57K1tcnKjVs8+sEPcXNxlXbbZXpyjuPHT5LL5fniF7/I6NgIW7euYQ0OIoTJRz7yLI8//hhXrl7ihRe+x+TUGJcvXMDO5QiVIpfNcuzYcZ595lkydp4vfOELXLx8DiF0pfhcLsfAQAGloNPpsPzKd74/rLxfQeNfvhESCu2vnuZ5Q0iq/sYa0LRFordQTCwF30ZbRIqgRdJyrN3Z50ssIs1jQohVb0fRLPv1RolwBMRV7GQ8P9UljvHhU6H+LVEchYrAD3TWLM/F9wNUqJEoUms/tKYjFqh0qr6N9XW2traoVmsEQUipVGJ0ZIT5+XmGhofJZU1QOnVYgCIQCiWjeJFIO9eDCKLgVBGZxbs/dTMESRlZM6Jia0nYaWKKj1LihSEq9VaFQKcOJPK3DEIsISEIcdttOs0au2vLvPrcn3Hj/Dm8Vh3bQFeUtE2GJ8awSiXs/AD33fcQ4yNTlLcqlLe2adXLXL16llJecmvxGk889jg3rl4nCBUT07NMLxwlVxrh4cee5rsvvcTi4k3mFg7jBYp8scSzH/shAiX5zne/x5FDhzh27Bi+47O+ssL2xhrKb/PmS8+xsXyeVnkVQznYJhD4BJ6LZZkIU2FnDFrOHtLOMDK1QGFkjrGZu/jEp36J3OA0X/vmd9hYW8UMHarry9Qq21h5m5m5GQIM7j19mqVbyzSqdZQXkDNtBktFhFS8/ubrjE5MkLFzbK+sY1o5rFyBar3JE89+jGJpkPfefYf5mUmWb15j4+ZVzNBh4fgRsqZg+eYV1q5f4vGnn0IYGa25d0OuXl1kYX4BM2OysbHOQw89iJ3J4/kCy8xi23m2dveYP7RAuVyhMDhMfmiCwfFphscn8cJQp0MEDEPXvwmjLFhIkcQ0oNCWSKEQhiQU4HsehmloZhIwpEkYxOZ77QjVJwsTcz1RxFP3nCY1RbpQq9PjxsoARRgEmIApBIHrsnRzkVdefIGf+umfIlfMR0yo0AIGEl8IQqFLssX4RaoQQ/ngtamuXuM//4t/wthAgdOPfAjfKGAOjDAyc4jc8Dgjk9NJuszQ97Esg3anTbPZZmh4JEIXsotvUnhJptNJqm51kN6WqTuJtr0/MiC1d0rvW8ws9ATn0/097TvRPd9dRiK2Ksda4f5L9XzaH5zdFVq6wkefPkg/o7SWVCbJAFK/xbg4fsX0CoS961cJ051WXmkLwn5S1WvtjfYgBYh3Ypj640zih+L96zbsjfXQYN1Ln5LVCFL0j54+u3PW/fTEV6T7iB7uvv8D1iu1NTFM0cW0Egpii1hMJ7QgqFSIYQqazQahpygVS3iOj6EUQadFdXeDnfWbvPDtb7B8/RK2gpGBIcAgNzTKyOwCN5duMZTNMJizWV66TrtdxzDA8zrslbcZzNp0vCZOp4GVVfiBA0aAYWqI9/0AyzDx/QARxeepME6XH2JJU2vcVez2HNEzw8C0swSBIghDhofGqdZaeJ02hD6GJcjlMszOz+J5IXuNFh965pNsl9sgszzyyOO8/L3vcP6tl7HDKkHQxsxm6PgujtPBjFKY+54uAuj7fmJJQSg838fOZAk8T9dCQmJlbCzbRKAIfA8vlISOyS/+8t/ktdfeYHd7h4xtkbFMytubjEzP8Mkf/gnafoadhss9Dz7KyXvvx2m1eO4r3+LVV17kb/6Dv83IyCjDpQHefO016vUqH3rmKdbWK3zu83/Ij3/qUxw+egQrY0UpbbvS5UHnSop08T2VwHAv3KQAGZWcp4Rni64w9bn3aMWWyijxgQp1gduoHAG+xsfNWoW1lT3q1QYoxdrKMl//ypfZWFvh8PwcI8MjrG1s8OGPPMuDjzxEKCUvv/I6f/hffp9/9P/4v/PSd5+jWdtj6cY1drfXCbw2od+iWCpx6PBRSqVB6o0GuVyWMPBY31hla32Nxx97mBNHj/LNr3+D7a0tVBBSGCgxMjGJNCzW1lYJlM/dd99NY6+GEAIv8NnY2kARMn94nsD1aNaahIHCMjNkcwXyhSKZTJa9vQqDgwWuX7kMEkZGhxgaKuF0Oly6eJ7hoUHq9TpC6kKAC4cOcfc991Kt1bh69RoqVDiOx9TUNLubW9iWzbGTd+EFivXNdWr1PSbGx3A8h47jEAZhVMfOIp8v8qlP/zTPPfc8Vy9fx/MDctkC+fwAR44e4+d/4ecwpM/Lr7zCd77zAiqEe++7hxMnj/DVr/0pKzeuowzIZHJ0mi2GR4aYP3yIrJ1hc2OLvb0K7U4T2zYI8CkOFJiYHCeXy7G7W+bSt57j+13vP0YDEblC9CJXmfq7D6XHxDH5S9fUywFIOj1e6kbyMR4/dTr6TdDppxT9hyFNvETURulqxxEdi92a4oYySqIexMyXBGEZ2JZJVhQSomtIkirZUmiBRBN7gSgWENNTlEolXEcXPczYNtlsjtJAkWa1xtKNbfYqe7iej53LMjg6wtDoMIOlQe1j2yeAJT7joRaG4hejlE65J5ROyygQqKgYX6w9TrSksYChlA7Ai6qaB2GoGUojirMxtMAiTINcoUAmqocyUBig8ujjrC/dQiifXE5XyNytVnDQlbyX13fYrXRoVJrsbe/itGsMjk7SaexiWTmclsPC/Dy1WpV2o8ra8g3q7Uss3brJxtYumxtb1He2sTJZpmbnKa8vo4SJ06hQ2clRGx3GsnI02h1uraxRLW+RHxzhSOZerr/XxmtVcF0XERoQWHT8AGkqhGmQyRUJCPFcl+ruNrWqy3dyX2F06ghbSzfY3dgg6NSpbyzRru0iswaNjesEvk956QK1eoujx0/QrrfZa7RRUxO0Ww1KWUWruklmaAy3VQXbY3CgSHZ8hN2NZTZXb3L61FFWlxbZ27xFp7GFDBwWL1eRQtGol7HzNmubKxjSxvdCWo02zb09rKOzXL92jVajxbWbEwyOTjE2McvA+Ay75Rq5kWlurleo1atk2yGHS+OM5vJ4CELDAKldJrwwVZBPxDUrdDyJaeoKokHoo0KFYQjsjIFQIfVGjUyuoClaVKEUNDz2ZvtV6JiqLlOtz2u3QnjMdaYZaohctoShGWSlhZrp6Vk+9MxHWd8ss5AvRkK01nLGvHYvzlBRMSn9Q7vZQioIOg6GkKxvbVJf2WSy5XHPQ0NaIxkqVBhgWpIwkqJs09D1EFTsKtkNmE5nt7vjdRteV92G+U+eic5roi1MaasTxUB63SlG/qDxDxpPRHsUa7z7J9tfAE+kXt3+MbrvOL3K9PPp+Ry09DiQNT23A4ZI5tb9ObX4g/r9Pve6y7xNB8nexQJAqp/+z/sJYc/NmH7tE+r6x0s923XZituKnmf6rSfJtqtue62U0qlss5aFG3rs7mzjOQGFbBbfabO+tcml8xepN5sMj46ze3OJ3Pg0e7t7ICxmH5tm4fAcX/mjz7LhtZiYGKJZa+B2HHI5m0MLE0yOjXDlyiVm546wvrmi8YAIUKFPGOhELlbOJJPJoJQiCHQyBl0AVSRJLpKDFq0j8BWgayjsVWvUq3XGRmc4fvwkGUuyeOMyS8uLbK5vEgrB8PgYV66+S7nSwvclla0ldjbWaDbLuGED0whAhoR+AEGA0mp/fR4CRegrTEtGsWcKFejAc8PIkMtkeOjhR7h+4wZbWxuaTwgFKggIPY+N1UV2Nld1nJjXpt7pYNk2m6urvPy9F7BLU9z3yFPMzk5R3t3kO3/2XS688galUh7CENOA1aUl3nnjTdbWVvFdBxWVAzBE5N4cSWCJ4lDEca/dfYshtgsMvYJtGpZ6GK0+YaMXRtOw1nu+VcQQmYZOJRn62jPCNnRCjeGRMTbX62QyGd556y2uXrrIicOHOTY/w7UrF9lo11lbXaVRO8Pm5jpOGFAo5Xno8UdptmocO3aE119+Ad/tkLMtBkaKzM9PU2s2qdVqCGlElbMllm0zUBxgzQ+4cf06uzs77FWriWDm+i61WgXfD+h06khDsXLrCqGvmXghJdmMxA9CtteXaTVbKDfAMG1MK0uz1WCvWiafz+vMp+0KoyMlAkI6nSYrK3va8yJjE3gevuuQydiYUlLbq3D58kU6jkuttofvBUgkld0dHMeh0+pw9fJlTNuk1qghDUGruYfjOrieTxDBJ8JkdmaWxWvXODw3h20Y1OsNLDPD4OAwuZzFF/7ov/HBDz1F6DlkTQPLsmk3ajz/3LdQfocwdBkeHqZea7AwN8X8wjx2xubatWvcunkTO2NhGpLQFwgjpNP22Nxok7UzVPb2eD/XDxAMvh+h7tNqaU63h9CJNHWMvie1KdDMr+x2sH9Qlc7hHw2RJr4HIGzo00j1zGc/dldx9oYUwdbjRiQlka66jFE0+65LAySpLUPVZXAEYGczjGSyjI51x5ZCV0SXQuC4LsI0EZaJIQSWbWEZhs5cFAS4HY9GvU690aDT7hAE2s/PEIJcsUAhm8POZrBs7f9qmmbC9MX7Fc9LRWuLlp4UIkwCzJV2e1GQ+Fj2uz9IwyBbKHLo5F0sHDnC1OEjoALsjIUiZKe8SxAGLK+sYgobQ5rk84MUBwYo72zgtCoMj1gM2FlWb60wNFigXq/R7LTJOG12q3VM26ZW2WGolEcoD6/ts7uxwqvPfwsrk2V6aprxiSFME+rNKh2nhZ3LMDw2zsRwnrz0yUhJs7rD5toyqJDRoWGkEeJ6TeycYGP9JuDTbrbx/Q6eX+GsI5g9vIkfGpQyktLQKAzZ1PeG2C5vsruximWbbC7VCVHUyzZO26Xd6LCt6lT39igNDeqK1qZEKg+v3aDTqjE5f4iJkRKVvQq17VU2bl2mU93EUB1M6RO2O5SrZQzLIJOzWV25SdbKIjBwOg4iVNSq22QzJoOlGaxsAWHnsYsj5IYmoS2YmZlh6dYy2cFRssUiQxMzWAMlgqhaq05vqQilZmX6mVQpFO1WA6fTolDI0W43aTRqWKZBrVzGtCymFg6DmUEYAoQBKjLfx96VXX3/HU6gSJjotBAiAKl0IH2snRaGpFgaojA4xPXri/jKwIyy6MhYSSB08Hosc8sIjiW6qFuj3sAUEqfjUClXmJiYYaowSH54XNfn8B2EYaFTkRqEUUpS27b0WY3RTSysx1qMmLftQSvq4KXf5koE/8T9Eb2nBwgF3WdEMk5XJkmxAQmTkJJY9j2///tBLDZxDwkRSLftX+j+1LYHMcMHM+Op+wfsX7KKFPN8J2HtztaMvkHi1MvE8NSlbyK637uTt7MQpRiv1D8xxej5jdQ77hHoDnoXsZARnxV6/8YHuG+cZE1xv4YkDENM20ZKk3bTZXNjlYFsFqdZ59I77/HOa6+D22RiepKHn3yKVqvD9NAo80ePc9f99zE2Okx5fYmv/9HvM1AUqLCN7zZxDYuhkTFKowUC4aCMILKKGjq+zg21AB8oAjcAK1p/qFBBpFQQEkUQoQ/t5iulzvOqVEystTP+/PwRhoZnGSxNYAjF8NAUW1s71Oo18qU8rueyceUCoTIQmOwsXQXAyhhIX+mAbimwTZMwCAh8pZN1JMy7wJQ6C1YQBBomAl3QdHxiEiEMXYA21CoHFQikMMBUrC7fQKiA0HE07pAGCr0PtpXl0sWLPPsjn2J0ZIiltXWqe/9f1v47zpLkuu8FvxFpri9vu9p3T3ePdwBm4IdwA4CEEUmBokBRXFG7op74ZJeUtHokpdWu3H4kUdKKkiiRj+bRCwBJEAQBDOxgDMb2THdP++ru6vK+rk0XEe+PyLw3b1U1MPx8Xn5muqruTROZGXHO+R3zO5ssLNzigw88yfDIEG7BQ2E4cOgQxUoZ6RcZGhli8uA05Wqlm4pt52oqQ7M1n7NRMtKNPfaQ2GsL7SZ6yOv+/KzN5mKvzrZ/TmOMva6EdhSwvVVneGCQSqmESuDixUtsLK/w+isvs7Iwzz2nTuL4EscRNNt1DIr5+ZvUWzt0ooSRsXHe+uiDvPz8M9x17Cjt5g5KhRQKLtVqhVKpzOb2NpVSkY21ZVCa2qCtzdze3MCohHarxdrysn1WIkvjTTA6QiURrqPROmJnO8CRju1o7rgUyiWSpENjp0WlWqXT6aC1simbcYQBosjWH6koYGx8FGU0rXaLMAhwZaoYjebgzAGCIKATdGi32jRbHVu7qA0C2607iWMwlglufX2dQrFAlIQUih71nZgwDCmVyowOj1AuVmm1AqIg4rVXX+XA9AF8z3ZhNzrAcWKCYIdvf/tpWs11mvUmrpSMDA2gk5C5G9cpVTymDkwgpWBnKyRRIZ1OnShykCIhSTp4vkFray9IBLE2RGFA6HrsbG3xZrY3T2+L3jPp9itMpm9y7vL8iMwbmNV22HCbyYWQM1HePTIn8LtKPf09U7KZYu3zvuXOtvuz3gc56yEv3NNF1K2tSk8ipU1HMsakKVW5UdtVmQ4rx6RjDMpWgue8NIAjSLRBSkF1ZJCB8SG00ml0RCKUPYeKYuJOQH17m9WVVba3t4miCNd1cYRkdHwUPTxMuVqFUtnmxmtFGMd0gpBIJTi+i+/6uJ6L63m4TvbaRdoh1ia2GGXTx1whEI4Vrlob22U99+5dR6A1REaD6zIwM9MzQozh+PRhCo7D4aM7JFFMseDjOA5xGLK6tMB3vv0tSkZh/ALrc7e4feMWQdhG+i5O0WVwoMyJE4eJVczU1AyddsDm+gbry3Ms355lcGiQ977vAzhmkkrZdq6tVn1OnTqGihMqvmSo5FP0fRo7GwzfuoXruEwfmAKh2KmvksRNbty4iRQCT8VgNI7xUM11TGucWm0EPMnBqVEK3hibG1XipM3GQkyxWkGbGIRi/tYbFPwilWKVJEyIgwa+qBHomO21ZaKOIo5sE7gjx45wcHIUFdZ57ltfpVlfRcVtPKEoFFzKpQJbQQPhlInbESqJLS98oUit7IN02dla4/ip+xk7cJTy8DTCG6A0MI4slCkPjnDkrjOUhyYYGRkEaVOKkq4Bbud0oozlg5e5xWUMUdgBFbEwP0cSdZienGB5aYHZa1eRWrG+usSBw0cYHRumUBsGXOsFzC3QzIAz3WhGZkhBL5kjFfSmt3b3LtKeYWcEtgDfwIHDh2z9knBw0m7s2XEWYBjbGNTQZc7SGlrNNlI4JElAmCQ89uBDzJw4RSwcWolmZWuTsfFJkGC0IgwCjDYUiqWuJLFRF9P9K9vMrvH3XCPpR7nv922U131AJgdc9pevu/FM9pkgT0CRvldhmfi6ESTDnjPurlUQOUdEftO5A/uM+10Rj+z7/nN+N4M/lduZZzT/Pvv0Ar0vuveZ+3sfI/uOwaLMGttzVnJRm1wU2ewHCPrf797U3TsNoAdoemBhn/csRLfOSe96nvsB+a4e3D2GdM6azPiUgOOgELi+y9jYKMu3F2g3GqzM3eLWlWtMDAzhyQG8ao33fvT7efnlsxw+fpz7Hn4Yx/PYWlvmAx96H1/5w9/gxo0rDA2VQUTUmzvotQ5RUqfe3qQ1v4PAerZVnKAjG2l3pEsSJSilcRwnrYk01nnmunhegSgK7b13I/G2J1alXKNRb1IolHnrY+9ic73D7LV5tIoZqPqUSwMESUy5OsjO9jY6jvD9AgUPlHHZabYoFKogbDNB13GRwhAJx1K6W7c80hEgHRyZUn0j0t5IhqjdwXUcXvzOC8RxbPWpMUSxwfEk1aEaRscUXEk7sA6MoYkJquUa5XKNR976OLdXv0zB92g1mxR9n8fe9ggb83O4nsPI6DDtMGD8wBTTB2dwHYlw7bOhS6phUnvDzoOsFgtSR6HpWx575+w+skXmv931dWa7idy+XTGz6xKWbRRbQB+FLC8t0250GBkapblVZ2VpmcVbNwjaDeKwxXPPPo12DAemJ4migEqlyOLCLVaWF4hjxVKpxIEPPskrzz5N3NhAJyFJEqAxdDou1y5fYWl5iXe9+x3Ut9ZpbK0TBXWE6xJ2AgYqFQarA6gwQGmb8u77HrVqkUqlRKutiSKF1pHtgI0EYamVw44higMc16FaLZGENl1emxiShEQb4riTAq+EpaXbiBQY28dgm935nsPExAQrKysEQdhtmOm6DsaxaYNjY2O02wEqaeO6BiFtk2qtDTpRqEjZdMOiZLA6yKGDh6k321y/doOd+g7ra8uMT4xTr+9Qr9cZWh1iYmKSYhFef/1lklBxzz0PUix6NJs7+L6k2ahz/PhR1jdWkUKzuHiLtbUFarUqtYEBHBd83yEM22kkzdLESOkghaRYKO6ZR/ttbxpo2ElkdgnPXVg2jwDSz3cDDXtUv3/H9H2X7Wt6jkEBQu9G26aPq79rSOXPIvKLQPT9yGSuzvbOr6IsTz27J2Fz0SErms6K62xqlUCANGiVsYPIbnTDCIHEFpfmvWQKMI6wzhnSmhNEl/FJaXtut+Az6A8zNDrMXadPd+9XCEuv6ntpXrmBRGk6QcDGxia352+zML9As9OmWqsxMT7O1PQ0ExPjeGVJFMVEQYzjuTiOg+s43eJzkekj6aQUulaUaZFPVRDWKBMgnQKxUmkTOxeNJNIGrzxIoWKNP6UTPM/j8Mm7qJWr/NkffZZrFy7xzsffSdjc4sbsZdY2V4jDNiXf5fxrL/OuJ95P0I64dXMOaWJqBYlT8pkYq/K7//t/hsowf/vv/wwHDh9nemKIlZU1vva1Z/CF4C985EkSHdNsd3jXE09QrVaZuz3HrbmbbO80CVpbSOmmKsQyHBkVQFRnrCbZaizTand4/fmvEoUdm6qDxscg44gwaFCtFZEFlygKiCUMjIzT2FZ8/4c/xBf+7MtUB8aYv7lIp1mnVHA5PDPJlTde5/lnv8Xhg1NsySY7m02iTotmoGg3UsO4E+AXXFwpqRR8/IJPoVhm+uBhyrVhtuohUjqsLK9gnCaTFPALFeZu3eTw8ROMTIza4kqToMj604CUViE6TkpNS5xGFAWogPnrb9Cp73DjxiVmpqeY3Zhj9vIlrl66iI4TBgZqrC/Mcf/DD1CqDYCw9LEqndCu6+SYSzIngqFbC5WzJbuF5rsspJ6NZgG6EbYY0wBJpPCLLq2thgW/jmfXXj58T66QOp27Ujg21GwE0vV457ufYGRymnaUYDwbYt9YXmFiaAghJSrRrK0sIx2Xg4eOoLU1iJROSRtykia7IbP3BthvyxulmSHdO1bsYxyQE1D2y741mLuUzOTznkvvBQ7dp5WvcegeutfAz67RX8IMfUItd4+9K/TG028Im/572e0oEoLdBnz3vCKT9Tm4t3sMewAI+9zT/gb+7t/7X+ne7/t/75Fy7Ad+yJDkngv3Qah9zMBst/6HuT/Vbv+CciQkiULpPMCxOqNUkDz00AMsz91mcfY6gwMD/KW/8qOMjw5z5cpFrs8t8J4PfIjB4SESnbBw+yZ/+sef4ZHTRxBxG8eD4ycOs13f4ObcLNtb6zS3lygULFhwpEcSa4QG3/dxAYMiVAmO46bF/C6eJ9O1KhkbG2dxcRHXlWgNSVq/USj6TE5Os3PpMsOTI5RLJa5vLtDY2WFosEqlWmV1fQOnIFlb3cCRilK5zOBAjYmxCcqlCt/+1tMkQYQnJUK4bG5sWapRx0UWCrY+Q0oLeqQkSeI0S8AjjhOMFvjFMteuXAVsTaYxEqMtFa+QPtMHDjJQG+T2tWViZad6ySvyt/7232Puxi1+9w8+y70PPQrGcP7c67iFIvffex8Hx8b5w899DpRic2OD8fEJSpUiRtj0MpP1LxIGpSwVtyAr6u6tWdF79T1nzXeds+ySMXeaT7u8Ot1je9eV2dzSVii60sWTDlcuXaFWG+S1l17lvjNnuP/MKS5feJ3Xz75CfWeLZnOH1bVlHGEYGhqivr1BtVrDc32uXjzHysIczc11LrzW4fDBA3gkhJ02sQNxlKCjmLWlZY4dO0I0M8Xsjeu4UnDPww8SxxHPPfMMQwM14iAAsK0MRodZXVthbW3FAnthGwjrLLKMrV91pQNotjY2sA13DcYkSGmphrVROE5WLyXSOkZbBB8nCa7rst3Y5rXXX8Noge1pYxvtOkhqg1U2t7aIwoDNrQ2iKKFaGWJ8bIJiqcT87dsIqWm3W7iOT6cTMjc3R73eoFqtsrGxQrFUAqFJkgBjIuKkzfp6m3Znm5HRIdASlQjbQLAgiWOHne1NPF9w88Y1271cGkoFHwQ0Wzts1zcplgoMDA6wsdkmS4XW2qYHKpUwPT2575zZM4febDH4v3+5SyTfr0QzJND/wV5d2Y1D55Vrpmx6SqGfqi03tVOLROw6n0zZm7J1orsLRmdnz86wd1S5W+9TBbtuR/cZBnv3MwaSzHpKje8MsXbzJ/P9RNKGRBlY0SnDVJ/n0/ZNs5iny0RnFavEeiqVzkKm/TeQGXBuXsoYy7awvW0pyS5cuEDQajM5OcnRI8eYnJxkaGiISqWM41jPd5xY8CBdJ6UdtdeSMmN7sYIv0QbHccgKR40R3dQtYwxJbHNuXUcilSJpt3j95ecpk2DCBi8/93VuXDlPEjcZGhnAcV2kW6YTKHbqLcbHJqhWyrR3Npm/fglcjVMsoIwLwufgXfdw+oFHOHzsBFGU8Pu/99vEi7f58b/5N1hdWsaRVmG12x3aQYuXnn+G97znbWxtzHPt8jkKrsCohPrONsVyDY2hUCwzOjHJ8soa01MH8d0CywtLnDl1ipvXr3Lk8AG261ssLC8SpgAzCUKKpRpGQxQJ7nvgrdzz8Fu4vbzCKy++RLC9w8DIENtLt8ARSKkxuYZURiWMDg6hVEyiQsbHx9narjM6Oc3M0eOcff0ipYERBoYnaHUSVte3mJw6zJl7H2JsaoZLszd42zvezdHTdxPEcToPbNRMShetJAaJEZLNrQaXLr5BrVLgrmMzVD3DU3/6OZ7+yp+Airj3nrtYXlxguFZjsFLhjQuXKFYG2Vrb5uf/yy/jj0zSMR4JHkJ6SA1aZfajwQiNkam3P2397qSAI5vlWliWKZ1RXJF2VDd0PesGbEQQ0k7sYBJFHFrGGtf3LFjpuX8Rynr4pLFzNQ47fP0Ln+HmC18h7rT59E/9faZO3IPySiRC4DoOO0tr/N5v/TaPvfMdjE5OMjIxgV8qkRib+tGJI1zX73mh89o7L2PSCEJerMpdcsMY1WdI665s7JeB2Zm7RvNu72G2T+akMT22ozy9g+65U/YaF31AQ+yJaGT72zP0IrXQi+5m5xK7jtm9ZY4hA5h8B8H8vdzhHu1ld/thv4fqynRDVyeY7jPOzpc7+R233jvYxRSVe+7Z3/nnk5Pme1Rk/s8McIrcOTNHWP/1cs65rEDdmD1Dz2o08roy65OU9xUKASYxuNJ6621CkgGtiMOAsu9x8eIFDh08yNlXXuTF57/N9toC8+dfxisLahUXlYQ88cR7uX37Fq+8+hKFksupk4e4cf0qKtbEcYIQPhiJlBLfd+h0Ovi+TxBElEqlLkNiNgcdx6HValEplmg1GniFIsLxbHTXLzMwMsrU1DTtVsjq8iaN7Tq+5zA4XCPSMX6lRKvVIGzXqZQKxHHcjVBqI1BBwPBgjZ2tbcvsJbP3JpCOg45CvKKPKyRRGFEsFCkWy7TabZtNUPDRWlMqFVFKoXSCEOB5HokyJNrhYx/5BN/8yjM06m0Gx8YoDw2yuLTM2PAIQnoMHjjIrbkFHnjLYzzxwQ9y9MgR5m/c5E/++PN8+KMf4bf/4Pf46b/7tzh9zz2odM5GsUJIB8ezHdBl3wTJgYBcg9keMO0JrDvZMXJXlCyzzfr6/qQLVKa0+dbLkpMh6Qkz1jDXkWxs7PC5z/wpn/7LP4pI4Bf+t58jarXoNHZQUcCxozMcOjDJ7/72rzM1PY7WiqGREQ4fOYJwXJ77zvO02218CULFhK06Zd8HrQnDCOmW0cLh8OFDjE1MEEYd5uZu0mo3mZk5wIMPPsDv/fZv87bHHuONN96g02mDURjSPku+x8iIdVQWCgVr92CzPRxpC9p1EoG07J7CcSn4BRzhEIYxJn3/xoEgbOOm0XbLWGapmF3XZ3NlHUcWKBYryNS4830PiIji2MpXx6VSG8LggpHcf/8DRFHE1NQEzz77DJ7vUir5GKNptuqsra2BsdkyWmuiThuEwC0VKBRctI6tnFaCKFRMTEwTBAEbmxsUSz4nTh5jdnYWg0YKk4IsY9+v4yCFT7vdplAUKZlDrxpbKYV0oHF1me+1vWmg8YuvpN7s3OTOUou6fPg5VNwPeHOXsFZ3bjobhHC6EzUPNPqQeLp47gQ0svFkYzBpQXQ2EpOFJvLbLqCRpyTv4aIUGH2Xp2SMtaXSNd4FGpnw3DPW3HfdR5K7pjEpR0+mWbI0iHSnbu2F7gmN3fSTGtPtZeCmACBP2avT+gvfkyhlrxtFMfV6g7XVVZYXl7g1f5vG9g4ag1soMDg4xOTkBDMzBxibGGN0dJSMbywrNs9SPmKbVUUUGTwPbt+6zcbaBkbFLMze5N2PP8pz3/wKozWf5775JUzUZGpiCNc13JidZX1hmZnjp0hig+cVCIMOWoUM1IrU62tsLC/zwGPvpDw0xtWrN9lY26RSG+TIPfcyPTXBV//wf1IdGgBtPVRRGKESxcj4CFpHjI3UuHHjIkLHFDwHlUSEQYdCsYgB2kGHSm0Av1BmeGSckl+hsdng9u3b+MbQ6bSpDFToRCFH7zrJ0ZMnicKI119+laOHTvD66xeZmD7M5OFjHD99BikkLz37PEcPHWD+9k2Wl27ieQ5DQwME7SbNRp3RoWEa21tEgU0bOHn6DEurG2xsNfBKVQZGJxken6YyOMKBmcMsLCxy5OgxRsbGuHlrjqe//W2e+NCH+PAPfIydTsAzzz3Lzs42A7Uahw4e4v77HiXUAr9Ypd1RvHb2LDsbqyRBncb6PK2NReZnz2PiJp2dLYyKGahVKRVLNBodwkTy+BNP8sTH/wLDM8dRfo12IokSGy2Jo5SSWRjoAxogjETmIhuGHNBIkUW3+JA0Zzu1lnQu9UYCaGOpMaWD61kPjDVc0/+1wVGWklk6gjBs8ad/8Nssn/82YafDj/0v/4DJ43ejXNurRSaalavX+NX/9J/48f/7X2er2eTgiZOMHJgmRmCka8FQOrZ8zqS1lzOhKFJMlSdv2KvYjdFdww8s+UK2c996Nv3Hfy+g0ZMleaCRwYOuQMtFAfrlxm6gkffKW5a/HJUrWeqdvQLmzgAj27rpFmTpH/vcy3e5R0HvNro3cIfN1iOke2l7YrHnGeT+FXvP1gcG3iTQ6B2YCunuNel77vveG/nmg+QDden4LRwxKYVo75mYPefbC2Z6ekYpkzaks8e6UvTWJoakE/Br/+OXmR4ZIGjtcOXiG3Qa21RLDiVfc+XiK7gyIQ6bKdjUCCnwPAffdzCqQxwFveY4OLbI21i4mhXrYiRJEFjd6znINF23Wq1SKBTYWN9KdZ4g6z1gpI0otOsN7nnoYR55+FHOvvgK5197nYmpST7xI5/iT//sz1henEcnAVMTY5RKBVrNBhj4qZ/+O/yHf/fvUWFA0GmhMip7AV6pyKFDh5i9epnBgSoAQSdEKWujGA0qijh9770EQZvt+g5hHJD1pNAK4iDmkz/y4/zIX/w0/+yf/FMW5pdx/CLjB6b44JNP8pu//huECh5++zvpRDH33H8/MwdnSKKQqbER/s2//FdsLSzw6Z/6KRbW11nf2eHeBx7kR3/s02iTZjo4EKNTytpsPmVzU4CxlRl5Mm6T0YbvG8Wzc0/umZx5oJE7XqTrIZNPJr+u7PkdYGVlI2VSmiKODOtra6wvr7O2vMi1S29Q9iQOildeeJ7ZaxcpFV1GRwa5554zFMtF2kHATqNBu91GCEEStTn/4ndwhKDgubaG1PEZGZ9BC5fl5WX+6T/7eeqNBl/4kz9iZXWJialJrl2+RNhu88GPfAQhHGZnZ1laWqTTaeGk/UVs5Mq3tTjSBWEjE0YpBAbPsVknnl9gaHSUdqvF9ta2dSIpmwrs+pnAsTpCGGxalNEkiQLj4rkFxobHiMKIzc1Nir6HNjGdThOkC47D0MgEo6MTSNdj7uYcYbOJ8F1LCoTGmBghDb7v4nmW8l84kvvve5Br166xs72NdCXFosfw8CDLy8vp9HBsZFOl89138X2368gzRvXNCyk9BC7CFThCk6iIfEmB6zgkJv6/Fmj8x7NYjnm5azoaS5uHlKnn3fR19s7SNvLhtS6vfiaIpdP7LjNCDFaRpQog63ORKSIBKRtTf0Fr90V3b5C8P6/3b6rwAFLqe7JwfKbkDfn0qp6CZff1dLr40mhGbslbAz8DGl1lbrq2SrbI+5pdpYtZQZoypnv3ZSBj2smaHmU5mz1vVWpoaIMje4vfpJ9lBbgZHXGGUq13Ne0/ojTKqK4QyWCeEL3ISxiGrKyusLSwxPraOp1Oh1KhwMGZg5w4eZJyuUS1WsQYiMKEleUVZq9cZnttmddeeoH21golV+M7iqizQxLb3MR6fQtHOjz04IMUvRJvnD3LxtoawnUYnRzjhz/1Q/zRH32ewclpJiZncNwCzVYbx3E5ffoU9e0tkqDJSy89R9RuoFSM1jbUZ4S2rEImIY4DBArHGByskRWqGMf3SNAgXYwC1/GQOOhYI7RhanKStdU1OmGH6UMH6bRbbG1vI9wCnnAZG5qgOjDMrduLhK2AwbFJ/EqN5Vu38atVPv2jn+KLX/w8733327ly+Q2uXbtMo7EDUYwR4HsFIuVw+u4HcJ0Shw4f58ixk7z+xmVeOPsaoxOHeMe7382Ju05wbfYKy4u3ESQsLtxicnKEN155mbe+5wmuXLvOdr2OBqrVAZ544n1s7nS4cHGOj33yU4yOTHD+9de4df0iA0XNd772BWpVj+2l2ziOnXd2udsC6XvvfYjrcyvc89Z3ETplYqfM6QfewgOPPE6QWIM8K0NSRqWLNF2tmSEjgUR0rahsCanMq2agW9yYTXmDdRxk6yP9QitDkiRgFKPDZdqRIkIhkLhKIhOTpo20+cPf+TXmXnuGZqPOT/3sLzB2+CRKFul0IjZXljlQq/Iv//b/yk/97M+w3Wlz8K67GZg8QEtr8F2CBLxMsacjz2pBuspcizSikRu4XdRplCF3bD562eeIyX70Cju7+2V/5G2FnHMCeuu/K+TScYrMaOgaJj2wlH8P3Y+6Yq4n7zKK4kwmGJGm3UH3fe2RjX1bZrCIPvbB/NaT0Hl5dodzCdPVR5lDZg89usik+F7Pf7affTfdEPReENK9ZA+8ibTJyZ5cd9H7KVM5TO7ddK+ns5RUdgE7uoadI2Q3lbb3S3b93Q+6lxLV/bw7N0XX+217I6VzVGsKqW0kjbCFzYnGSWJ+7b/+Jx45fZDf//VfprG9gZAa1zMImRCFTQq+gxCGIOjgug5gKakxquvhBWF75hirp6WUuJ5HGMeMjIywvdPgZ3/mZzl//jzPP/cc66sreJ5LEEcI6aY1g9aQExikI3B8l9gYJibGWVvfRPpFakMjHD92mjOn78NxPR5/2+P8P//eT6OiJirp2NpKR+IXfA4cPswbr5/nyNGjbKyv0Wm0UCltbXVwkHpjmzhsMToyRBh2rFGGi1KSuBPiFksUfY8gaHP6zCnW1tYJw4ixiSkOHjxGdWCYr371Gzz40KNcuXIV6Xjcfc99TE9O86U/+zLveN8Heens69x1+h6OHjvMhdde5sql14EYqUOCThvh+IxOTtPYavCBj36MJz78/SS43FpYotXs8EM/8nE6CHDSmjGt0vQdB50YfNfDZNHlrB2BtPNfYWw6kOtgTG+NWNsgxnUlMk0P6nqvU2eCSOedQROGIa7j4Ek3FfOSak3wxvkFmo0Wh2YO0mkFfOc7L/D888/z5Pd/lBNHj/EHv/d7OCbm1We+QdBp4PkO2xsbVMsF/vKPfoqvf+0r3LxxnTjoYJKEcqXM1JFD3Lg+i+UrTO83USilGBwa5fF3PsFb3vY4X/vaU5y/cI6w1SJRMZZqF4xWFgymoECTOV0FruvgSI9TZ04SNJvUGzt0gpA4sc1aE60Ag0oiC2wECK+QSRh8z0NFNnvAcWw1T7b+jbF60Na52j5sWhs810NKB61NuiYk733iCYqlMkEQUa0NsrNT59zrr7N4c45CqUSQBIyNDVOqlNjZ2aLRrON5DoVCAa3ASPDcgtWHqaxROkZi0+yMspT2xliCE9d1iFN2t06nlRNxmTNA4jiWPteWrPRqtDM6agwYoWne+N5A489Bb5sz3skJYCGsQQwpwt5L9ZgJZciVg5qc2skXAqbS1xYpi25TvvRSqRGSAg9sHwirRvanHMwSqGRq67BrH3OnD7rXTFWJzity+n930ihDGs7o2wfrJepXSakBkN6zDbaIPkPKpMftXySZjSX7UPaPJ7uPVJHp3LMxad8Na/sJtOnVuiAs4w+AcRwkXjfnUqYK0+RoMEuyxMyBAxahRxFaaVwp8X2fYsEniiIunJulXq8TRTFaKYTRjIwM8+Enn6RWdlm8eYOXX3gGooiJ8XFGhgZYW1tk7sZ1Lr5xkfe86134RZ+DRw5SqZa5MXeLb37zG9x19yliBbfnbmAQRGFEkiRsrtym1WjQ2Vqn0WkghcFxDUJa+kSJIgwiu4jS56K1ZTlxpKXzVUoRJTHSUXiuh4o7KA2OsHn6G5trIDXSc9jY3CCKI7to0we+urrC2uo6heoAxbERagMV/EIBefgAU9PTLC7Os7mxxvPfeZad7Q3iJKJcKaOLlvnk3gceoTp8gKHhSdptxeLiGleuPs3EsWM88b6P8vi73svFy2/wzW99Hd+DoLPNjesXScIG7e1ZonCdS2efJggiiK3A3NpZ5OtfXCXc6eAPH+Lzv/ofefLjP8Tx6REqYobZS2dJOtvIYhVHKKSB4aEBNIpCyefoseOcffUcXnGQdn2dW0s7qMIgkzNHAOtdCWLLzmRMCubS3GqRAg6jbR2Rk60F0Sv4zlKmunN91zrLYHHf+pA2rzaJQqJOzObGGttBk0KhRNUpU/XL+KWCDZAnsa310AlhGCCwqYWugIFKBc9zQMWoOKCxtUnUaduGf0ISxBohnV0mZaZQ7HoQRoI0ZPrM5NZyX65/nzFI3/d9n0G/Rzv/RX4MMjNMe88l71jfBQMQeeHQxWw52Zl7DbutfAf65GWfHtgFnvaz6vPZs3fED+n33xVk5GTz3mNzUjZ9gDI7Zp/n6aR6YTdg2E+X9A+sRz+7ZxyiN3bZf4bc2HrnzuZKb76kYCx9TmaPvO8d35eRnBtPbkoghOmSJmR+LMcBlLTduqWDMTA7O8sLzz5DfXWJm+deZv7sU4TtVTwnolh0kQ5ESUi14tNs1kEpyrUqxmhUYp04WmscaftIxXGcGsM2X11rjUoUnnTYXN8kMYbf+M3foFW3EV2BQCWqC74c14NEW4Mx9VhmXtd6vc7w6DCx1rRbdS6eO8vclVn86hCvvvgyAkEcRgwNVgmCFq1WkzCU3JqNGBkbYXnhdhpV0XiuhyNdgk6IIxy0cGg2G/i+i+u6KGWBcaFSRmnbyDOJAtqtFkEnoFlvE7QX2NhoMzA0RhgoqpUaH/8Ln2Rja4u52VusLCzwgSc/yKPvfDf3PfIwFy68wfPf/AqrK/OE7S0GKwWeeP97OX/+HLfnV4iaDaI45NtPf4u1rTqPPP4uDh09yRe/8CU8xxAq2TWYBRrPtaacxvYpyd5pFik2RiCksa1SHZn2YbDzRKUU5tJxiJOIolvMplJuSqczVUDBdVCRwBMSL6W+Nybhs7//FV577SJHZg6zvrBMHMXcvjFLHHQ4fuQQBV9yc/YKZV9QKFlvuTEJQ0MVfNfhM7/7W9TbDYKgjSsFlcEqvu+xPD+HUJFtnJiC/VK5RBwnJFqx3djhs3/4GeauXaUdhxiVIAVonaBVQqHgI6VHkijK1RLtVpvSQM3eb6x46MGHKRd91oVge2fL9kUTgOsgkSiVMDA0RsH3EULQbLVsmwJtiOMkreOwz0ElmmKpgDaaMIqsM0Y6JFGC43s25d3YOS5dmfYwk7z0yiuAIAlCpOuRJJpOq0mxXMT1JMLzCcIW2oRoHeH7NlVdaUXmRYiiwDr50zR8R7joxKbp6hTwGKNJEvsulVbs1zC2T6qbJPV4Z5pE9rGaOWk20vfa3jTQyHxCMjXws3B81wMPaQF06vMxvd8zszm7GZtnlMYZcqF8kxqzeS+TSA3fLOyePQYbOdCpId3b8iI98z7RNeRTAzuDTTmnnkg9f9lJbA1rLzLTpbnFLjojegkT2YK2Sig3hlTa947Nq/m8auuljaQPqV/57/p8z8dZSkPOoLG9CPrVZ5bTm3lYLZhLh5bFw3rypHsL1nBKp1amtQ3gCDynQCHPPJDub0GHYGBkhMpglTiOEQYKrotjNCXfQ+oYheTQ1g7bm6sIE7Hd6rC92UErl0Yj4NIbVwiCAM+V6GYCJuH2/E0mDoyztrLExtoGcRxTKlU4cGCGY0eP8/rrryNch9rgEJiETrtB2IkQKAQKIyEJQ7xCAVvIZ+lME6Wsx88ROAaE1giVQMqKooTCGEGz08R1fZI4JkoUR44eo1YbYH5+kaJXYmlhmQfuv496u2MFuYrY2WrS6XQwKmDx5lXQCc3GNoWCi+dVUs+Zg9Iup+59KwNTR9hpxgz6VdyBdeZuziErw4hChdlbc1w4f47R0RL1zUVWl26RtDdRSYtOkuA6Cc3tFftujcAztoCrsd7A0Q4FU2NqcobzL3yZUrVGFAfcunKBgm9o1dcwKkDphFbL5rEmymdtbYmgXQfhMH/jGv7AJPe97VFOnzmFNgplXFug7YJR9v0LYemT83n+MgUcRmTzOz/v95nbfYugJym6E81YEgZhBDevXmXq0EEGimU8vNQe1AitMSpGxRFohedILDOvAJ0wd/MWZ5fmqR04QKVWZeXCBaZaze4akcbKNie9ttk9nO7QBUbovq+E6AkKAeyJPOQXTu4+u3LOZE9OpAZsT/Zm5+kaltDnTRHZmXJG7e4rdceYG0e/0UpXTmYyytzh2L6C6F0XyY/zu6VY9YGzO/RIEtkJ05vpAwK7rtm9jz7B3NuynPM9kQn2kb/ZfUCm7PaMuzuonP7bHb3qpaLYrZdrv5vCNn3nu97Y3lS53rXST3PPMXcvuUmlE4Pn2qoM0t4lI0OD3HXiMDfjHS40V5CigeOGVAeKxGGHIAjAkcSxBRTlcgkpJVGcWHUgMzIImXpWbbqTViatJ7RryNY1KIyB+bl50GnULaUddZyUCVEpm7qS0sALej14Op0OA8PDBI06JJokidlsBvidAMcoKuUSra2EMAjQiUIicIWgUvBoteqEnSblUhWUxisU8VyPRruNlIJSsUwcB2nfDk2iwC8UGB0bZ3l5meHRMVYW54njGKU0SmsqhTInT93LTqPDwcMeQjpcn51lbXmR1aVlkkQztjROfWeVs2fPcu3SRRbnbvDwww9QqRQ4//pZrly+wub6DgOVUQ4fOc7ogRmu316g3gxwcPniZ/4IChVWlxsUhwdBCJuObSQqVl0mIJmy8XUJabI0q3Q+mNzzRKRgWwuQAt/10JAy+9mCZWmnDMbY9+J7ggtXrzE9NcaB6WnC0JDEis2NHV59+puc+NSPsrZ4m+vXr3Fr7hblapX15dtsb2+CCigXapjBKuthg/pOA6MStO+xubaKcGzKkhaSKIlJVEwUhbieA1gWq2KxQKlSxoki2kHE1atXaDSbjNRqdDYDDBqlbcqT4wjiJErrWgVRZL+P4xARC5QyLMzPITB0Oi2iKCSroXOkACFtR3vXoRN2bOsAR+B6Diq2LnajSQG7h1/wrB2hNVmE0s51he/beiSlNEbbiL8jLeva9vYWOrGAPfNUCaBQLKJUhOc7JDoijCLAOgqyc9lURAdjjHUUG52zvy2gFGkEyxg7tiRJHazSkFGpZ2UCYBMR+izULNU/i9SnTaLNd2EUzG9vnnUqTw/Ts857vwpBZvKnOpd+bZMBkHxoOk2FEvm9srSJXM5ghhXoGSd3UkL5rffYUoN/1zEmUxqpUS9yx3WhgCGNhuxSYruAQnZ+2XcvpGPPSOgyBdx7Atm52H0c/S8akXvZ2Udi34P67j/7ueupd8ff6+Pb79Xsu1eRK7JPJ6ARpotN+qoWu8BE4Do+E9MTOI6wjFzGpnLpRIFWRJ02ozOHebBQodXYpt3YprmzydDgCMsLtygVJJ36FomCdmsHYxRGaoKgw8Ltm6ytrhCFEVEY45gEHY+gkwCjIqTvceDANBjN3K1ZtFYM1CpUSiW26jt0mnU8p0gURdm6sWwRJltMIIy2Qtmx70fpBCE9tDJESUy5VEa6PgO1IWrVAUqFbds11C9x4tTdvPzyq3Q6LcIooNNukoQhwkQYpZBS2VxLHLRWJErheB5auVQGxjFeDVNSDEweZPjgXYwdO4PWCpMkvPzCs9y4dpmiM8364nU2V+cpFhwEEajYdqomM/YlvuPg+JJ20Mb3SxRlm4IXcPXyG4RRjJCC1s4mnidJ4hZSKJSO6HQsD34QBURJgudJ4iSiubbMPSfv4d4H7mXm8EEC0pQMBxA2dVInCULKXi1Cug6EECj6c0GzOfbmkjghv1ykI/A8F8+FyxcuMj01xVCxTBJrms0GYdtQKUqioI1SMWAo+B6uI5CuJShotZssLa9Qm5xip9FkZWWVVrtFljLmCsu41q2R6p/u6foVuXXW5wrsM/Tz99nzSu82JOk7V9eJLvqjpXbf/kZu6RD75dkeA3x/QNBTNHujE9/7XL2x7xeN+F7H7d52OdbufOzu+ojd5zB7x94P9qB3v7tZrt7E9fd8vn89X39RbcZAmI1jvywAkbvOfvfWe4fdu8iHMdLxd+tuhO7pwlSg22CcRBqIw4BqucCp44dZmT2LlB3KFUljO8L1i4SRIlYRjvBSECFwPd+m2yqNSR0LQlqGt8wAylKHu0BVCJuOIkn75Yhul3MhTLewWml7zrtOnEzz4beQjsOBQzNcu36dY3edZmdnm6gd4DpOKlsMg9USM9MTrKwa1oSg3Q7wfZfBgSFKJY9ERYStBmiFUQlGKVzHwXU9dJIgPdf2wjC2gFZpjeP6FItF65jTCVNTE2ysrVCpVhGOD7LByPgk73jXe3n1tfNsbawxv3CbcrVE2G4SR23COOHG9Ys89u638sw3vkgSBdSqFapVH8cRKG24NbfIQG2Ux976HoJY8c73vh//1bMsrW2AcVhZWuHMg4/ynede4d0fegeuV+yS5Bid1eyk1UQmNVwsZMOVpKnnMm3mm9paBtvI0QBG4AqXxJiuc7Qno7L97Nx99cWXiO4+xeToGFK4gMN999zF2QNTrC/Ps7WxzuWrl6k36xw+cphnvvllBgcHcElo7WzSaTfotBp23lUrBJ2WNYa1QhuNSRRaRYg0IqOEZS1TgQIhSFRi90PTqG8RdgK8sRGMTtJUKdUdv0pim7khJH6ljFKCKAzSFHnB7ds30/ViGRkRIFLmsSxDJQwDwjDokt5gTK/dgRaMDI2ytbWNJI1SGAsipBRoHaUONm0d5o4lRnCkQ6I1xui0H5SmUCmBSdOd0gie1gmOToF4GtGzZqRJHW35tC3TbRZt97esbq7rdsmHsiaZYNKImKBfZWW2r7XpMzlls19sbnS3hvpNKu03DTSS7GKpBMsiGZbRIpcnS5+oS3/vhWfyuaa7lbJE9PG12892gQN6k3+3GO56m7LP+uSuzl3KdBV3Rn6Sz/3OTtD14mfeAZMf7e5krZRdpuv1s5M4E+4ZnWemtLM+An0WQe7c/YpoXxOmT3EKkWM86dc33eeRgYyMWV90IVBOouyHWLL7zR6R6BmNmPRsOeVtnVp2Z1daIYqQSCu/McJSCxZ9n/LAENNHjuFgkEJjTELQ3OGV555htFbi1pULPP+Np2g0W0hp51qShNy8fgPPsQtNak2nUef6pUvMzd60C0q6jN97LwjD9sY6vudxcOYAU5OTnD9/HgfH5rTGxkbnIfVaCyuYlEY6ottwyklZvqQjcKUkDGNqg4MMDg7RbrbYWNkgjhIwgkOHj1IqVklizdb6FomKcBxDuegzMjyIlJL5+TniUNFqBiDA8YrESlAslFleWcVTBYYmD1EaGGZoaIyDJ06hkoRyweXSxddQQYOz37kKNJEyITTgO1gwJiygQ9uUH8d18T2XoGPQcQcTtzl/9jtoI0lihVIJjmOIw4iSL9GJtgxLjotGoIwhjlOaPyHAkRw8dJBCwUelnbSjWBElCuk4NjyfMknZnM/eKtYpm1p+Xtpfcul9OUBt11/e+BPdhS4QSOFScCRSauZu3aK+to6YnIbEsLO5QZKEHJ2ZJGi1yFI4jU5QcUwYtwg6bYaGB3ng4Ye4cekiN+dusd3YIYyjtM5EpkXPOjcGek06yUcTrDIWuwzWvpQhIXtyJXf/+b+7azO7Ru6BifQZdB1Wpidls496wYA7K4FsnQrywCDzfH83EGB2fZ1Cre9yyF7nSOahyO2zy9nS/Wz/IWQ77LrOrn32BVG79ttzL/mfvbH3A4X+fXonysvrnJ7Lnq19uHuAWDeKkQOxdq7cWRb3uaPEfk6obB4ZHGF7yRiTJhILQ8FzQEHY7iC0Img16TQ2WZq7zNkXvoVLaCO2UYd220MZkK4HCMrlMp7n0Ww2cV0XSGtOsJ5eoxMc18NoW0NlMo+plGijbTNMx1J5p4WGuJ6D40qCIDUgbdiT+x+4n+XFJYKO9SbffepuLr9xlTOn7+Mb3/wGEgehDOgE3ylSLRTxpG26h+uTxFArDjAyOoQjDbPXL1PwSyjVJopDHM9DuI7NnnAl0pEEQZR6aiVSupTKNRzHZ3lpBRVbulLHcSgWilQqg2g8CqUSIyPD+J5Lp93i5s1r/NAPf5ydsRrJ+ZDFxUXipE0SNgnqm5QHq0xOjHH+9dfY2WkwODTOw299G0eOnOLJ938///W//w/GJw9w5u6YevMV5m/P89g7383o+BgXLl3kvR98C54skqTGo+u6CG1TxLNoMpBGjjNDMUEaN21Il5NPaQ8TKS0xjADc1EgWmLTRbxqRkhKdwBvnLhA3Qw7PHOXQsYMI4/LgfXdx6Z2P86ef+Z+0GjuEUYBf9glaG3zra1d573veS9jaYPb2AsIo0AkjgwMcOXaU8+deQ5ACTVIDm15D4SRJKJWKGCwRSBB0MIDnFSiVfDr1HVZWFlDK1uwJkabWyrSeyhiSJKJSHgHTIZGglCZJEhxHohKFkKKX7qcFQllbRUowiY1qCEAlSaoGZYrbBZMHplnb3AAF5VKlK7tKpQJbW1vEStNpd/BdF79Q6KZhRe12N2tGYqiUCiitSeI4/WlrROIkwnWtHtWpLhKOLfrPGjELkbPDjemyuZnU+dd74T2CkD7ypQx0CGOjH2nwICMRsjojreftzp09hOf7bm8aaCjHCkpprOcgZ7N3L9hD1DqHJ3o32E0q2OWp6ZrjaRFoFlrOzpc+t77Nym5rMMt9lVT20+R+M/17GNONsPQMnjzLQu8LA3vlffZBzk3ZjdDkH1Aq9WW6T5YbmT/fbm+bza3snUPmRplntAFsk6Hc33shUFonIkTXyMmUnyRHfUi3FGXP85ZSYoQ1trN9+72OojvB7eOwX8TackwDxEqjklSxONZ74Xs2XzRJPTPagBwc5W0f+gE8leDXhrkyO0+AS8HVODpkfXUBqWPiIMBxJY4R+H6BSrVGuVRFYyhXajQ2N7l9ew6/6FPyCizeXmRzbZP6VgOlQSuD6xSsR8HYJnBGWQ9WYiSe52DQaKXQWLYUW99icB3J8u3bHBifQgvD1tI6iTb88F/6NK5XxJEl3vmOd/P0159ifWOFoaEhRkcGuXbtCoODg9jcYBeDZGhkiFK5wtyNRd7xvg/x8tkX+NAnz3D65Em8ygAJDrG2Y8CVfPTj38/ss1+krjtIL0GKBJ3EhInBTXufRIFVop5bItaGOIgoFMu0my1WVlbBWAYTRzr4BRelY9u912hwoFoeQAgHxy+TaCxjmOvYvNVimTN338Pw4CDCKJSKaDZa7LQCxiamEJ6bNoU0mWei53JIBeJ+hmlvfZpUTGTGV87wy9N0ptNOODb9pFosUUDiaYNXKFCrVohDiec4OA42ZUrC+toqofFYWttmaXmNYrHEB9/3fk6dOMa5V17ALXoIJ03NFNYAQeUWB6JPHmSqPL8c+oy+3g3SF5UlU+C7HkbOEO0/T+pdMj3AsWcTu35mJ9yzn+g9v2yvfSIrb27bx7PRPUcGQvpl195a8L3G/fe8qs6Pd+897ieu8w6c/PX65l533DkA9z09d7uBxZ2en+lGGsA6p2T6d15n36FWftf1+oHQfnNCkEYb6fWFaDTrjA5VIZHcunKVsNNmfLjG5fMv89nf/hWk2qJSULTqdSuv8VFxRBRoytUCx44d47777uMP/uAPCIIAIQSeX0wBjcZ1bWp0ouNuXrj1BKf56TqhVK4RdCKktM2/kBJljE33ldbAVMrw9NPfIgwCWo0mrnR55eWzYFye+pMvY1yPaqlK0G5SLlcZHZni8oXLXH3jMt7gCEKUKJXKTEweBKO5dPE8jlugUhskMTbNcXR0giCM2KnvYFwIVUjRL6FjTRjEzBw6iPRctjc3CVohlaEhrl27geM4vH72NUrlKkZ4tFshX/7Sn7CwsIRWCa6reP75b+G4giBq4HiGRmOL//Ff/jPlWoWo3ebW7A2MEZSKVU6evIef/nv/iMHhCeqbTeaXNwjiFm9766O06gGf/6M/5vHHH+MHPvokb3/XY1TLRWKjUyBgu5z7uEhj5VyCAdemeGttU2YyMOo4opuhkOn+WCWQppsqpfF8G2GyhFwGR0Cz2WGgJmk3JWE7sL0phqp8avoHCdqK5779NL/zm79Ke3WZWq2KKxKCZoOF9gZRnPCFz/wWtYFBdBwRhREzBw5w+vRdVCoVfM/FHaixubaCV/CIE4VWCb5XYHR0lCRJaHeaaSpUmNppkARtwijE8R2iqGPXgGMjAuVCiYFajY2NDRuFE5rlpQVqg8MMDNSIIvvehWPBg+N4QNpEz+g05cnK3HK5bMluSiU817NRFqXSTuFw6fJFpCMYGBxkfHQizTAyTI6P8+ILL5AEAdL30YkiFhFxGKJ1YumUc7Jmc2MtjaZk8tLWXCRxCtgdCSkhj42e9Jmf2EBWlj6X2IhjYtLmy9oyaWU6tY9B1qDjhCxdWGSkT2mqZxZJSVL9bdetfBNy0W5vGmi4jr1xrZTN5zMpJ0EqKDM3pQWP1tI23fBdphhlNwUpr1xtPcT+iiJjRkqhR88AyZ1D7Dpf9pkdQ/q3sOi0ex2TGTYpn4LJC+08sNiNBPNbXjmyx4uYVyik188+71eDhnyh3x3fXQZgBD0PYN81e0qnd4jpou78uPL77Z0sez2UvaZvvR4Z3bGmLjohTUo9qvA8W/ikjRV2SlmmMcexhrAyxvZFwKRcEtarIlzXdt4UEBnD8bsf4W/8vWPMX7/M+Zee5+yLz2KooInxSrZYLIpiWmFIvbkDyaZd0M3rOLUKfsGzlHXYNJs4jsmYsyyNbAIipjZYYmhwkK3NbaJObGswIltGL1wv7Wmies9UaSYnJ5m7eZOgFRC0I6JE8yu/9F84fve9GO0wMTFJ2G5x9NARjp++i82tdaSUTE6OE0YVFpdu2rzLlRYIh0RLPv+Hf0Bt/Chf+9LnOHz4EIODVRIhCBINrsPly2/w6H2n+MRP/t/4wu/8EhtrN8BRuKkBpZR99kkU8/BbH2ZkbILl1XWuXrlKbWjA8tILW0QmAaMTYmXzNZMkwfN9HEeytbNDEmtO330/kzNHuXZ9lpnpccoDw7xy7jK/+su/xFve8X088o734lWGefnFV3nw0bdz9cI5Hnj4EbSyLCjSscLQhsEM0tlVUyV68+hOxb13MjwNKZObkUSJBRdJFCMRhEFIfWubKGozPliya1MbPM/j3Ouvc88jFc6cOc299z3I/O15igWPraDJ7OwVJJbf3HEEibBeWUfK1DjvUYtabJ1KJtNjdMpgx75gqgsi9jOS88dkHmrTv9d+Dpf8g/xzbHsPEXcQPvnx9Y9p7z7584quM0LkZTHkIgT73/vu52f2u/n97qnr/MmJ736f0R3n2Z2+y40iN6796+W6ACC3f9/noqepbPQr/bYv/W3vM9773Ht/91TMPjEgA0ls65IwhlajxZWLl7h67nW+/8mP8K0vfZkPvP99vPzs87zw9Jdxwja1kkPS3iHqBDiuzyc/+UNcvnKN5577Nu1Wm8uXL3P9+nUqlQr1egOlDDKtl4yiKC2gVlQrFcIwTIvAbb69V/ARrsR1JYWih2vcHrAW4PpO2sfJEAvNTnMHz/VsT5tIsbGxhUDyMz/3/+YP/udnuXnzKkHkEiQJgW4xc/I+fN9naWWRI8cP85M/+deYm7vFl77wBTLAtLqyDSKhXPFpNZtowPVcojimWK5w6tgpzr38KhiXJ5/8fhqtJl956incYoJShiSKCRoNStUqiVLEUUi70eD5ep3Dx44xd/0StYEqi4u38HwndY5oSpUq//gf/Rxnz77G1772NTbWtkg6Ce1tzfONV7n5j3+e//D//2+sbG4xPDbKU199loX53+fg1BS/9sv/havXZ/n1X/sVfvSvfhpMAYm2cj+te3Owzes8z6XgCYI4QWG92Q4Sv+Txykvneeihe22qTboGjTEUfRdlLLBwXZnWHag0qhWhYsXVq9d56stf4tTxE4yOjLKyuMjv/NZv8ewzTzMzPcn3veeduDrCKzhoHVgKVqmRrmR0aMiyNa6sgo5AwaGD04yODHP27FmOHz9GrVLi29/eIoptUz2hFb6A8YlRFhcXKRQKtFotenadlUdaRRitcVzb1wWtEa5LJwhI4phCoYDnO/h+DSEEnU6HRnMHbTSKGNWOKVUqGGNrOkqlgj2v0Wmnepsu6PseYRgCabG141AsFgmCAC00Y+OjNOpNrly9hNGWqOTy+fMgBMVKtfusdZLaEcJBK8ueZcG6jxTGsmQa+z0IyyolbEG/K1yEY+s64kh1ARfYtC9rc1vpoFTPSEtIrM1rctlFXW+32SvL7pAaJdOUsmzu6DcZ0XjT9Lb/+VxKRqtsAYwwOSNf2oeRNxosV7rophj0rij65KXo3WqX6znTqBa19ZCdgfR8mVVv+s7Tf2MpOEkjLVlUIeN8z2hsU9XRHVvX89odZk9lZJqyq/NE79isDj6L5PQ/VZOhjt4nu77vPbu0aUruhnppXb2b7XmI8xEKkU6m/PPVPUGem1T2nHZi7p0q+ynbfJ5t6tztRlZEN39TKzv5fN/tLoCssWD2CLS2xWkohZQuSaxBCmQa+UBBwQUiw9qtW/zh7/8e1y9dpOhKDkyOceTQAZqtBsPDQ1y7ehXXc1lfXUWriA9/5EOUCz7feOopypUC5194nnZrh7TVOUibzyiFoFgs0mpsUyq5ttgqScA4jI2NE4Yxm1sbJHEEKIQLridxvZRrPkmIA0USaaqVQQqFMq1WQKw1w6PjfOjJj/D5P/kT6vU6Qkr8QoFyucR22o0zTjoUSwJjrALWGjy/RLFQJYglUUsh3AoUBhidOc6RM/cyNjXDoUOHODg1wb/9Vz9PY+Ei6AaOo/CEwJFgVIxJqQ7DRFnPXcrz5KLwXQeSCM/z0Di2wVSikZ7HiZMnuHLpMkiYmjzIdr3B8Mg45UqF2dlZHrz/Xs6dO0eno6iNjuOVhihWRxiZmGHqyClur2wzduAIH/zox9HCtbz3CFQaaRHSKojUT5Gbt/uslzvOw2x/bZvzAa6UuNIwe+kyv/+rv8bjb30beD5LqysIEu45eZSvffGz+NEOy0uL/K+/8C+ZOXkvsZZcvXqNz//hH/KOtz1MxXN56s/+hEKpwoc/+UOcfvhRQuERGmtGCQ0ZI5AWojc8Q0pDnV8p+zkU7Ld5gN+3VnP759dr9jh2uzn24oQ/H9jI755hn55MzF8gL3i6aOpNnr+nJ7rS06Ssgn1AY+/wxR3lZf+Yu8em1xO5L/Pm+R0fj9jHQN9364GF3rjy48+iCmmMa/f9dP/tDXqvehT9+7BrLmTjyN1f/tzdx9AdoEgN/cSmyACq0+Yrf/g5vv57f4BWgp/9+Z/n9OmTPPO1L/Kb//0XGRmW1DfnEb7EcX1i7aSsgSEDQ2UefeQBvv61r+P6PsbA0aPHaDWarK2udaPXSZLgupIoCBgcHABBF3QYo/ALDnEQoWOQwkEbg0IhXYlSEaVyGSlcksTWSRkEvldicvwg12bn+Ys/9tcwTomR6QPMHDpMpVihsd1kfWWJP/7cZ7h9+TzEbZxaGb9QZGRwkNHhIW5cu4oKO3Q6W5QKDooYW5IhqQ4M8WOf/nEunr/Md55/kfpWm7//Mz9DuVrly1/5CufOn+WDH3wfkxOjXLt+hVu3bnH6zBk2Nja4NX+b93/ow8zP3+abX30K1xEoZQuLHdfD8QpE7QjPrVIsD9FstPjn/+bf8/Bb3oHjlYmMwBQKICV//3/5aTrNBlOT4yzP3WLp5k1c12VgZIif/tl/wAc++j4iZQiSGCVsA1ajoei6dNoR//U//xKf+OFPMjUzbYFd6uyNAsXv/B+/xV/+yz9KqeilpphGmQStDI5vqVJtpqgFpxLB8uIyT335KX7yJ34MV2q+/fRLXLx0npde/A43rl0mbNSJG9sIaagNVkjCyJJvqBitE1vPKQyuKxFG2U7xeNbQ1oYkjhHSUsUePHgAMCwvL9Jut2zzXgmJVimVq63L6JOd2pCEIdLz8TxJFIa96a81ru9TqVTQWhNGQar/JcIRNuVMSKIoIo5jqlULCGzKn10vGXDW2jZMzGSkTm0p13Vtg2RpC66FlriOj0DQbDQpeB4z0we49MYbNhrg2LWs0x4uQqa1i0mC47upLeTg+37XPtLGRj+sDWVTEGOlcRzXtp0Qbtf5ZeW4PbeEXtqU2Q0cdAqoekZjZt+JfcBHLyMmn04lCJe3+V7bmwYaP/afv0GpZEOR1UqVaqVKuVTG93081yXtAWIRFiZXO24LKU16873Ge3s9fqZrcPcAh8gABjbpwGRgIRW2d/RA5XLPsn3ynOYZ6MhAQ7fmIDMCIGWWsjRyIh/NMDnAIlJGLEQvEtWzDbpjMKkxnhsaGTLPCp6yfXuFXHfesgmRheh6YET0nT9LL8uOya5h/7YUpJm6v6PneB9l2od2RX9euuNAGKo0vCa6DAzWuFBgNK7j2ALxtHGTHa3N9Y2CkGe++U1aOzsQhsStNgPlMsODNQSWXvDAgSmqtUF83+fmzVlUEuM6gutXr7CwMIeOQo4cmeH4scO8dvYlWo06B2cOIITmpe+8QKfdRIUBJgwQInUHpYhMJsZGn4xGqwiExi95VKpFHAeiOCSOApJI40gPowQYieO4BFFIsVxCuA5xkjA8PIoyhkazgZSS02dOkSQBm5trbGwu43ppl/fEABJtHKT0CQMFsoiWRQ4dP8Mjb383M4eP8crZV9nZ2uTW7EU62wsI1cQhQeoEdEyP+liSGInCRSsBcYxbECTtFqVymYLv0wliRsYm8AoFFhYWGRsbZ2xsFK0N8/MLJImiWhvA9Ty2draplIo0m018r8Sjb30cLQpsbLdYW6+zs92hNH2Uf/C//XNkcQAlXRKd8iWl7956a0B1m+HceY73OS32EXiYLPKbFZ6CiRP0TiNNX3S4dv0qzeY2D993ml/+j/+GeGuRra1N/u4///8xdew0RnjsbG5z6cI5RqseF8++xKsvvUjUCfjgD36KM299B8avUB0dR2GZyDKZ1nN6pGPqFW3su2aye8oiGne8r++y5X0VXRu9e469Tp1eo9DdxcZ7RX7eaN/bgC5zRaRPvC+t87tvu+8pU945KfKmj933O70PvSwZ8Ljz8+37RtDrF/Rdrtl7nj0wsBsgyxz+7Kej3ec55KJ12d+yy8W7y2HUh6qy303fLfavi95m5W/W4EbjJAk784sMeB6X3rjEsWNHef6Zb/H0V/+U1dsXkWYHTJtytYQSkjCxTkPHAUcqUCFhotPJLHGwlOlaZ5Nb47g5MuSUmz+7v0LRIwwDPMclbid2LQhs3YYncRyJ1srKLQTKCLSRCFx8p4zrVzl5z8O87V3v4963vJ2RsQmuX5nl4uvn+cFP/ACbK7f5Wz/xl9FOzIOPPmwZkdbWCTsdGhsbfPD9T/DUU19AOopS2bPUn4BXqOA4Hu1WRHu7iZEu1dogru9SG6hx6NAMr7zyAgXfA53g+baxWycMiFRCdaBGHMd0Gk3r03LTRx4nqFjh+GV07GCUy8/83D/nHe95P6+evcTy2hZH7jrFVqfJ5tYGv/HL/41/8o9/lumpCV589tt89Ut/xo0rV3B9j/d97CN8/Ac/yezsTd7+rrczNjVDlKbPoBW/+zt/zOTUOI89/gh+qUycNpwrF112tiP+j9/4DZaWF/nJn/wJhAPFos/k5ASJ0SgNnueShIo4iok6HeIgZHl+iS98/k9o7uzwIz/0g4xNjPH5L/wR58+/ysbKEp2dbUwcEIVtXM9BpzVwUmC7TasEnRb6S2lwHA+tJeViFdfxqDfqKJ1waOYgy8tLltBF0DXAtdY4nsvk5DhbW1skSUKS9rnAWAO/WCwSJzG+79usiTRFSGtNEARUq1WQgjgKLduSyBngXbdtjxo2SSxtrUwjF5VKOW3saLMBsnTZJEmIk5hqrUa9XufQwSMYLdha32Zncytd15Ki7xN1grSgWnRTj5B23SbaplKHcYwlVLEjc7s9N6zzMM4AUJpuaIyN0mepXDKrAUzBg07irlM5kwU5yYDjOP1Rjtx6zeuBLnukSO1oAZ7nUSqVWLl0k++1venUqfvvvRcpnS5HtuM4aSW7phMEtrAmjml32oRhSCfoEAQdhLBsAcViEb9QoOSX8f0Cvu+niA3iBDwvBRMZukpfUF4daa0tFxs9X5UB0AaF5efP+41sw7/eC8giDUJgC9N0Bh6MzUnL8E0KHizSs2EtcvnAmYMpYyjAkBrNefWZviSssW3JjHqKqofIM4WTvmPTU5ImZ0TscY+Rw0yZIZMaGyIN5+T8X31GXRdYoC2bTrfY1PSfOLu6xLJV5E8g6BYxkd5v9y9t80QRvffQhW8GBA7oFJrpbCdbjWOwbA4nThzn2uUrvHLuHKODQzbdSsLU1BRj4+M45TL+0BAvvvgio2OjHDp4kHKpxOSxu+wCU0m3e6Y/cZh2s0HJ96lWSsjaAW7euMbBqUlGh4YwKOZv3+Tm7CzDgwPcvnadzta6bSSpbYGzjiWNndA+C2lAFMCxBZJGWn74WNtCwQMHpllaW6Rc8QjCHevtcLWlkb11FZ3YIkvQCONgEoPR4Pk+nlcEXDrtOsWiw5l77mFs4gArty7x2ovfYn15kerwIFFzCXQLV1qQoVVsu5eiCYIEgwfSZ3TqICNjk+gkYfb6JQZHBwnDCK9YQ7iCILQcVdMHjrK1uUZzu8HI6AgzUzOsr63R3NpEG4Nb8JmcmCKJl6iUB1hd3mC70aHRiSmUh3ng0cc4fv8j+F6BRAgLlGW6lDMvOGAcRUanx540xh7g369OKjfz7VpOZaaUlntW4FIaHiTqdAiDiFK1QqloBXUYxghsCFtIh0QpEqXRKqHkOVy78Drnv/M0B8bHuH19gxtvnGf0wGFOPfAWEruAyDppqFQ+2VxWO5DsVrJ6qV1u5b5llY07v8u+5m12qvxC3vVIMmVqwYQVcJmC7srTnHLpMd9lcjCnZvcM3fSEXfdv0XU2ZOfL32N3byHu/LnJ2FD2SfbJ3WzGQJh59HfzfQnoMuvktAF3eJpkstbccY9+4LNfdKF37f0pczNjei8DVD+wylh/en+n6yGz1fvGlOqFfc6TPRuR27d3UZuvbTIAIiCOYpZuLxJubPDFp5/mkx//BJVykYOHDvDYu95OY+Mga0uXuHXjIkHQ4tDRI6ysrae0mjatw/McZKKsrBaWRdAYS8U5PT3NO97+dj7z2c+SJLYGQ2lr0LiOA0YTJwkI66UWqddcA1rYhrEyB5WSOAHhMDE+ycjwOLdmFyAxuMZh9sosrUAzNj6FSTRJu8W//Ke/QNzaRCcxOIbZ69fAwN1n7uHDT36Yl55/nhvXr5BgkMLQbLWQngOOiyddPvoXfggSwR9+5jPUd+p0oiZEhkR18HxDGLZJQoPveSSRTfFBCnwhaNfrNnVVCBxp6+qMlEwfnmFqcoqbN+epb7VxnQpxYqnSr126xO3bywwMDvK1Z77F6PgI5XKBa9cvc/jQOCPjNSpVDwhBaF745pe5NXeN5uYOt65e5kM/8ANMHz7Ciy+9zte+9g2OHj/FQw/dR7lcJDGCRr3J+soqja0t1lfWOHXsCF//4h+ztvQBaoMDOKJmqWDTouckiQGoVjxuLS/x8nde5oVvP8vNy1c5euIov/lrv8rb3/E2Vpdv40pNsSCJRMLMkQMIrbg2e9X2cnBE2ig0o3C1jH9SWlYmrQxh2EF7ikLBo9OO2NhYB6HxiyVcz7HN9ByJ0oogDGm1mghh8DwXIeh+b+0enbY70CQqk1PWznN9SzlrcxEsaFZagTZIx+nKBYFNr8aYNLWMtNjZEIYhURSBsJkXeUkhpCAMAwqlAo1mnePHTlKpVImikCRKOHrkKFcuXaJUKiHSCCPG4Ps+1VqN1dVVEqVwHTc1fTN70yClRsURXsGnP+nYINL+NSodv+u6NpKRMnIJYd+DbaRpes6pnL2pU3arTJgI6NO9mRNdWM98n8yK4/hNp069aaAxNjyahnlkN3REahRIaQuMhNBURIGVpXmuXrlMFIa874n34nsejhDsNBoUR0uUC17aNEZhcIijiPpOkzCMCMOAKApRSdIFNKVSiVLZhkBd18VJWR+ySIMVwDLH95y9CJE+rNSbri2atMABMCLthN0LIGTFlgiBYy3sLi1YXucKSBkz7Hny+ib/MjK0KGQONJmekuh5unI5v4Y+Y1/kL5zb+ryb6XWtkZYz3PJFPblrZyfIwELecNlPC+dsxb79RX4Qon//LojbhaIEMg3P5Rni05SNlLN65vAMrudRKZUoF0skUQhGMzY1hTLKCg/Xwx8YRBTKaLeAUx5gsFSjVC6hEm27bQOTlVGSJEob+RhKY+t4Wy1ir8bQzF0MjwwyfOA4xaFpNldX8QbqFMuDHD08gyc0a2vLrK4soVTMmXtOUx2ocO78OQCOHz/G1tYWy0tLSAEqDGg06milSBJNFIfYDsaWuUrrgCgMSZRNLcj4qF3XZbA2wPDIBNdnb2G0YnJilErJJWpvs7W2wuLNWVxhqK/vYOI2DjHCJAiUZcVSMX7B59SpE1y9OsfhYyc5fuo+BobH2NraZGlxnihoc/zE3RSLZebnl9Owcolmc5sgihmqVOi0O7YLugHfdZGuZHB4mDiKmJiYIo7BK5ShETExOc6hY2coDoyTKEi0rb/psdNZwK4xtseEMCmhRG/O95MX5FP7+g3gviiB6XmktLHXFBK0dNCxg/A8iqUyQqVh70ThIPD8AtJ1LXiMYrY2Nrhy8TydtVvsbCzhi5jxiWGmp8apFH10EuEVy5asIF3WEpEF4cDY8LQUIi26pa8B3H4B4/2M3Dt70kXf/fc9g/SzJJWV1lliLIgXvf/znqm+SLIAkZdV7E+skb2Ebj1KDgzmIcf3usf8ftnb3XvfJsNLmf8hJz92D0nsObR3jjvXk3w3UHen8UKfr6Y7tj2n6evgfYdx7nvJflKA7PxdsNg9oJ9MgO472f8+tLE8+lpZ4hPHcSkWi1y4PsurZ1+lIAUPPPQArU6TdqfF0vISzY1N4k6AcSStVhOMwrU1qCCc1BkkLEWmMWnKq6Xv7HQ6NFutvjln01NIZb+wVN6OQxwnOFiCDWUXlu3Fka4lx3Hx/SJRqOi0O2yzjVaa6elJFm4vUK6NcvG1V+2TSzREMQXf5dqNa3zsEx9jp73N5vYmjXqLTifg7Kuvsrq+xvziPMIVSNex8ldaZ4tGMjA0wmsvv4pbKiAapOyQmiQJSZKIAwemWFlcAGP7Z5jUBrANzDU6SXC9AgaJUor7HnmAiakp1tfWCcKo+04830NKQbvV4Pq1ixgRc+PiOe7/1A/z0H1nOH/2JaRpsbm+zM7OCkIHFAoe9z94hlfPv8FwZYhrFy9y6tQpgnbI5z/3OS5fusL3f//HGBoYQCVw4Y3z7GzvkIQRNy5f4bUXX2D60BRCx3zjqa9w+p67ufvee61s9OzsS5IET/oIHMZHh7jvnpMUgSOTkywtzbO8usA3vvolthubDA5W8KUh7DRoNnxcKTg4M83i8hIa25w3S8uRUqKVbZGrtcbzCylrk04dNhCEbduZ3BEpY1SWxgPGKMs0ZUzasdpKEMdxuvOsWJR4nkccq67N5UiJ47mEUWhrI9KUIm1sVFanIDiL+lp7VuJ4VpYmacPbKIos5azApslawdQtiFZKgYa2alngkGiK5RKDk4OEUUSxVEI6DkmYGeeCKErodAJmZg4SK0VtYIAwClnf2OiCKmGgUqkQxhFCOriOBe5g10rWRXVgoEaz2bSyQHTjFyRpI2XHLdBNM8qcIGKXfsrZiCZjtiKtvc1FXrNsHp1Lofpe25sGGnEYpuEeeha3yCaD5S31XIFT9tFxh/WlecJ2m9W5GxQ9l069QSuMmHhsiErJI9YmDckCwhAlCUEUEkchYRgQx7HlIXYl0nVwlY+XNvkzWqO0QRlFHEUEYYhK4nTh24fiOraIp1As4Hqe7fqc1gEIch2xs/BFpjRFT/XaQnRB1u43lfN0f6QGvSALp/ejwSy+0Vts9m9rb/e5rez1cyDGZMizt8OuNyL2+S27j95mC7czf9deCsTemHuf5RFu9/zdnI/0R1f395RgP4ixBqDTBybsOXU6ybPF0IVm6TqQnoPruxw8dpjDR46A1tS3twk6bSqVsmWf8H0QHlOHDhMGIZEB7djpHGroBBGhdtJQqkDHEXEU4jiS4cnDzMSwvbnBRjPCKSlKg+McOiHZbsSURmc4MDHO29/yCCXf4ebsFd44/xrrS/NUSsOMjI4xfaBOFMdMHTxKaWCESEvazTqlWo2V1UWkaznYlY4xwjJv+Z6PKwHPSwGetlSEjsB1ZFcIhmFAseRRKDpsrC0ShSHtdhOpmnhFn3qzju873TQ0gcD1PAqFEmEUUR2o4Xoe5UoFhKHV3KHZ2EIKg5FQKJQ4c+Y+lPHphLYgPohCSpUSxWqJVr3BztoOxWIRx3XwfNcWiG9uMjA0QnVghCRRuH6R4bFJasNjLG3UqYwfhKxTaDpPZGafm1SVZ3OqO//zBpMg82j3rYUMoucNzmzXVOZnKVoJYFwX1zgUy2VEbPNxk0ThS+vRcqTAcyStOGRna52djTVk2ECYiObOOrUjg0wdmMBzLcf6gRNnkH7JzlZtvRJCSgwao0yPX17mQAH997F72/2x2PWhyf27Z2+Tc2KodA6l978biGSOBpEbTA/k987TfSd3wBnk1nmXYCJ/n10PjOnun73jPtaw7AKZ4trVbrWLgVKQ0Gfc77Km9zzDPtmWvou0yVjvvr7rk+0/V1f+9er5smP2K87ul6f9OiDvUOqdk77vumMxmdOl34ElyJ79/kQD+wGaDAw63eiixCsU2G7UqQ0P8c1vfYOdxhblWpGl+dvcunmTgYJmdGKala016vVGGn1Ko/xAEseWKQrL3GeNPbsmkjjmypUrvXRZabWo0gqt4i7jotFYI1+bXoRPpLWfBkDiuB6eWyAKO7bpn7Ie3ImpSaRXY3Cgws3Xr7K+ukbUblP2C7zl8ccYHh3kyIlj3Lp1k+GRMba269y6eZMvfOGLeI4hSVqpMWsQro8ydl1HScL5189x9uxZMAkIYxsGCpvuI4TNzpCO7RZt11vaDd1zqFbK7GxuorWPX/QIY0XRKxN1YuZu3Ka5uYN0ChgCFuZvo5IAvwBbGwu8sjFPFLWpr8xRFDE3lub51tpNwqBJfWsdKWOkiKlVi8xMjEIs2Fxd4uVnn2Vo7Dr1jTXe9563c/89p3CA7zz3PBcvXWJ8dIxqqcil119hc/k2N29coDpQ45UXnmN6coLmzg5zN25w+u7TBIlGJ5p20sGtlCkVi4yPjpIcjagUfK5dOYeKWywuLNNq1XGYpOi7eJ7D9vYGxhiOnziGWDU4Tgq+Epum5ApbC6GUQQhLLS+wje4wIiVbsYQCSRJZ6nWV2VQp3XFXxvTSQU3anC7rb9El6TA2OmbSZpBKZ030UhY20UuTskDY9vrSKqU0T9eP0rZYW6dgyfPcLlDJr0spJXEUgwvLK8tgBMU0MrO4uoqbFpRLx0mfiyYOI2KtGZ+cZnJkmE6rhTEwNDTMwOAgriMI2y0cB9qbYXr7diGn/iQsBbNN21ZKI6RJCXukfTYZGCaVw92Umb3MpJlt2ufQEoLdDi5Ev0x/M9ubBho7Wxs4juXk9wo+fqGA6/uWdlNrhNGWQtUYpI4oOppOp87//kv/gYKA5vo6Dz32Du65+wxmfBSNxHEl2gG/UmCyNoGKtU3/0KYXPel2brXNf1zHsmgE7QgVxzTqO6xvbtJoNIiiyKLlNHesUikzODxErVbDcVwqlaLl9laWmzhJLNOOFpoksTUFnuviuLbDps51xsyM7cxfZSe07Hpf7QTWNoxFr4G2NYR6qUmZju2GrjQgrLEoyCyzNNKSR5FZrUVXmfQMr74UpmwupYrPpPR0+XFkkyajvMvncGfsJxZI5OINfUBr7zTLIiHdephU2er8dBb2CWTNz1xBGiK0jFTGShAQkjABzxEkwiL34kANt+TjCMPY4DhGCDQFNnYaCMejXKlSKpcRQhBHMds7OxQKRTppk50g6BBHETPT0zz86GOcOHmKK5cvUd/eZGlti4FahfLgKAeOn0aUBrjrrtMcuvd+dNyhMDyJKA7y/De/yrnzVxBXrnLffWdoNBtsbjUoVWtMHjzCrdkrzMxMsrSyiJMW2mfJIQKD1gnNep2CW8HBsak7aFxpCyBX15ZYWl7DLfhUB0qsrs6jYoWKYqukRULYbuHiII0kjBJcRyI9l2KpxMTkKLOz1zh/4QK4Ba7PXuHS1ctkbBqomOnpaS5eusD73v8hFA6vnH2VhcXblMqS4cEh1hcXLc+6FARxjIkNpmPYbrTwXJe1jU0ee/t7OXfuMn51jEI7JF5aoRUJPvm2x3H9QleEdQ080WsMlIVguxOoC4xTL3lfnlD6ed/P3uzT6ZpwXCc1ggxhovA8hySOcD2XUqGKq0LCoMNA1UmbJimESYiDNjpsMzFUZaM1hyMiKsUySdxhe3OV0PFpUqQ6MU1tuJAWunbbItlROQKF5fx3pNNb49x5664ek5Ml+bXWd/+GrCd59/6zqKsx3SZQTko5mEcKtjYG9nax7nnBe/qkFwHYzwGRXX93BGM/ZZWdL7tBsc/33b/6rtGLRPRkVDrWfRwkQLcP0u4tewcp2dme4/arocmPdLfRnnfA5FNd97+v3vPtRWT66/D6QVQaac8BP6tn8iyF2LVisve3/zjzn0mwjETp+jcGwiBmp9Vi6tBBhgcqvPCs5ur1Kxw8PENpcICpEye599QRSFp86Y8/Y3V82MEIbRmWVGxFtOvi+z5BJ+p6mSuVCqNjY3Q6ndSA8wGI46j7fMIwxhEQk+Bim/s5wuk2jVORAs+x3Y5xaDXaxFHC1MQMU9OH2Fx9GYXix//qX+Gpr34Vkg4mqmNUSKPV5Btf/zNO3n2KLz/1ZW7euM273vNeCoUyBb+E7/vEwQ6ua2WxUgqhHbSxCi9ot3n+2aeZmZpm7tYNQGGSiNrgALWhIRr1Bjs72/iOCyL15krbT6FULTE2MUGj08IoQW1wmCDZ4oUXX7HzQClKOASxpljx+MKffI577j1NHG0jTZPmzhZu0efPPvvbjI5N4Psey4vztIMGUhq8godJAr78R5/jHe/5Pl749gtEWrK2tMz0wcO8+0Mf4od/5IfwRIxrXH7zV/4rE+OTPPQDH6PgOcxdv8Spk8e4er1Oc3sN3y9RLfgszd3m/PlzPPrI3SRNwWajyfLSKveeOcHq4hrPfOPbvPzC89SKLgsLN2jUV5mZmSAJ6zS3N6BWZXh0mHpjh7DTYXllCYy2qVsqIYotQYyKbeRAJQrPL6SgMbbMTo5ro9HKFhonaePcjFpWCJGm2WfRDgsQbIdr62jJaiqSJOkSjegUmNpGjF5XxmURDMdxetEMYzCJBSaJiYkibTvYK2W7gUvbY6VYLHZrRLS2wEhKm/7nOhZMmdSYD4MON2/dtFGPBJIoZmpqGoBWs0WnHeD6Hlvb2wyPjPLGuQsoDEePH+fgoYP4vsvGyjLLK0skSWbs2x5Xvu8jpLQsWELTbLao1WoEYdsW16dyoFobotVq9oOFLt4Qe2TInXr3dI/fXQD2Jrc3DTQWb8xy7sJ5XM/l5KlTnDx1F6NjIxbZO4IwbFN0PVQU0theZXNlnrBR58j0GLdnrzE6XOMHf+BJjh2awrgWKSJBYUiQOEIiHEmsFE6KMrVRJEZb7mBlu5EqbXm3y+USkhIDA1UOHjzUzQfXaU6dkGlRWSrw41iRJIZO0KbT6Vj6y3qd1dVV6vUdlFIUiwWq1RoDAwPUalUGBgYZGBiwLzUzMDJlgwEUaeaVzb0zlkHAcRybD6vSEFdqpFv6uPQtO7aIztr4snvurKujMQaZNogxOWTSs89Mt25Ek+UY5jyC9JWVdKl3M6AEpIad6B6b5URnUZqeqdNDvyYzBrpK0X66t+A1P1FN9l/X+DTYULOT5y9ON4nBc0HFFmwYZfB8j0LRt2cQllOaBI4eOYLnYL0WsUZFMZ1Gne3VVTZ3tmh3Ohw5dpyjx44wNDRox6sN1eFRTpy+m4LvkkShBYeOQ3F4gurYIuMTk8jKAK+9eBlUxHYoSErDvP+Hn+ALv/MbPPftF9EknDhzmnBphXa7TrVS4sKF81agKjCJ6jKaqCQhNjEYBy0iPM/Nwk3WYxdpbGMrjVaC+vYacRBQ8ArWIx8FGB1RrlYwCpI4QqsIJVyGRsYZHxvntddeY2x8iPWNLVzPRcUhUtgwszSKYtmnubOFVgk3rl/hxq15NteXUUlEYydkc72NYzSuX6ZWq2GMpBN2CMIAk3oY/WKBC1dvovwqhaEJDp+6j7e8/b2MTx8m1JLYCFQarTEGTKo8MCatH5LZBO63/OjNe5Obz11rvDure5srLdd7nCQ2ouG6uL6HawyNrW08NH6xSLC1jQraiIESpYKLJyBpNym5UETx3Fe+wMioR5J0WF9p8uOf/CSvXbuB2wp48i/+FUrDw0RGY4zEcUCZtE4DGx0xxoId2/iKXfdFn4DP1t3+d9T7rI+YQqfrx6R0gmnk1qSKLquX6x4vbX2UTgt0XSdLp8yWYm6xmd412Tv0fba9ln2+VsHkd+v3MdCHOnJOm+6uXbDTdbql393BmN5ldO+3iYx4IHcmw+77TL8Tu4/tv8v8tXvRGt39XuxyzuTT1PLf2d93AZl0/24dX98Y9s6XvWPtSf9uaoMBYyxRQhxbx1WpVODw0SOcOnqYW5cvUykVCZrbHDt+GNeBrc0VHrznLv7TL/5riBKCtKt0Fm52hLRGYcqYY3PZJZVKBc/zuD03R5BmP7hOgTAKAMnQ0CC+57I4P49C43s+GNPtBYBOPdBSW2DiuAg0JkoAh7m5eW7PLUKsuXbtKv/ll/4Tc3PzPHjvaYZrJebn52m12yhhHRALS8tUh4eYm79NrVylXC4yNTVGpyXY2JgniVppbygHIbxUzCQMDY4xMlRhfk4jsDbKffffz6EjR/nsZz4HRtLphDxw/z1cvXqZKE6Q0qHVarFz5TLloRFUoHBdD8fzKXo+EvAdl1Mn7+KFl17hrW95C88+9zy/8L/9LMIodBTguZqJ8RGOHznG8SOn+Z+//3sYD4oFH60TfFcyNTlJJwx55hvfhERQGRzl2KkznDx9hiho87f+xt/k45/8BB//gY/h6ZjNxdvMX7/E0SMHufvUEc699jIPPPwAL33nJeqbW/zeb/w6Q+PTPPiWR3ABX8BrL7/K3K3bTI0Osby4wPLibdaWbvPS1TcQSZvT959ka3MNFXdQMQRB03Z6F+AKwebmBghDxSvhl4rQMTQbTUihtOvZVNZSwUUITRwrwM7RzEh3HNlX4JzNb2v4dyl8uvpCpF59z/N6n5NGIEqlLilNnKZBdffTxtY4pLTnxWKx60RIVEIcxxhjKBaL3fnebre70TobgbPUyEEQ4LoecRSlOi5dLykL28joMGtrG1QqZY4fP0EURczPL1Asljhz5gxf+MIXwPcoFzzmF+aZX5i3pAMqYWhoCIGL5xaJooSDM0c4ffo01YEaV65c4Y03znPy9EkmJyc4f/4c6+trxHGEIyXHjh7iwhsXrKORzEmVPr8c0Nhb+9WfwZOlPzs5GQ37EY3sv71p1qnB+/8CjfoO5YEBHn7rWxCu5NyFC0xMTvL/+Rf/nF/+7/+VE0eO8vKLL3Dj2lWGaxVOHjvCl7/wpxRdQa1Uxi2U+emf+Sccv+9B2gYSx6VjwHELxAkUHeuZRJu0qzEkAkxasCiMQGqspjciLbLuKYms+2naAak7dqUygZgiXW2VsEzzOjI/peNkhn+KBRzLgtRuxzQaDVqtFs1Gg/pOnUajQRAESGmFbKVaZWB4iNpglXKlQrlYhtSblHkas7xARwgU9j7686d7ako6otu7IltsmYusFzZMgUYaGpPd0KGwghtDN5k8RwecB0yZNyrbTPf/3rToFTbmEXAGi3dNlK4BuSt6ou05DbaXQmb5SAPS9pLOgSi7vytt7b/WJu3HYaMhKvUSFjG0G22idpvtjQ1u37zBlcuX8V2XgdogkVG854nvY2RswqZaOdIW9or+gtA4VtTrdXa2tyn4PkcOHGBzfZWVpWXKxTKttu0g7WBIwjaP3H83n/393+Q7f/ZHhK1tXFdRLEgKnmBrays1BmFkfJzJ6XFAsVPfptVqEbRCTGILqYoliXATjIjQJrLeQlGk15PGFuq70sFzJY5rayDCWBMbk3JtS6RwASel4rWCsTYwTLFQst1/g4Cg0yJOOmitKVcGaLRChHDxCgVc1wGToFVE0OxgtMDzCkSJ9ctKz8MtlIhNkalDx3n08ffw8NveRXV4EuFXMG4JJR3b004L++qlfdfaWFpAIG1EZBtpSCPs+ujOkXzn7d6kMtm8tzM8P9EQacGcEQLtyLSTLJAYFuZuUyv4zIwOs3F7ln/1//oHTE+UiOOQx594kiiBhfkFFm9eZ2flFkPDHttrC9YAdoocf+Ax3v7Bj/PgO76PQBTsPSbplaXMMchpjFZdZWf6B9y/LnYBjX4Pd/qdyeJ7uTWY1YiljH3oXh1LXtDrdP8sjVPrPJNRV7/0nl/OM58ZzN/NQ571kbnTfnc6bu/n/fd8p2P2jzrsUozC7Nk3v3+fAt1HXHWvBRYH3XHMovcesqgLd5q39np7oyI9NHYn9Zy/D+ns8jjuM4fy5979SHtYNYuz2/9NYnA1lAWs3rrJ0twtyuUCjfomF86/yurKPK899w0GB3zqi7eZPjRNJ2jTaNZxC043GgDgOB5JHKd8A1aHeb6NZCRJYtOXCwWiMCRotyH1ItdqNVQc0262UXHM4cOHGZ8c58KlNwjCwAIb4eFJDxXGuI5HoVQmVpqBkVHqjdDWhAUxp0+dRroOi0uLvOsDT3Dq9F384r/+V3zq03+V7/u+9yIxvPidZ/nylz9PwddcuXiWSqVoe37IEsZIm4otlfVQG4WKNUJ6GKVBOExMzfDQQw+zsrTMay88i+u7JMpS40rHgZRmdmR0jPvPPECj3qRYrTAwOMji/ALnzr7O4OAgH/nYxzl64ji/+K//NZ2wjeMY6wQq+hw/cYJz5y5w7OgpllfWiVPyGyEMaJvCdXjmMCNjkxSqQ0xOToN0mV9c4vyFc2idcO9999Bptbk5e4NyscToyCgGw825WWYOz7C+ssz73/9BvvynX2J7a4d3PPEBfvQnfpIHHnmUWGv+v//iX1CtVnn6G19ne20Fwg5SRRQHyngyod3ZIQ5aVMoVhJBESUKkYxzXxcRJOm/BL3pIx9bjREGIayz1K9KmHo0MD5HEIY1GHbC9O4QQRJElECgUCqmzRHULyI2xkb/M6LfzL03bE6KbJpodlzFTqbQY2klTpJw0ryv7XaX7xXGMlNKmW6eOm6yGI1FxV9ZKKdNaIkmSJN1xW8r41M7JnGbGUg/7rovnFmhsblKuDWAMBO02AyOjVKtVlpaWuO/e+wmjkNXVNeIoplwuE3cC1tc37XqIEw4dP0m5OkB9Z4flxQUK1Qpnzpxi9sZVGjvbGJPgeq4tDEehkrSVQOrgzp6bIV1iu5x9WQR2P3lqn5dI7aeeLOwsbt5BmuWOf7NA494P/VVu3rhJ0Ghw9wMPcPjESRA2bePjn/wY/+gf/kNqtQprCwuoOEKoBCeJOHXfPfz1n/irPPPtp/nil57i2JkH+egP/gj3P/Y4jSjGFEvExkHiIhUIrbtmZ6ITjGc7Jxqj8aRL0g7RcWLDXn7BFh1hC8PROnW82IeijCbLYQPSxm0ChOzWaHi+9ZhnlqfJog4IXNdBStuALntKMhWmmefemBTlOaKnqCQpQAnZ3NxkdX2Nxk6DMAxtrwYEpXKJoYFBRkZGGBoasvnwMqtasAV2vQZgovu5TgdqUpdV1nG1F83pjTMN7KVTIuMf7gca2WTJ/UG2V3a2jKItG4kgzYk32WhyEMZgeaB30wKbNNdPZMwvCqEtfXDvrOSeM+niACdlMFIIFIaO0viuxE0MjY0N/uA3fp2lhQWGRkYIO20cKWkHIU9+5CNMHTrM2OQUhXIFhVW5ju+gknSoju12blIEqqIEB9vAyCiN0XDt2ixaKe655ww6imjXNxkqCf7jv/gFblx4mbi1iTAh0lj2jkQrfu7n/xmvnD3Ly6+8xOrKCkollMol3v72d3Lu7AV26hskSRNtAqSjcF2QjiSOLXWdTkO2SmW5zsJ6KRwH6fpoQKkkvQcP3y9TKBTRcWTT7rQhiVPPt1IkKsGzoR8MLkZKpFvoYsWBgSqnT97Fh598Eil8KpVhnnn+Jc5fusrK+haRcfjg9/8Q737fR4iUQAkP3CJ4RYzrY4REmRQjiVQ5ip7gAkgSy86llOquUbKCP5E3IHPzUnR9LN05ks1Pgc25FVLapoPKUisXXMFrZ19joFzm5Mw0y9cu8x//9S9wcKKIIw2r6y3uu/8RqqUyK4tz7Gwus3D7IuWiRMUJjl/hE5/+axy77600lMuhu+4nUA6+Z59XYtLoZGpoWq+a0x3VvmGBPwfQADsfVa4TOICTT6HqHiJSJZxRcGUgQ3fZqPKc5zbtoDfE7DPZ8zXs2Xrj1N0Lfzeg8b1AyJ2Axu7j+mpHdu333YDG3pSArLCR3HPbb2Ds/+6ya6bH96IMvev37/s9QNR3ARqQyVu6YPZOQCP/ce8d5a9nf0phe+UgQEqHdivk21/7BjXP5Q9//VcYLPk8eP8ZjIo4e/ZlDBF/86f+GoMlwf/83d9i9vo1trc2SFSI9Kwutk3GLDWmLeZ1cB0Px3FoNBoUCoW094A1bo4cOcLAwCDnz1+gVqtQr9cxcYLnF1FRhBAWWMVhgBWGEiEK/MOf+Ud8+5tP89y3n0ElCcJxGJgYZ2dti49+8od57ewF7r33flzf543LF3nv+97DH33+c2xvrCGjGLdYBKNRUQcdt3BkxENvf4QoaDN7fZZOM8GRlpwmTAKQBk/YFEitBErB4OAIk1MzVCo1bt++xcbaCibp4KQV8gZh06+0xClUMM0mplhEmKRLX4oWKA1OsYgQhvvvuZvrVy4SdBq4rn2XyoA2DnFgbZLSyBheqUy1VqVaKTF79RrHDh5h9sYtTKz563/n7yL9Ai++9CKzs9cwKqDTbhHtbFuAZGB4bIzR6WlwYfbGNWYOzDA9NUNjZ4f5m3MoI3jPBz7Iv/3Ff0eC5lM/8hPMnj+HU/R457se5/DMJHM3rvLVP/siBV9y5sxdrKwu0WrbzBClFDJlgcLYJryWNEnZrBVjeyiRpM5hx0F6DkW/QBInxHGIlKJLaJGlv9tIQoFypYwxhiAIukAD6Mo213WJIht50MYQxxHSkX01G67rUigU0ma96TrRttA7iqK9skj0p2dZoo2e915rjeu4aV2EBdyua6MaXeePEAhH4nk+cZyg4wTfL3LixAkqlRrLS8vM3ZqjWCrTbDb50Ic+xCuvvEKj0QAsSY+KFTpWvOe930c7iNja3OHjH/8kExNTbG/vcOXqVb7+ja8Shi2arQauC0KalGVKIx2R2g+A0n2O6T8P0MjXs2TBmrxs/r8UaBQO3Y/0fYqFEjMHDzJ9YAYhHS5evAjY5mcz09NcOH+Ora1NhgZqHDk4A9Jw++ZNTp06xevnLxAHhnd/4MN86Ad/mAMnT9EBwkQgpYenJUtz82yub9BptzAOvOWdjyMdSRCG3Lg6y/lXzjIzNc273v0u/EqRMKWJQ9pinlSyAjY1x2jZVa7pHOpGNaSAKEnSlvM9c4au0M4/7B79bWZdZ69ImJ5ygHzhjI2IhEmcekZSRWCsUem59n/buIZ04seEUUi73SJUMXEUp7a7XaSu5+J5Pq7vU3BtuM/301Bg96qAhsTYxDEbIusBjd1b33G7lX0vxtIFPPZsNuyw7/QRogt0sj4oWfV4fm+ZGlUiNUgz/6AytkmTIM1S1th3LOzDToxVwlJphEpo1XdoNRqoOKFULFAslFDGWNYhr4BbcFFCkGgQaYaJUgrXsUpCadDGpoM5gFAGRxqU1gidCkEhKHoOze0t5q5e4tLrL/Das9+gvjSHCRtIHYGOkFIQdTpMHTlKuxOQaIiCDkW/wNHTdzM8MsRL33kBlQTE4Q5CKqRUCGEbYUpja4OEtPSPqdPeehM8N30TmVUYp+l6Lq5XsgoviTEqoeAK4iRBkHpelKWVRUKs4OiJE6ytbxAnCcVSiVKxiCMcpPDwCxVqQ1Mszq/SUS4Dk4c4eOQkR+66l5GJA4yOTzIwNIzCsTU40oU09dFICFJqa9sA0eauuq6L43hIV+J6nl003QWUluYIgTI9b72dSr2FZnZHNMgMX8uz7zqgQo0rBBcuXqBc9CkKxTf/5LPMX32dqh9wYGqcJHLQCsurX99ka2OFdnONoi+oFko0A8WZR9/Jgbvux62NMjJzjFJ5GN8vMje/yN333U9tcDBNaUznU2LQgr5Gft31lAMP+RXXNV6zT03P625Ej542U2bSyO4+WfM1N+WM1+RlUAo0sNFUo3RXhthu7aKnUEgjIDnw0V8f0TOcu81T6ZcVXbu7+zpzwrHvvnvv+8+z9ZeYZHI6/5D3+V7k9+o/xorp3n46u4Huje26vuidr/tvN1Ky3/X37+2R35zuhcyuB5g9+9zyyH/ftzZIe8iktYTd9GFDHCvCICZRCTq2rHcIrEzD0Nza4ld/6d+z/vpLyKRNoeDgOKB1jPQFnpMg4w7tsEMURDYFz5f4vkucWGOwVh1ke3OTqQPTJImi0+mkAMOyTyWJlWnFYiHtrqxpNVu4XlpTlTLzGWXXckYLrIxmbGqaZiPg2JHj6DBmbXWNze0tRiZH+W+/+iv82Kd/HFd6BNst3vGeJ3jvBz6AdAT//t/+G5qdFkbFDNYqSGyadhgGIDQnTh/l+o1Ltk4kipDaEtkYbTBCkegE38mYhARaC6TwqFQHGJuYpNGss7Y8n9Z5WNvD4DI2cZAPPvkxnvi+D/B3fvqnCdpNUC28gosrpUURjiR2XcYnx9leWcGVtlYkSWISbUB6uG6JsBmBV+HT/4+/yb0PPUoURVw49xrf+NJTPHLPfbz1be/gW88/zyc+9SnW1teYn7vFXSeP8s9+7h+jW9vge4yMDnP06DE0AiXg7vvu4dixY/yHf/eLmDDE8337/OOEAwcP8pc+/WO4hRL/7Zf/O1sb66gkYHy0xtjIACaOuPTGBSZGR4iiEDyBliBcxzoBjSYOQ5IwIjIKHBfpOtYGiGPiIMBL69cKRVu7oQ3dAmvXcUmSOG174GGw+lnFMUpZAJJFE7vN89IoBal9YzNHrK72fEv+k/mmshoKSxZkG0eibbaAkzbGs2nk1mmbqASlEkuBnkYsbJRE47kecRKnabJ2HUohqFarBJ0Q13O61xVZrwxtIy9RlKBMuhaNSAu1bXaDbUaYEMURAiunS8UyM1OHAAe/WOHGjVs8+MBDgGRjc8MySS7cxi24aJNgSHCcLCNbo3Wv63g3Gg7d1LI86TnsqtXNycwMZNgPeqlrVgYJgqWt7yrr4M9Ro2HQREGbgVqF1eUFUDGHjx+n4Dncvr2ALySPP/oIVy+cR3c6mGIR13WoVEos+S5Xrlyk09phaGiCdmubm1ffoFgtMjg5TRwr5udnmb92k1vXZ6lvb4GAkfFRHnvsAYJ2xM3Zm3z9qa/R3mnSXF/Dl/D+j3yAODbERlmBkXnuTJraYCxl2tzcHO1Wi7vuuotKpWqNNiFs7wLHSan1+g3hrjJJO/6qdKLLXZ6k7s5p1EVAl/KM9PeiX+gaD2nAwxpouTxlIcBxXQpC2iLWUoEoDft1X7QUCJFStrkSo0W3l0kcxxakhCFBENBqNKk3Gyht89Sr1QrVapVKpUyhWMJ1HDu90qY05IyezAAxZCAqT0Oaph112YF2ARPTKwUW+QeaPqjss/R2rOLMvs5kg4Xa1oGXGWo5o9QRWJRiABwqQ4NUBmq2GZVIQ6iObSKJlCQijcCkHTm7Bpk0oFO2IE3atMvYDtZgqeRQ+L5DFATcXlzm9o3rzF29xNbyPO2dLVQSWxYj18MRLu12E6RgdXUVv1Th2IlTlMsVhHQYGhmlUi1x/K4TXLl0DuE4qXfQQiqbBWgb8WgsSHCkZemyBAl052C3CVZqdMYqwpi0MR6COEpsqoswIBykECQqsUDC91hbXiWIEoTnESUQNgMwDknYQsoO7lrEo+/4Pk7d/1aGJw7jFqu4pSqOX8RxPbabHeqNJq1OQJwkJCqxXPupMVssFimXy5SKJYRwQRkklo1EaI0RKQGAwHZpFTKdEykjXJ8R3jPCdHdOZak/vcUodcqCBxycOUCnVWdraQ4pDJ5re4wUiwVwXW5ev0l9ewspNRLL3V/wiqi0t8atG9dpRIaDJ+/hyLG7eP21V3jw/od4/YXnKEjDqTOnKZaKbGxtMTe/wIMPvRXXdUlkOtfoCfZeY9bUo0Q+hiey9glkRqcNuWcOkawLbo7+NJ2n2bJw0qhFlHqGs2eSpVKlEgyts2iG7A2KVGwa1f3sTulTWQ1BD0PkGZP6j+na7t0IQP9m7nCdvdftAY0shdPkrPAe21921v5j7SPNzSSRG5ToFWynA9o7SrHrfH3nztV8YN/IbiUMqQztexeZjDX950v36EY0sq/zzzAHMsCmnGSR9SzDVndT6/J9DFJ+v1RPDQ5U+aFPfILyB9/FH/3+b7Jw6zpxJ0C6hlq5BsLgeA4mSL2j0qb8Zl46nRpIBoHrehgkiemgI0X1/2Ttv6Msy67zTvB3znXPhc+INJHeV2b5QhmgUEAZeAIEjdQaGYgixZFv9UgatTSSerWkXt1kD0daMj0taSSRQyNSJAQaOAIECgWU91mZWel9ZHgf8dx155z545x734usKhCapYdVyMxn7rvvmn32t/e3v68+QLOdooXP8ePHObD/ADO3pzl37hwyqDI6to09e/Zw6o030Tp32zZ4wiA9QTeNaW5u8tM//X/hB889T3NtkzzNrDOylHz7D7/Jnj27uHH5KtqTnHv3beK4ybbJnUjPMDYyQHNjjbTb4uDB/axvbNBubyA8w/TUFEknxo98oPBTsEwHIQyBFORZ5kzfFOBjjCJJuzQ312i2m/ihj9aJnR01Hn5QJarWaHcTzp+/yK49+5BoVpenSeMmKksxRrlOXkan0yKsBAidY5QE4yOEQWlJtTbAof27CBsjLC2vMj0zR64UFy9fw48qnD57juX1NgdPnmRqZoaLFy9w+fw5rp5/ly/85E9z/sxbBIHH3r17uDV1i04cM75jO9porly9whe+8AVqQcAbb7zG7Zs3SFXMyvI8X/uDr3Ds+EnWl+dRcRvPhyyRLC00STotqqFHt9NyXQPF4LYRNJosTUAptMqJotD+VikJ/MAm857BjyqlH0WaJYAhCCJ7LbqCied5DhwI8iRFqdzGdJf8BoVqkyzmOKywhy3CiFIRSkiJ71vAoJ0ildHGxVxpHbalM4R0sxa565SlaeoMB5Xz+lC2iyYlYRCUsru+b50Y+0V40jTFaEWeWbqwoVAhtF1yPwjLuK4Qbr0TWBERSOIuQkiGh4YdKMlIk5zp2XnyTCG9gE6rw+bmBsPDI2AUCwtzdm7CF5i8F5uUVhhtnyhp8T3Waxlnertv+mKG2PJ64bFmuyBFPHxvjPvjHj8y0KhW6lSrNcbGx21ioxXXr98gThIMcOzECdJccdddJ2jUamitqEQVms0mQ6NDTN28hvShVvdZWZnmjVefo9ld51Of/wlCZXj7xWe5ev4CK4sLqNye8OX5Bt/8iuHA4aPMzsyzOn+T44ePMzm5l8GBCipPbWIvwKCYn5tjfXUdiWBkdIThkWFOvfkaAsPs9DTD1ZB8ZIyoWqM2ONCrHDs0XAxPC0ShaIsn2OJ6vmWxKU9T8am+KpfoUYXKd1vJEFupLN5pHFh3P0RIjwAPRECwhTogSioV2ApwsV/aliWRvkdgAgoZM+Fbr5IgCqlWa1QrEWHg47tkLE9TkiQpeYzFoLo1uQlLU0UhnQ8JbsE0IN7nYuvvChn3Hk3v9/fpd/XWb1HqTdH3VO/RO5y94rBboo10F74WSOlZfwRj7D0lDMaDMt0SxXk1LnnHMSqE80EwZfLuSeximuZ4UuJLSTfp0NlcY3SwTnOgxu3La2it2Ll7B0O1gKSzydzMbbQEAp+7H3iAWmMIvJAwrGAMLC6vsI0R67NhbPtVqYJ+5mZaym6F5/iQHhKJkRqtM7dYaesf41TRlJLkqctM/QLiCdxwE9aNVbrAaFur7W4TvIh9+w8wsXsv7U6K8CJGBseYX1hhZGI39z/xSQ4cvYewOkSsDEbYDkaW53hApBXGs90SrTV+bA2soiikWq0ShRGBHyCQxEmXlc1llFFobTsxSKwMb83SA+r1OtIP7MBpCSAoE63imjJFUtgPWLGGTMKz7xsaHiRLNmk119EqBm0N+1qbbQZqw4SBTyUKGB6qsWP7UU6fPkOStPBEjhYZSbxB6OXs3TXOnp3buH7lGp5KWLp1hTOmQ010GN02xvWbNzh/6Rp3H7uLaGDYup4bB8mFtF07Y6855SCIBHBKN+g+hSUXxyzHV1DEFE9Y9b2iCWQKnVH3h9J5qV5nQZqTPCzKAm7B8D3fJdfGjWz1SfOW968DR7J/QLA4FXck3u409Bcp+gFTcd++3+M9C9QdnJ++vLs8z8UcQn9Fv4hKYmvbo7c3BeLp+w3lW8trqgcE3rNvgj5QeCfY21L/cNdoDyhseY/A+TqZ8vPFmlLua+/n3/H3rTDOgr7id/cqugXgKGKYCH2rhKNtp1C5QCiFQqaS3Tt3cub7p+h02hgU1WpIrVEh1TnVaoW4ZTsZBmW9qNB4RpIq+11JmhL4Id1uSlRvUB8MWF/fJDIhxm/w2R/7vBVdabVZW+2iUo+gGrHn4EkOHznG+qbm1uWLKJUQBAJfGLIswfN8kk7M9PQM7U6HxtAQKlfESwt02h2+861vk6UJJk948JEPMz87y4ULpxlankGbFK0kiJw0iWm21unGbYJQUKvXWF1awqv42P6cITd5mUOUwUaK3v3rWY59niU0W+vkKgcpCPwKAwMDdDoJWQZpkrC8OM+N6zf44k98kdnZaV54bh0pIPdiWhvrtpMoBXGnaUUklHYUTEu98j2fp596mrdee50403iVGnv27mFy9x7uu/sufv/COVqrazRGBjl+/BDju7aTpC1mp6e4MTXF2K4JPv7MJzl8aB/Liwtcu3qFpblZ8rhNa3WBdmI7RJM7djI8VGe5FhJ3W3TbG0zdvMqRQweQJmZ82yDduI3OYzp5QtxtE0qP3CWiWiviuIPSykodu5impB3MVkqjstzO2bpkvnhId0wtkLPdK+vULVB5Rp5nqCzvJeruys8d3Va59yJc4dbNv1rw4SN8n2oUYTBkeYbKFcZojLJzG4XHRnGTKWMN8TzjZGuVvTcrUYSUkjiOUVpTq1RI8sTyOjzpZHMpgUqWZehcIYI+p2034K61QrjOiJQSbbRj3whAojOF8Cz1MEsUmaM6GuNTrw8xPDLK3OwcQ8MhS4uLKJWjVIbvCfJcoVTmigoCY+xaTBkne/GlGLYX7lrXWrkin2XLlKHSmVv3x0Kj6eu498XTrbWdD3z86B0NJTmw/xBeJQTPY2lpiZnZOQ4cPIgRAU88/Qwvv/Qiuya2swfD5sYaSmUsry4xsm2IIPSpN6poEhYXbjEzP8Vma4PxsVGMkZx+9fsszs5g8oQw9NC+pL2e8dUvX+KTn/4cK6sb6HidaqDYNznG6Pg4169cwvgRQ+Pj+H7I9SuXWZydZ3BgEKkzNpfnefm5Z9mzZyettQ1uXQjxjx6jvns3nrFKCQrhUJtDdH2683ZQ2S1C5YB5/0KxZRWy7aniZXuWemdC9BYQ7VY3i7ptUlJU6URxcg294SbKEFh+l3I5QVEZDMKAIAyAarn/FJXQvuplWTXWhtwZDOVZZgennMOrlXuD0PMQ2tif7tlKWJbnZGnmgIltyxWqN2XnRQjKmY5+KUZ6IKQn+FtUAotD5aq9RZVX9yRi7UExWC5VsUEHwty2tEuulZNHhv7Eyn7Ew7OAzxmbYTQ6z8iSmHZrA6MsKSiLE4SBuNNmZWmJ5toaB/ZMIrMOSXsDP4DxiVEGaj7LCx3irAOepFJtsP/IUeqNIWbmFmg2O7TbHRYX5mi21pievs3gwADV0CdNLM0oTRLb2hUBYH037Om3XFAExF2rVqVzq9AS+j4YgR9ENGoNBILV9RUHMgNXqnbJrbQD3krbqSbpheBX2bvvGCceeJj55Q0y43HX8Xu4fnOaQyfvY2JyH7I6QIwgd94RShvwJbWBGpVGdUsVJM+sI2kQBLZVrZRT9lAkKXTTmCxLUKmV5JOeRxBaoydViSy4y+xiU0gV5rndRqFKYimHIX5kB/aksQmDxDr9Km1PsucJqlGANDlri3Ogc3stuar+4NAAwiSEgcfY2Bh79u3n8uXzKJVhpCIIDZUIqqGmFgiG6xHXL74L8TrXz82xezwkbU5w9d1zTN+ap7O5Qm1wGCm0FStAOGBggYfdy146axNSQcn+wtguj9COlmiBuZSyrOIVeuhAqbJnZUczpLBOugWnuFADKhNPz9JeCpO1YqC8oDhKdw8VstRGCze837eY3CGr2t9R2jJH4O7VHz7HUby9Fx97j/f5bB/Y6EWO4vtMCaB436/corNFr2DU/2xfbL9jke2JGt/5md7bC1hYnNKibFC8uzRCLD9egJA7kNsdG7a0hzueFr3CjCg323d9CegpAEjbqRUCZWzcl9gB2NWlBb72la+g8xZGK0bHJjh89CDXbt5gY3OdVqtt5ULR1GtVIj8g6SQYpdDYQd9aUCVNcsK6T3VgkMxERLUhvDTgvsee5PVXX+f825dINmP2HTjBngP7OPnQh9ixax8Do3t4yfsGUzcuk6dttMnJMo0IfFAJ16/fYMfkJIcOHmJtZZW19VW6rTZzSRetUozO+dCD93JlqM5bp95mdWUBbRSp0eRZzPZdE6yur9KNu1SqEZVKSL1RI8eU3ghFJ9Xef/Z69IIAzwvQieui+DaWJWmXIIychH6Fen0QbdrkWYdOq8ni/DQzs4v81E/8ODNZSrcbMzw0gtE5rWbTXnfGkKcJiTEgJMJIqrUG9WqdjdUNxoaHmb55E+NZhb/1hduMDkSMDYS01heoVCKiCuzbu52T95xkcsc4gSd59tlnOXv2LM88/TeohpJL594lbrfobKzRXVuyXfrAY+H2FNvHJxgeHmJgoE4ad9jYWCdNYXNjicBT1OoBcZyTpQnaKKRv1Tt937MdBCnotFoYevM5eB5ZrsCAyZWNM25VlrIoctm5V7A+EuVQt7s+jTKlgXJpDO3ig6YYytYlSCkl09196vm+zUkKmXFpiwomN5YK5SRpi3tbuGKKMcbS6Dyv7FIEnmcpvsaQ5hm+55Hm2LXVFZNw59C4GTltLBAH7LbdPWg7IO53FG1HAwLpZjtylytKqtUGw0OjhGEFrSEIKzQGhlhb20QIw9LSEs3mBmEU4PkSkRpUlhEE1khTu7nWnpVBEUqKnEy731yYFhrrVyclWud9eW6Rk/blpkL2fvePCDCKx48MNDrNTRr1GrHSdLoJuRbs2LWbJ554iktXrhBWa1y6fIXbN66zbWQIoXPmZ5cQnsEXEmkE42NjLC4uEHe7eEHE0uxt/tUv/SJZrmnUq/jERFVJtWKTrE6c0+p2uHLuLaZnl/C9iGe/NcP68hwn732Qt06dJRgY4ROf/zG2bdvO+vICJosZH95F3Ydvfv0bzN+8zPVzb3Hy+F3cupZy5PA+hhoVNjttZLWOEdZtMbNQ1lKJpMT3BeR2wDQIhBW6KhYyt7hJLLgwngOBrkppHL+jVyHsr9aZvsVbuAVSlGWvYgGRdyy0vVpj798/DE72FhyXyBfVNafW5QcS37Nu6wWdwG7T8bfdOlXEAYwNzkmc0G63abfbJM6jolqpUqlWqFYqPYk4AGFVwjTWNEY71RqhQXg2GVJuZ4tjVaB+o3GmTpQrud0NU54H6YYRDTZoIARZrh1IEXjSscq1rWoILHJXmR207qQJOs9IO226rSbry4tcu3KBVmuDRrUCRrG+vMyt69dZWVqkEgZMTkxw9d3TjI0P4ZuY9ZV5Zm6ssra6YJNnAXsO7md6Zho/XKFaG6Dd6TAzO0PgSWZn54gqdSYndzM4UKe5ucnyyjKtZovQD8i9kPbmBmGkwSjyVCN9Hz/w6HYk9doAzWYbZezzaSdlYKDK/v1H8PwKFy9eQKvMSsxqyzXVOkNrQxRFmCynMTBErCTV+ijDY7uIKsNomdBuJXRzj+37DjGxay9epUYmHHVLGsDSHJJuF60NQRTi98kQBhXfusz6suf+bSAKQ6rVCiMjIwSBh0TbBUdaUQZb/bELy2Zzk7X1deJOTLfbIY5j8iy3QCkMqFVrDA0NMTA0SBRF1uFbC1AZQho6aWZBmlFUPJ+BSsT81BRjgxHGKI4cPMDs3Bx5ntBqbXDz+jw3p27x9DOfZG5hmpXFFYKKTxRK5mdu8sJz32F4aJzrl8/w8vMvsmP7GHFrlY2lG+TxErevniVrazZW5ti+5wDCGKfiJW2TRVgzRss1tmIGZUWhDyzbRN9W62QRC4zl3Qv6EvK+R9HlK/TgoQAadui36Ej0D4BbapmTKC0GyJXzLHIGT6ogGpTcf+niwVZQUYSo/qT9g3TYy7hktoKI91c42frn1td67+2Pr/0gY+uMyPvtjSs8lOUL4+ijvXe/N/pu3b8S7rxPCC4KicL0bcfYfS+Bxx3FnwIo9D8K2gJ9wOLOfxfHfgsgvMN/wxO2Wy9dIpInOTrrsDQ/g066DA5EdOOY4aE6J08cR/qC737vu4SBj9QSLQTDo8OEns/U2i07+C0kRgjq9TpKS9I4J4oCdh84Rq06QjCwxmunLpJSZWTnAQYOVnn04Q/xiU9/glRp0lwyPrELoQwvfc9jfvomnlBE1QZrm2ugUx7/6BPsmNzF4NAgF8+f4/yFCmm8CbiuvJG0mhsMDQ0wMT7G1O0pN0OiUFnKffffx5tvvUmn2yKOuyiVs2PHDhYXF8kcEyPwA1sFNpY7b4zB821HNs02UUZTrVSJpKTVapVUnjTN2dy0/w6jkCSOuT11EyE9/sn/9A/sDI6UTO7cgRCGqFrH96EVN1G5Bj/A0mYCJnfs5eChI7zw7Pf49//u31Ov1VBKsTw3zR/dvkm700YoRaNeY2jbEJfOnWJx9hajQ3WiSo0jB/Zwdtswt29cYeb2FP/h3/6/aW+uY/LE0tFCnzD06KYxwihu37zG+tAgu3btYnCoQbO5Thp3efml51E6Y+rWJiZPqdZqVKtVEIY0TQEr5gG4tdWuuz1uv01gpegZNRYFWVs4szHe0ow0/UUK46g5pQCIKxRapkmveivFVgBSsDcKn41Oc5NOu91XBBFlMbWIk0XoLRSmDLC5uorvW1EAleU0221rVSAkaZ6h0gzc+IWr7lrzZymJRERuNIGvS9Up4ZQJjbZiQYkbOjdKW6826eF5AYONAYQRxN0MLTX33fcADz30CAONIWZmZnn77Xe4euUqreYGwhMEoU/c7dDciDHCEFZCMAqjFdrlH6bPL634zxombo27UsiyowG2yCSUZeEUxe+CaVGKeJvitJpyOz/K40ceBp849igrS8v8hb/21zly4h5u3Z7je999jmtXr7Jz3z6Mzpi/fYODe3dR9QSt9RXWVpfsEFkU0N5scuzEXdyenmajuYmVp/VpDA7TSWLuu+8koFBZTBK3aTU3WW9ughewvrjM/Y89TprmNNearK+u02rGeLJKZWIn//Lf/ztGRsc4d/ocp994i9WFBUyWcOvGVRYXF8iyhMk9e/nYU58gGhhio5siqwN85ONPE9UHMCq3FCffDgcXhXMPNwAuC8nJogqFMyZ0SblnKRvO+Nvy8FTvZKj3gX+9Cr5dLI2rgpZFtTsWYF18Mf/1J7n3XVsvtPL1Oy+B3ge2LqTGVfeKrgV90rp96kFaQ54r4jim2+3SibskcWoH240hDH1qNZswRtVKKSVnjJOyVVZ4JM+LRMpVWzGlRLBximK+L9HGLqSFHHDgqCVS2MpJUVkBm5QVA17Xrl3j/DvvMH39CnFrHd1pMn3mHRiq0hisk6Ud0rVVAt9D+JK028a0mshqhM66hGAr2FmCVhnCF3hBhT/9Z3+Gbqr57vd+QJrD9h2TVKs1pqZuoVTOgX17uHr1sjUUUoqRsW3c/8CHeOrpZ5ianuOrv/8Vtg9Xmbt9g7XVVdI8Q3qCKArZt38PV65cQQiDyhN0kiNEhBcN02iM8qe/9BfYaHdYWl7BoFlZXGBhZoq1lSWSuAvGcOzkPcSZ5iMff4aT9z5AY3iMdqKJBgbZaHXJpUetMYSRPiKsIIMQoxW+0YSe4He+8hUOHjrMwcOHGRwexiDIncSrza09S/dxzr+ljbwWBEFxnkyZZCNcNXZL5bxHtOsvlhfD0Vpr5mcXWFuxDuZLSwtsNNepVqu0W03izXUik9NdW+TMa88jkw327trGiROH+MHzz7PZ3GRoZJR6rc7q4iIff+ZJvvWHXyOKFJ4HleoAUWWQkW27OHriQb729T8kT7oMDFbprC3RGKziVUI2m11E4vGFv/T3eOKTP4EKK+RCorVAOTfjKPQR0u6351vjUXsM+u5HlzObQty2rEyJHh3nA2KDKcCN6yKVgELIXnLr3l4OB5Z0G0Oe54ROkrTogNhcvV9txZTxqj/sfJBS1Pu9Xs6aiP7k5M6Hft9nPyjWFZ0DW6Tof/+d7+wv1fQXgOyf5anoe8sH7WEBNN5PnWXr9/9oZb/3qmTdud/F+eiHQPb5/q7S+ytvYXtWWpfUYJMkzFy6xDd++9c5/dwfMViVJEmTbnsD3xOM793N0vIyYbVCrhLStItWOeQaH4+J7dvxqhFLi8s88ejHOP3maSb2HWLiwFGuTy+wc/IQf/4v/mVee+cMjz3yYdLNJm+9+gpTN69x9PgRKvUa3/r2t7n6xhscOHmCp596igfuvpuhRp2Zqev8v37pF1mcvsYDjz1EqmM2Nlbodpuk3S6by8sEQUAtqJAkKbkQ4ElbjZYSpTKiKLQKjyp1ya0dgJcu0czzHM/dK4Vfl9LKFbAMgR+5+0JvOcdSylLxsuhz5WkGBrwgJAgikiRDRBXGxycwuaLb6ZCmMZUwYNeuHVy8chGdGyvzG9oC0aGDRxgdHmF9ZZVvfesP+fDDD/LWG6+RpgnVgRpBJaJSqfDII49w5sxpO1DshywvLDG5dz8jYxNcuHCRuNvF9z0evP8eZm7fZGHmNnmeMDQ8xPiO7dy6PYUu5xp612dxDWmtiaKAOI6pVEMGBwcZGhpCCMPly5epVqtondtOqJN3LY5PEZMLOVjrtt2TmbVqmxD0ycb2J8LF/hSxoZgtMMZQmDBHUUToOkr913ghY9vtdvF8v1zfjbHzJJ7nkccdoqiC7/tkWQZSEoRBOePqeR6jI9tYWVu2oMpYOVzf8+gmXYyyfm6B56P6cx4p8YRlSEhp/bK0toBMGyfUYHq/A5xdgRH4XoCUHlGlxurKBo8++hhpmlPILW8bH+cv/tz/FSkF3/jGN2kM1Dhz5jRLS4s0N9dZXVnGGHsNp1liZ508r8yTiuOYpmmp7mmMU2pEuKK6KBPXfulbK8hjaWLFzG7RkSu64cU5yJY3/vgY96MCjYG9x9EI/tSf+1mu35phbHwXz3zqs/zqr/86f/vv/B3+4//n3/DCc98h7TSROsPDUm66nQ6NgQHCsEq70+GBhx/i+F130RgYYGZmht/7nd+hPtTg0598im63xdzcbWamb5MkCbt27yaoVDl/+RqVSpXQDxFK0213GR/fxY/9+J/iey+9yj/+hV/gu9/7Hs8/9zy3b9zk6MGDPPahh7h2+SLPfufbPP3JZ6jW65x59wKENR594ik+/cWfxq8NoJxaDRhSlTvdaukctcsSGbmbpimGbT1tHOfWLSp9ngAlBai/8ie3LjtFUv1+B78fFGzlb7Pluf8aoPGeml5fkrOlnSgoMjq7uLmEowAfvU6M42W6pKioL1hgJt7j2LtlEcYmO0hpVZnSlE43pt3u0Gm3ibspzWYTIQSNuh1ir9ZqVKoVarWIKLIqW1a5xNLfiuYH4OSRgRwQjiIiLWBRgNAKgW3n3bx6kddeeI7b1y+Tx21u3LgK7U1GJsaY3DnOjUsXaG+s2i5QGCDI8QQk7U08aavVRmegNX4QohAkqaI+tI1WO8aPahg8wqjC9u3babfbfPgjjzI9Pc3mRgshPLpJRq0xyMefeoY9+w/x9d//CmdefY7AUwS+pcRUqxVGR0dYW1tjcXEZYzKStIsxMDQ0ztDgDuYX17jr5P088eRT3J6b5dKlS4QOIF26eBGVZgwPDZPmOQqPtGM7E3gh9ZFtfPjTn2J5Y51qrcGpV18nGhziiWc+wRMfe4qBxgAVKTn37hlee+tthoZHeOfsOaJajQ8/8VEeePhDgA1yyggsTBdFjtRnbSPI3fVSSuUh3DBa33XIVv8HrXNAls+hQWpBtxOzurrGyMgItUaVZrPJyvwCI9UKFaGZunyOP/qD/0xrZYbJ7Q0ECXPz86y3mhgZsGPXHu699x5OvfUqs1PXCEONNjm+H7Fv/xH27DvM5Wu3mLpyDb9WRZDSqIZ0O5vkWhPUh4i7grGDD/H3//E/Q4R1Vjc7BJUatYEGeJDnAunb+yPPlZPutDzw8p4oc96+K7lQajNF1b4YnO+/j208sIZM9jgWFfUymS5uSye7LbbEFrdtlz2L8jxt/Y4e0Nj6+vvFoB8Wn8pB5/edqbDf834J+h8HNO58fcs+ltu9E2gUJCd7kfYXc/44oHFnx/n9v/v9QcgHgbH3/kbTV0L9/xNoYBDCRkiJ7W6YJOXW+Xf5hX/wP9JZnkPmMdWKD1IjfMnhw0d4563XGd6+nSSJSZI2WuUIbHLk+yFdpThy+Bg3LlwjjzWNiV2M7z/C8bsf4C//lb9JOzUsbazTbrX4rV/5/3Lj8mU8aT2UvvQX/jxJlnLlyjWe+viTNGo1kmaH86dP8/Xf+zK/9P/8Bf73X/wnXLvwNlokiMAgPOtXY3KFLyS1oEqSW6qHMgakVbcaGBhgdHSUc+++ixdIl/xlYDSeGygGqIbRFjlSq8KjnEM1bs3we4mwsVVqj/7ziEu2Jb4fMDQ4zH33PcC3v/ssn/r0p3nt5VfZWF1DepLJ3ZN87nOf450zZ3jt5VcYntjJ4088ya5de6jXBlhbXuVX/8//E79RJY/bVOshoMmyLsYoKtUqjUadlbVVPvr4E7x9+gxploPxUNqalgpjpcyPHjnIwvwM7eamnX+QAi8MOXbiBNevX+fEibvIsoxbt27h+z533XWcgwcP8Ku/+qsuDthrq1Kp2A5EkhBVKvi+tHRYY+fh+mmd9nl7/RXHWJTxRJSJtoCyyFAAk54Bnj2uVqHQK7dfSNVaKVpKCpTKMrSykvJlzPF7AMVlx/h+gC/h6NGjLC8v02q17PcbQ66tgV+n00F6QbkvWuWAsepcDhR5vqXtWnqWHXjvN0oFm8t40kcKJyuuFWmaEIYhsZthlNJSnkuVVBGglSFptkF6CC9EOqloIwVZHCN9j8ndu1lamCfJYoLApxLaAfVOp9sXD4qieC/WKKXw8CgoU8U5wSlnCTcWWuSBhTkfYE2jt+RulB2Nomj03xRoDO49RGuzzfiu3XTaCXff+yA/81f+BgcOHeH1197kuee+x0vP/4AwkDz2yMMc3LePqakpnn32WTzpE1UqKAND20Z54smPs3vPbl568Xle+953eOjhD7Ewc4v2xhpxp0WucoTvE1SqtDda6DBibGIHG0sr3P/g/Tz82GP4QZXvf/91/rs//ec4dfYcR46e4MKFS6yvr7G2ssLw4AB/+2/990zdvM4v/dIvcvLESa5fv8n2XXt5+lOf4PGnP8bsWg4ywKgMPKvEokWRU/ctXsJSHowxJdCQCDzTq4v1t/LsGu8QZF+lrKiC4VrY2hhnpdS7yWxM25qEuF3oe93NNNyxLkneu1AVdMJiHxDCKV71AsGWS6D4ydoJoJlC3aY3xO6mnBDGav0Lg+M72oOhi88b6IdSQmAVfoS9cZXGtvmkVQApBs211tbQTWs8R/UoWrBWcQmSOGdjc4P19VVbcRBO7QuoRBFDA8NUK1WCIER4nt1laRMyD4VHzsbSPMNDNS6eOc0rz3+fG1cvs21shNWlBaLA5+jB/fgeXLl0noX5GcLAp9tpEscdjM4IPOEkIa3UnvQ8jPTIckgTRW1wmLQV8+Ajj/LRp54mDCOWFheZn5vllVdeJstyduyaRIgAP6zyyGOPU68N8m//2f/O3qM7mZ2+Rh4nZfNSaMPAwBAba5sgDYODDYQXACFhOMjw6DitTkpzc5NOt8nR48c4cvQ4GxtNXnrlZYIoJEtS7j52grvvexAdBKQIFpaWOHPmDO12E+kJDh88yJ7du7l06SJZrvH9iJnb85YPqiUPPf5RwlqNhZUVjpw4wRNPP0Ol3qCrFGFUJTO9YeYygxNYw0MDXmA7fhZoG6emZi88r+8aNKZYvIpuWUEJ6XU7dG6IuymbzU0Gh4eJgoCLZ87x8nPfw8sShgK4dvZ1dLLMUE0R+Dk3bt0i6SbsOXiEid37bFJCTnt9AUzMwNAAQgTkWtgxWGGvH1v4yfGFJk0TjJB4QZUkFtz90c/zpb/wNxga3ckLr75JY3iE/UePUmk0iDNjMW9xv1G02N291PfwjC5v2FIEov/2FFvTTVz1ypMOaJTJafEFvQ9LZ0Baylb0xbit37G1ymjPyh+X/Pd3IvoKLFti0tZK2HsffV0J04s2dw5n0xfPRAkYinmwLT++2Or7gCdTvgbG+Zr+MDDT++L+pOiHdS36k/337PuW9/Ve7KsxIftAkOh7r+CD9rQQSrgDkBiFB/jCgMrorC3ztd/+Lb7xld9Bt5t40jA2sQ0/DFDGcOLECaSA6VvXmZ+ZQgpNt9smTnK8sMHIxE7+9X/4D/zar/0Wz33t2xw5eR+PfvwZDh8/SRTVGawNUa1WqQ9XWF1dZ3V2lu/84TdZW1vl7/4//ke8KGCjk3Lx0hV+/3d/D53lBMDm0gK3L10gkoa0s44RMagOIgQ8q5R13/338+rLr5A7bys/DGz3QVtKyvjENuZuW1GOxsAA3XYbIXCdxN7Bz3NdVs2FS6ytWpBGK7fmFW7oLtHN8wwpoNFo0Ol0yHOF5/lIYZN9jGBkdIyV9XXq9Qaf/MSnOPfuOTbWN5jcOcni0hILy0uEUYVON2N0dJxPfPIz7Ng5yc0bNxkdGOBnf/ZLfPHHP8PG+hJCwqHDB5jcvYtmc4O3336bMPRdMuxZE1sEg0PD3HvvfXz2M5/h3/27f8et69fA5GAsRXVwaIiJHbtYWlllfX0d7RSwCkVLexx6UvUFxUgpTZ47dSZph7WDYtjZrbd3dkeLzojdR+uB5fm+vUtdN6UEHUL0qcY5qduS3WDwfR/ft8m/cQwJIaSrZRZgRVkgKYT1ijG2W1SAlDvvFWEMwutJtiqtyZ0pYBpnVKrW4d52YqxoSeAHVvVKpQg80iwppduFsNSs4sY02pQDtJ7n2XlFD0f/7XlzFADI8zyyDFSuGB4e5fCRoywuLLO4uGTVr9xwd+aEj5TKLFiQAt9RyxDCzZBkvY61tEJAWinCKEJlhaJRL7Mszrcfeo66Zh8F0Ci2Y0NTEcu2FnGMMf9tgUZj70Emd00yN7eIwWPX7r3s3LufpZV16rUhrly+wmc++zmOHTvO7Pw88/NzeL7P2tIqE9u3MzUzzf0PPEirG5OpjF2Tu7jr+FFefeE5vva7X6a9tkTeaTM8MMCOyZ0EUYWbM3MMjYxx4+Zt9h04yLaxMTY21xgeGWbf/kOEUYMH7n+YdpJw9dpNPvyRj/H8iy9w6eIlBhp1pDDs2bsLlWZMTu7i5o1bLCwsMTyyjQcffYwTDz2MMh5CQpLnSN+3FVl30IXjFWYq79m1u/8kAr9I7V3yj+ivDAp30t6vguWqtK6Ca/rOXK8jIstLYuui3FMXMbL/ebZYE/TvawHu+9Yzx3t0gKOczC7mH/o5wI5WYKwBX8mXFIXaQ++7iiuwqADZA1NUSOyCK41GCCenhsBIyy0vlFOK99mZb2WHzVxWJhDOkdOQJjYRRSiyPLc3BmCMJggjBILQ9/jyl3+Xo0eOcvyuozSb63z323/I0vxt7j5+iNdfeYFkfZk46ZKlKVEQcPzIYe675yRnz7zDjauX8YQm7rZIkg5SGkCzurqEQeFMMvGlZ/n32rp1j46Ns//gIU6fPU8cp1SiKrVqDeF5zkXXtnkbjUGEtPra2kgGh0YJwirzc7cRXozJu+RJgsmtyhTKII3gU5/5HOcvXCSIAjpxwuZmlzjOLa1hcjebzXWaG+vUGw2Cao3Jvfs4duIEs3Mz3Lx2EzJFmiu++Kf+FEfuOsHm5gavvvIqzz37Xaq1ClmWEAqPwaER6o1Bup2Exdkl7nv4CV5/5U0O330PG90uh44d4+GPfISjJ06SAwQBmRJOEdrSbiz/1l4OUtrjYyvrfee7TMBxCaY9j8UFLMxWUO2UEq1kb57TarbQWjMyOorQghuXrrA6O4/ptthYmOKdV57FxMuMDUIUGqamp2i1O1Qbw4yMWunHxdnbqLyFLxVB6DsQbIevkixD+gIdxwgnxRmGIZVqHS+o0U5g96EH+NLP/jV+7Vf+E9qP2H/0BCcffIhDd50gxrecbApvGXuj2pEu0QviGmTx+0VRwOiPG31Vi/J2s7LHZfen9/KWpL5IAox5L9DYOjfx3o5Cf/fhg1eLrXSG9+7ze+PgB73PJsruOL3PNrd+7v226YJcmbDb58Qdx6UfsJTB8X2+qoB2Wzs5vO/B6H+mHCb/AAO/O99XbqPc762gqVf3En3wdOu27wRywtgaGkojtUInHW5ducC//z/+JVMXzvHhj36E+++7n9dff531zU32HznCO6dOkbSbRELxwN3HOHfmbZaXlqyCXn2EcGCYv/F3/x5nL17lo499nOnZJbZP7mLH5B7mpuc5/eYpzp4+TXUgYunmDYwQDA0NcujIAT7y8Y9x/O57iDNFuxNz+dJFxkdGeOf1N3j1hR9w7/EjfO9b32RtcZaJsQY7dowyvzDL8vI8AsXAyCAYQ9KJiePEikMEgU2Ei4Q4TciNZnBwkDRJrO+Bo4IU1CljBLVazTk6+/i+pNNtY/0Hiuujd5QFEEYRI8ODZFnGysqKu2+sD0O91qBarbOyuobSCik8Go1BwHaB6rUG0vO4efMmDz/2GOcvXOav/fW/ydXrN3npxZdpbW5SrYQMDFaZm5ki7jbxfInnCycLLhgYHmJ5eQkEqDS38FpKJB6hFzA0NsbKygpp3MGT2A6Q0UjPJ4yqJFlmj49LRvuT/OL42OTeL42FoQccrEu3VTYqzN6KhB56dKgCLBR+DgWtqrwfZF/BqG8OrD8Rt7QnR7ky4DtA5PthqZKZ57nz07DpSJ4r61AOliYnrRWA7xzB0zS1UsZCOBEe26UyAtI4Iworjn7nFhjjpGKN/UxZCFWWPiakBWRl/Cx+H5Y2rHSvaOR5VjbZ923R3RhIktQeNwUPPfQwFy5epl5vEAQhnVab9dVVvCiwAjBuhjjN0lLC3ZRgzTmn9+ed7pzZbrdn6Xr04mVZGDeGIPQcmOxR4YpCdq8QZX+foOhI92JWurTOH/f4kYfBU61Z3VgnS2P27TvAYKPC9YvvMj+7wMTOPXzyyY9x49p1duzcw8DwNjIZkiQpaR7y6EefJDxzmrOXrrG2vsE9997L9h17WVhYo5vBibvv49rFc5w8cogb164yNDLOtvHtTM+vUakO8g//p3+K9H0GGg3OnHmHqVs3mJmeIQgDjEpYXF5lamaeJO8wODTKAw/dQ7fTodVsMrF9O6fefotrN2+wMjdHp5Pw0MPDHDt8gMHIY70ZEyvwowilrOlWoURRrkPFwbb/oqhRaWGVqQqYVwwql6fAVb5K0zq2rmOyWAL7tOCNMIVb/Jaq5Z0kqyLJ2PJc/2t9nxfuwiyhkjBIbSurPbna3gb6uzA22bHqBPYrdUl/kG4gsKBWFMdKuEzJYEp+YnHjuvq0S15cXdot2lvWfTskY5+Xdnsa20HBCAjAuPatH/o9kGQcf9Rt6IH77+bsqXd4+5XvU/UFJou5euo1NqcusLIyB1laBq2g0WCwXuGl55+jVo3YWFtCkGNMjlYpCI0fSOr1CIMiy/Iykc5y+/1BEBDHHeZmpvHQeFITx026nQ2XbMtSli7pajt2KzwEHotzG0jhs23HOMvL6wilrKNnrvGkz8DgIDt37OTds+8yNDrO2sYGnl+hWvfoxGskOmNpadpZcWjipEU7aZHpmE53naTbYXN1HaMUaa557g9/jzNvvYznB2xubDA6WGFtY508TSFqsL62gfSreJUBohF45MmnOPno4wyNbqOb5QyNjjIyPk4uPTSQ5Rqkhy6SV9MT7TVorJ+HMxkTdnEwWqNyy6Eu9c9doLcUKlvV1cpCSc/zCJyErVKKJElIs5iR4SFLzRCSqBIxPDpMezWnG3dpNTcYrErSLMHzha1cGk3cbrJhoFqroVNrlISwvGu7iGvwPPsnIAOBSu1ioXJNGqdEImR4cBiRdfjd3/oVpq5eRPgRndYKYZCzZ/cE0eAYidL4QYVU2d9qb1EHtozs89gpa+xbuhNF1VuIPnAv7ALQG3dw1W8XG3rzEBac9Yz3+uNID9yXIUAUYg5F0aMAEbKX7RbV83I7dxKNTN+fPxwwiDt+Y19ZpDhK7/vZ8hs+AIe8p4tRvrD1K4q4WADdO+NqiXbd8Rf923nPcWBLN6G/4lvGNfokcIvdKbskxZkwiIJKWP6YIgHuPz5um0XM33Is7aeFK1yBZnFhkd///T9gYXaeiT37Gdu5l5WO4sEnPsnEjp14vkemA/JOk8EAZm5ept3s4hkPtCRtdhCE7Nu7n7A+yoFjxxjfvQcZRkSVCpP7duDJD7Ft2yhpHrMyuZPJXZNM7JhgYGSIgW0jJFKQ65zhoQb33H2coYEqOyfqHD40wdT1m5y87wT3nfwTHNg7yfzsbdKsy+3bNzl16nWmpm7g+wKVdF2sMGTFMTSW+qUKf4QsxRjbFTfYqm2eWoPSLMu56/hdGAzz8/MsLS3YOCR6GodamZJWZbCzTK1Wy84AuFNh/eo0cdwlSzPyLLWeEvUBhDAk3YRW0qK50SSMIvbu3cv6+hpBIHnl1RdYW9+g3Vpmc22FlidZXNaMjQyijefWOwNS4AcBm61NkIIoikhMjDC2m2mN5TLas7FtFQuD1eGzhU6tcnTctSAj06WakqVAufXfVSPzTIE2zrPCQ0oPtEHnRVHU3Qfu+i3VHIWT4cY42lERNUwfGLDUHaWdxLSwcrUFGCjmxQr6p3YSsr7vIUVvBq1QxdRCl73hAhwaYwidSIg16qMEObVajTxNbEelyNWEQPgeearQSpPHqS2GeQKMQaUpRgr8METlxXdbhoVRpie3iyk7KAorGxuFIZ7n0W63bffN96k3GnieR5KmCClo1AfYs2cf3SRmz55Jdu2aZLPZZGrqNtIX1OoVuu2OOx6u8OpiatGJE04Up6jruhOFJ30QwlG9hKVKuVy0CLVbZmT6czDRo4cqV/zeStH84cWTOx8/MtAIazU6SYzwBEncYTVL2VxdphpKNlcXWVuY5dLZd9m5ezcPPPoR9hw+zMzsPBcufIfp+UX27j+IjCpsbDTZvXsfRksuXbrK1K0ZJB4yqDC0bRx94wZprqjU6hw4cIiRbdup1RtMz84yPz/Pysoaq6trrCwvosmZvnWN1bUNYqXxQsGBg0eoNwZQWc7QQJXt49vwfJ92HGM8iRawvLrMqbffJM0VIqii/ToPf/hhKyPaF8Ot14I1gSuoDqL8nz1TfQX7HmDoWxCKDkdvNSpS/t7iuWU9NP0LS9/Tdyxm7/ncHU+IOzZafqbkwRdVjP5Ko5tPcQCjVBooL24XWCmAiw0EBbe5SE7ckXEXZwFQKK9uK5NW/PZiS0Xy1VuQi2BGUYFwVQIjJL4n0SpneWkRjDX08TzLIU2TlMGBQUIp2bNznNWZETbnbjE3NYNnUnaPDLI0P43JO4yODCGlVUsKw5D2xhoqjUlFRhK3kCgMVrkJocitdqmldDlk7wWBlUDMlXWbj2OW00UbXKTz7dB2f7XObWKpUuJ2wtDIKEEYkiQ5aZKi8oSkFWDSBJ0ra8SjPTQ+yoSIsMHU1DUe2HkAL7QqYEniPCR8w9jYKAhDEidoY13p426bm9evIPKMRqOBCCRJ3OXm1YtMT93ED0KkkIS1Ovv27iUMK/hBg3pjlO2791MdGmOzm7D/rpNEjUGk9FAIjLCKNLYjZ3Xhi8qOcXzcIvE1bmErOnaFuSBYrxpHNHyPUg8UswlWa75Y1IQQpFlKnqb40krZekLjSY8okIhqiKhXCEKPNO0i6gFaWMM/61hsMCol7TbxhWGgVqXbtUZHCuVaBHafpRXIwgiJML5bfAVZkiFFzOCwx3CjwtvvvIbOFEZIVmY7LE5vo7uxSDfNqI1uB2OvD2EopW+LpNKYXjGguFdl3z245b7/gPu8vzhRLAa9YVbjwEAP9JcRTbhJhb7ORv939TqN5Ul5z3cXcWJrLOmnYFHuz/s97gQbRYe4/7NbvqfcH0H/u8r33PHJOzsQ77cfH4BXtv5OU2Tz/QCq/713bmUraKIEGL1ZGbtE9CJg8e7yzx+6r33D+XdeF/1gyt0z1XqN4yfuYt/OnYyMjrFz9x66Sca+A4fYuXMXadymFgZcPnuG86+/yMryijX/dMa1YSVictdupqdnqQyOsraxgcEjyzq0ugmVMGBsYoy52dscPXQUKe5hYts4tUaNXBpSYROXIPSpVjwCWWFu5hbTt66xubbMwEBEq7XOyNggt6ducuvWTTwp2FhvkqYKY6Q1CnTJk8Gg8t6wcK6s+7IQgixLS0qOFLZ7Xg1DMqUwWtPtdDDGEHe7pGkGxuD5nhWUaLbAGKrVGtpo0iRGAN1u1ya7RSXSWNqLypVN+ADPk+Rpwo79B5ifnae50URInyS1g9lzczMgYWl5hla7TZa1qFYlBw8f5vzFd0nSFkqnbnhf2vVJ2Hk0KW312RY2taXq4JbTQrpauGKNwFap6SWOStvuuPWuKIBw7yJWSpHrzCX+lHHcSuK7Ip8D3kYbtLDbK7oUtthqze4QfXOq7t7RucLIgpnAlvcU1CpVrCPGUb+1FWOxdK7e0LkU1kivWHOUym0nw3U1jHY+JX1zIP3zJIV6pVC5/X1KlbQ5ZQxod3yFcKwC4VQ8yp4wRmknq1uI1LhugNwaJ/tpZgUrxA88gtCnUo24ceMW9XqdzeYmG5ubJGmMF/quG6ptXlZ0+d197/kew8PDjAyPkec5GxsbbG5uugKoVZRSRiMoCue9wkWx7pRb6+uE9s5ZUQjrDy92f35Ic/p9Hz8y0BjZNk7cahFgjXpU1qFerzE+PsGli1d59tvfYHBsgiTepFbz2b59lNW1ZRYXZ3n11Rd5+uln+MLnPker3WVmepaZ6RnyTLGysoYvFJvtDrdnZ4nTlLX1dRbm5xgeGmDnjgm++Y2vsry6xszsDKGzvc/SmE7cYTGOGRkZYXSoQR63Of/uKQSC4YFB9u7dR6e5QbVSYdeunXTHRok7CZnSPP/SywjhEVRq7Np/BGMUgfCddrQmqkQEro0mpAfC2ESnTAf6lhp3c1tEW7yvABs2ee7NcLh7WvSte6Z34ovt9ctJln/rwyrlRbDlDbzn/UU3ApfY4AKN55LkXnnU7pjBdVQKcxcpygSmhEhl8ggY7fiS7pgUHPCCAoIDE6IHzorvwUCn0y5bimEYEvi+rcUIjQeWC+/UHSSgjSJJMxKVMz9zi4WZKfI0IwgCfClIkwQvCGkMDHLX0eO0Nza5+9ghdo8McOr1V3nr1RfZu2sckw4yO7dGKKFaDRDCurevLS+wf88kN29eQ6WxNcojs0BDaozSJbBxcmT4gSTwQjKROl6lTVDzPMfzfTxPYqRAIWwbX3gINChD5Ht4niRDUwkD0lyxsbKM53v4Qci2yd3U6yMkqWK9FbPahnsefpLdhw4z3GyxND/H2uoKnl8lTbts37HXdVVSG3ia62A6GJkRJylRaFW+4k6MCXy0gSRO8YOQ4fowu3cfZHRiJ2MTe9i97zCjO/bg1wZIlCasVtFCkriBZuO8HixwhMCTuLhMQTXxXBJVAFu0sSodFm3gCWcWJIXrWhg8IdH9SaarlglcW13ZbavcmkKFvs/K/ALonF3bJ9Fxi4FKQHWoQqNqFZ+MUEjPKxdXKV2lV+fkaZd6tUGSdMgLffY+WqJVF7HXdhBGdtFxCW6apqSdNjrvotMWgcAacCWK9flbXDv3DiN7jiKCCrXRCkJ4CFN0NXpt6lLSVkD/rIHNj03v3uuvVxRJqRCuU9Q7ZL3KVMEJZsuL/Zzqokp/J0Wz90W9wsmWf/fHG7E1SS4T3D449UGJ/JaP9AfFrZva8p7e9wju7KW876OvCLf1Vxb7Ju4ANv2LrgNIpvepfqDQtyvlF5Sgr/889T3kezpAbI3FbD0fov8F+rYptsCY8reIvrcXwAYh2L5rJ3/2z3+JPFHkuUJInw1HPbTqNIbQ16wuzvLaS88zPDqI8DxUrqnWBth76Dj3P/oRZucXmPArsLKGNpIky/GCgNGRYXSWcXvuNnc/cJJtY6PkWUaaJ4jQUlhCT1KrRNQDwWY35Y2XX+K573yLQGh+6otf4Na1Czz3XcPpN96g3e1icoV1rjd4oWddj2VAPwwvZGbzdlaua5WoahWJtOWqC+lRqdVoLS8jheDKlSvkuX2/73mo3ILxwA+scZuQhIGl6mTCymbbGWEnQy17XjUFoDHGEFYCdJpTiUJ8J6dqQZFmfmGWTGdUahFhJMg3OnTjTQbrdXbt2c65C6fIUkOjXqPVju1pM4I0zWzsQJB0Ewsy3DVjtJN015TrrNGqlF8tAC5YEGSdr93r7gKyscgez8nJSUZGRpifW2Btfd0WVox7vTSJKeYyXN+iH8Q77RhhitW/RzsUDvR50nPUdPt32CpKAzbeWvqP/b5ipiZLM1Su8ZxylPSsv1KWCYIgsF5fbmC8iJuFqZ4vZU9hrMxZcvygUtKHimNqDODZa1blVjGwmK8ofEEoQBMar0js3f5nWYZSOZ4zKDRGE7vBbiHsuchUxtz8LOsba6yurTAzM1NMnOFLSRLHCAofKeHma3qBpl5vMDY25uiA0Ol0yLK8PCdaaXzPKwV7+rsRZZmrP490hZT+olFR8BJbxsz/6x4/MtDYtXcvi7NzjA8MMlitOa1ky72cnppGqZxjJw9Rrwlmpi9xc+oy585dZGwoRHc3eOPF59gxNkKrk3DqrVPkSvGRDz/G5UsX2LdnB9euXGB9bYMoDFlbWWZ66ga+H/DAhx5hZnaWYyfvptVaIwx9to2N4Qchs7MLdLtd7j1xgsGBGqffPcvGyrJ1Ea1UCTG83o05e/EyO/cfotVNOH78BMeOHmN0dJzJyd288tprfPTjT9PpJGyuLdJsboDQjI2NMDwyhIegtdkkCAWVagMjfJSycwvKAYTcGHwnEWaTr2IYlvImLigPhr5OgVOBgeLmsje9lQXdqjPtBEDdJovFvv+z9P5uylhQVpCLlpvAINGEnuUvKq0sUi8qGsaQazDOMVi6ACxdAFOu6iACr6zom8I7pEDFjoNvdaRt9aXgWxvhXrcj6cxMT7O2sspAvc742CgDtQa1SkiWxMgoYGN5kSRL8QKP+kCNqF5hdeE2S3Oz/O5v/io7J0bZWFmh226RJwnxZpP7Hn2U2YVFjv2dv8/Ni1cYGhhix7YJPvLhx9Bph+9+86vce99xbk9dYWlhFt+znFRfCo4ePsLNa1dY31hFYr0sjKPaoO18SaVSpTAkNLkh7cZkJHawLvBdXHctXZVhtCirQ74bLPTDEE/4rCyv4vuh5YdqQzWM8OuD+GGFxuAon/3Cn+DI8fuYW1jj5dfeZnl1nf/hb/1tmhtrTN+4gUq6bK4tc/P6ZZaXFllcXOf++x8mDOu89vqrtDZWCIOAxuAgRvm02inVWsj2yQO0Ogmb6xsEoc/eoyd49LHHeenFV/DqO/jYw09QHRolFyG5CCCExFhpR+ELcDzUwnTOmKIz4WYwvII+1UsyhQfGtaQFnruE3SKo2RK8bae3GI4V7hoGY6QdfDbgC0nFD1Fpwks/eJ6k3eJzn/40q9M32bdnF2lnjebaLGFggatBkCqrDqa1cpJlmm6nRZxY5Q47qK1BWbFeT9qBRKWs6hUIVO4AkgCtFOtry0zfnsELA4ZGB2m22uQq59bls6ytrPHn/vu/z7XLl3jg8Z0oZe8X0Z8gKo0M+pXdTFk4lO732zf2PiP6Dp3nWYU/VbzJUM5rWTGq3gBHv0SupTt8UPov6Fdz6T1LGXfufL4fVNi8tviR7lNFe798qi/7vzNppy+umfcm6r03CnDeR2XRBwcDTLE4m/LaKjaptXEVXkcBkf272hd3+7oXJfg07ye8QVFVKWopWwFQuV2x5TwWH+s/AuV10U+d2rJPd2z7DgBV7nJxJHxAaKSxLtTt1Hb0hGcrsTenbmHylKFqxPLsDP/8F/8JXmcdz8tpttbxg4BocID9R+7imU9/kcMn7+Geh+5lanGVuJsRhAHNTgfpSXbv2Ua3nfLxpz9OpVEhVTHNjXVUnhNVQiqNKtWBQSJfU4skq50m87dukGysMjI6xOrtmwxXPF574Vl27NiByjvEeUJUiWgM1EFIOp0WnXbbJfoGIzSJMwP1pHRUQc3OHTtotVqsr6/TTVKMyVnNVwGoVKt0u11AUKlU8TyPTrtNlmSsJmsUMpHraxvXezE1AAEAAElEQVTlMVVAFFVcF8HOIkSRlcK1QMBVrQ3s2LWTmzdv0m52CYLQrqNGY0yOEDlCepw9+zYCO7612V7nu9/9FkJljG/fxf79B7l8+TraQBiGNJubpFrRqNdZWVwCDNVaFZVlpEohPd9SdpC2m+G6M0KI0lw3CAJraqqs6qKNBbYzYcAlq4ZPffKTTE5O8p3vfJd3Tp2mmOsKg4AkTfCFZym/0n3e9LoFnudh0EjpcgZD2YEp5j+KeQJDIYQjSsndfsBGIQSD9d6Iu118L6SYAdVAluWo1CbWeZ7jO5luKyFrZzC0k7sFSLOsF0+FBYAyjEqzYu2oWdLriQcIYQV0tOtmSM8rY0vg+yiV4SHwpe1oCencv41G+p6l5GOLx8oZxxYgNc0yVtdX8UPfyfQ6arqBXFu/kixLECJEoEsWgDGQpTlTt25ze2qaLE0ZGh6x++jc2aWUDsT1QKTpkyEpJHsLOlph9loYfBYzHjan1OUsYH8R7kd9/MjD4F/6h/8LX/md36a7vEq1UrEIMk2oVELQhixPUNKiOBFWCGoNPBHQWW1CpkEGPPnpz3Pt1gxBtcHTn/wEX/yJz/O1r32T//SrvwIq4e7jh7j27juszM1Qr9eY2LuHVifBC0PWm0127t7NwYMHaDZbrG+2+chHn+Seu+/mN//jf6TbWufadesvMDY6SrVaZWZmjm6cctcDjzCxZz8n77ufgcFhhodH2TW5Bz+MLKrMNH/wu7/Hq6+8xN13n6QS+vzg+8/xk3/iT3D//Q/ya7/x66ytbvKX/+pf4tCR48SpQSFQNsdylB1dtsc+6JAWi14x0f/eIfE+9YY7FrL3Q5JbK15b31907gLf8jSlgMiDyLc+ExJbmNHKqQwoQ5Yrcq3xwohUQ1oMbPdXJYW92JSijy9ZVGLtd+Zu8Eh6FoAoDL4vHKLPkb6HH3mgbDU9breJWx1uXrvO+TNnuP++e3n1hReYGB9l3749/OD557h+/TJ333sXP/eXfo6vfu2rxM11XvrDb3Dy5HFWlpZoNTfQRtvWdp4zPL6dzdW2Cw4eYVhlYnycY0cPM9So8Pu/99votA0o/MC38rXSY9voCBPbxxkeHuSFF35glSY8gfCMdRoV1t00S20lLPTt9a+d0kQ3iwkrEdVqFYEhz7NS51toC9x8L7C69rlNPLS2sqcqzRgZ387Hn3qG1954k/Vml8PH72Pbrv10c4+NjiaqD9Jpd4lbLVbnZ9m7c4JGNcQTOZ/6xDPMzC7w9Cc+x6l33uWb3/gGWbzO+GgdQcap02/zZ//cn2O92ebqjVtE1TrzSyv4UZWPfOxJOp2Ue+++jz37DxFLj0z4GM/HeFaG2C4gVrFFOrk8IQo1JuHmANywtjS92QFhP6sddUoKzy4g2pSLjYe0wN2Vgo0QTg/cBfQA4tgC5PKaVwadKfK4Q2dzDRW3ef6732bn+BAr89NcuXSWhbnb1Ko+tapPJRQYnXP75lVUniExloKBDb12YdakeYZ1Z7KmS9V6lSTtolJljfWUBUZCgO9LKtUqcW4YGhqgEkiWl5fIlcDIKloOsOuuR/nzf+3vMrznMEKGrqNiSt+dLFNI36MkD+piEP6OgF52VHtV6uJ+jGPVc4fFnhMpBbmyC37ZJ7gj5nh3xI2iMNKrekG/3G4/0Hi/we8fFvt61bT+TLkPmPT/W/Sode/X5cClILZYktPf17AmYsIt2rih1/5hcLut4jUh+mrj7z0cW7/XHZr39iPc7+plcH37f8e2zXtP75aj9p596D/u9u/FgPl7l3zB1hcMWiir/iOw3Wz3opQewghCzzBUhRef/S7/xz//V3h5l89+8im+/4PvopRibmGJ3XsP8vmf+JP8iT/zMxgPOil0k9wlj9CJE9Jc40chm60mSina7Tan3nyDhx98gNnbt/nud75DlmX8T//oH7G6tMzE6BD/5Td+g6cf/zBXL57hN3/tl6lVIs6eeQutc4TnsXffXtZWVnn88cf5c1/6EpcuXuHdd9/ld3/vd7HdSV0mUfV6nSNHjjA3N8PKysqW5LX4vZ4fkMWxnb1y4K/o6BVqSFL4vS6g1jZmB4FNxkzufBrs+Sv8Z4oBcykleZ5Sr9ep14cwSjAxsYNtE+O8feotukkbYzKMVLa44ICnlB6VSpUkyUBbeqcxFjQIYY3ajFF84qmnefbZ75AmSXlt4OhANh5b1/eSPkRv3q24ymSfI7bn2WH2KIrY2NgofSdUmtrKkOskB2Fkk0xXH8ry3AFqS5EswIGUEqWtX5YnJEEfuCi6q55nTccKZ26ttav+2/VheHiEzc1NkjhGYkGIUYYgisgSCxpGR0cJgsCaB3dbDpj06FtlFcZ1tzDOkNH9/nKA3X4ArWxRSWW93KzYTtnlKK4HKfGDoM/rw+53rVaztD6MpV5h8ANL98qypLxWtNZu/s7N25mioCF7g/dKI4rvcnQ54RZbOxdqRUCCICi9QbSmHMQvBumllIyMjLCytOQKP73iTjkn5rolxWB7EYtK1/a++NQ/pleaV6603hOF3hOVflSgIXbsdxJ5dhGrVEKiSsjmxpq1QA8FwpOkee6GaXx84ZN2M6KgRpZqjBfx83/9/8YjTzyFX62zuLzM4uIib73+Bs9+7avopAs64emnP8Yjjz7MpcuXWV1d4+btadpJyic/9Uluz86hheT4ybvZs28/X/v93+fyO++QttYJAzA6Z3hkiL379jIyuo1mO+aNU6eZ3H+Yxx7/GLPzC+zdf4Cf+bmfI04y4jjmP//Gb3Hh3XOsLS8SBh6Tu3axfcd2XnrpBZqbbX72L/48X/zxL5AbnziD3EgyQHmOq24MwpNlqe6HLraYclH7IKDBBwANc8d7i0dPfrH/xNo/PYFF0Bh8aUFGIATkGcbYxCkMQ5Q2BIE9uetNhQh8UsvuIdPCDoG5BblIKNGKKPLIc8e7L65Llyi6+5DMUTo856CeKSvTFnqBPWbK1YqNYX1pmd//yn9hbmqKuLnB/MWz5FkXEXmIyCeKBLt2bmd26gZpq8W2sTGUVmR5RpqmdFtNRJrx4U9/mn17D/Ct3/8q682WlbgFKpUKH3/yCebmZliYn2N1dRmtNPValYGBOtWowsmTd3Hm9Ds0mxusrS6TqczJ40JUDfEleJ4dXou7HSTgezbJk0FA5tQ5JLaLUZgWKSeJBxJfSjCeld8VkizLSfOcer1Bt9W2HcMgJM8Mx+99iGMfepx3zt/iT/6Zn+PatRtsrm+wPD/DretXaG2uEnig04R/+E/+VzaaXWbnV7h2+TJXL5zBUwl3HT5EtRLxvedfgHqVv/TX/iYjIxNUawMMDI9hfJ9nv/d91ldWOX/xAn/n7/19RreNkxkrHakFiLBocRtX1XOLpBAEnofS5VNoDLnjlEop0SiSPLVOs5kq5xSKKregqEgL8HozUXYdNWRJRrUaIoC4nRAGAYFvF+K41WVpfprNhRl++Z/+fXYemGR1YQqVd6kP1AjCAC/0qIYBWdplduqGvVhx0sRoENbR3N4aCoyPMZZ6MDBQpd1ukadxGfitW7ZLmKWPFj5JkmAjAvh+BUxErEKG99/D//YvfhlVHSHFJgdK5Rit8TyBkL69L7QAk+GVC+Z7gYboTyRdt9Lz7lhT3SK2pbBdbML0SAMu/e6LMUXhXbjjc0ep/I6N/VcDjf6JkzuT6b4KfPFyyS+/A2gIB4aEMUiUzS+0MyPsSzbCMLRgwrdV7kLyXtvmJGmqUbjOgfD6OjBb9oxyGL74v/f7iVuofgWQ6AGN8rO9n/GBQGPLe+mdo3IItG/b7xG0Ej3aVJEi+JGjz2mND3Zo1yjCICDyBXmcMFTxSJprXDh9mtdfeI7f/fJ/pt3tgPT4hV/65zz9yU/SzTVXpxY5dPg4Rtpkphr6zM3OE1UrhNUKqxtNhreNst5qUqvV8BG8+L3vM9IY5P577yMMfYbqHi98/0Vmbl3jD//g95i+cZ2k3UToHD8QdNM2k3smmdy3l+npaVaWV0i6XSa2bePpJz/Ob/3WbxGGIUnStdVqyytBSkmlUqHdaoFLnEpuvtYYpRC+XybF/YP6vSNvUMolm7oA9b3EVMieNOuWAWZHqY2qEUblbJ+YYHXNzZVQ3JMGO59rUCIrv9MoLC0zqmG0BR1Jt1MmeTaxtUlgYciJ0agsLe8FnautqkzuohN9qlCgUcoKlmRZVm5bSqvc1e12kcInCAKSJHEFZWv4VvhAGKEpPMMK8GKMBQ9B6FGpVAiCoAQNxcxkeIeRXq4tFalI1oFycLow9i2ubyk9BgeHiOOYifEdBEHA6uoqrVbL5kVGoVSG8KzUcRCFVCoVMNj5myTBE84oUFkKbRiGBIGNu7nWVt3KFU8Lg9QtVC7di5tGuSF62bvfjNYIx1aQnmRgsEHg+yzOz+NHEYODDevfIZ3PiLt+inPmeRLf7aMFvhKtDUkcU6lUCMOQzc1NdzwTojBicGiExcVFjLGeJ4899mHOnTvPyvKKyzvsgjw8PMza2qq7fu8sUslSXRV0OYxvyhjVC0RCiNL7qv+1/6ZAY/TgXSRxB60VBoXvS2q1GiMjg9y4fgXpFjs/8O1ku6vw1isDpElGliuMF/HwR5+hqwTtTHPsxN1UqzXiTsK+XTvpbKxTr9oBmMXFeS5cPE8Y1bh+/Qb//F/8a86eO8fs/DxT09MsLi9Rrde4ce0KfpayOD2FEJpKJaBaifACnzRNqdUGqQ+OsPfgYRpDo8zOL3D75i3a6+vIoRHyJCFLEwLfJ+m0OXH8GE888VH27dvLN775Td584w08v8KHPvRhPvnJz3Do2F1E9UFiA5n0yF3F1bKPCiUlytZe/0lyL7hErHibee97XOus/9Fv2Hfn+++UtXVf45B6Tuj5FJQpiSHwBKEU+FIQ+JI0UQV7BWVAaYGMPOIUggjizDaltCk2bCsloSfJlSJNM6sMIW25oxgoT5WV+SuNoY39L/Qp23BJ18rXqSy3N7BSbCwtMj4yRNxaY3NlgZmb15m+fZ3rVy9y6dw7+IGVrpvYtg2M4EOPPsyefXvZbDU5deoU58+dw5eea9vaABZGEX4YkOWK0W2jzM3O88RHn0AIweLiAtM3rrM8Mw2eh+8ZJvfu4fata7Y6g0Z6As+3A1laa8LIL9VHPK/H1ZW+JDeKwPPwPemGxnsVErvIQdxNyDLtBt+k1RoXAs8TZGlmwaDwSA34tUEOHLuPz/34n+bYyYdIM6ta9Sv/8T/ie5BnXWZnpnjgwQeJk5yf+Mk/yfWbU3z3j77NxvICgc5J2i3idov/5Rd+kdrYKG+dPse3v/aHnLjvIR58/GPMr6wTxylXr1zhypUr7Ni1i/sffIC9B/YzPDpKfbCBljYpM9pVAYWt9BSt4DTN8QPfdsU8iZE9Te4isxVSksWW4uC5gbWCbqB00Q2xcw5ldbhYcDVkSYzOMqIocmAP4k6HS+fPcOP8O/zga78F8RomaVGr+NQbdUQQIj2fer1Ka3ON9ZVF651DAWhyhLQGTdpoVG5A+wjsQlivVujGLdKupYf4rlro+ucI3+fE3ffxzjtnqIS+7UhoidIBBAPsPfEo//d//M9IvUGUFyE929EQ7vdluULLwl3WIHTBey7ggLvfzZ2V+SLxdtQ803P9LhJiU1TkysjjnmMryLgzrpg+oFFyps3Wf98Zh/rf837btIDufV/GrX3uvVu364k+jrcogAau8KVIum0OH2xwe6ZFkgj8ILSylaYYgC8qgQ6IFR5GjpNdwgj33vcOX/ci+fsNZpfvuRM83QEG3vvZD1563+97it7y+237PZ8rQZNBGWW7hoJyDfDcbNo3v/o1vvX1byDSLrrTYmVmikYtYnbqBnfd+wCf+rHPcezEvQyOjFEfGmZ4bNwqyxnbedOZIu4mKGMTUC0E3TylMlC3t26uiDeaXDjzLptr6xw9eoR/+j//Iya3jXDp7NvoJCGL21ahzwOtUx7+8KO8/PrLbNtuvT021zbptKwfRhQGZEmKUplLkgtqSG/mKEtTpOeV/gbS680AFJXbwhW8eH7rfIB0n/XLwSc/CKhUq7Q31/jwxz7GxYsXaTQabGxs0G630Uqjc01YCUjjLmGlQpZpjIbDR46w/+ABnn/hB3i+ROscIy2gMQaisEIUVthY38APo/L+e+C+e1hZWebWrVtElQp79+/j0vnz7l5wvhfaAhxPWu9nO1BtqZfS90EUxRTjwHfFSfoGZcdHClmCq+K/PM9tjHbrkn2jpTDh3KILadoenlauo5P3tu1AjIfdZpok+EFgWQJ3SNomnQ5GSnbu2EkQhk4lrGAEGOujQc9ALstS0izBqmdBfWColDo2uOQfQbVapRLY372xvk6apj3w6GKwEcIO3SuFwc3daDuTWYAOY4xT9Sria6/rhe+XFVjpWbDRbzYIVrDAUqh6dLEsy0iS1LIdpN+L38a4Tocsj6nneWSplcQV0sOTPkNDQzQaDXuNOBpfluaoXPXWzT4wV3ioFLTDoiBRAI2eY3svDvZ3q4pksz/OZ6vt941h/Y8feUbD0ymVQBBnCq1z8lzTbHZpt1dLvXxhgLyQpbTDnWkW24NuFKnqcuzoXvYfPUmcGdY327z+xtt86Ut/geef/wF7JncxPjbM5voqKxsbXLt1mx079yD8iN/9/a+xvraG7/m0VtaRScpdJ4+yNHWZJ59+km9/69uMjQzTbrdZW1uludEkCip8+ulP004Sbt2e4eDeQ0yMjVMNIi5duMD46BjtVotbM1NkcRM/CLh++V0Wpq9RqdVoNlsM1quMj+/k1As/4OrFSzz8+BN89KlPcPCuE6jMnnylFaXmtnDdiP7iWNnG62tBFX9uARC9ofHys648JegNjL7nUWKYO1cdEL5XzltojaOL2FkMqUEq27bQRrvl1FZxs1yhgCzpPS+FbXdKYfmBnucjpEb6BmMyhFYgJMIIMqUJPN8ucsKic4zl1avEBnlpoN3qMDV1m5WlJdqtTTA5k9snmJu7yd7JCdZaa9ycuwFkHDp6mLAiWV9dwvdDnn7mU5x65wyXbk1z+uJFhgYbfOKzn+WTn/k0r778CqffPs3+PXsZ2zZBkmV0koTt23dw4dIVwtoIH/7oJ9m1axdXrlxh6tZNNlaXOXvmbWYuvcvMrZtooxFoAt+2h3We4DlaRtqJ2TYxztDQMHEck+c5jUaD2dk5PGPwDKCs+ZM2GmNU2ekzBirVGkFF9zxbnBxRksYMjg4QyoAsU1QQpEbR2lhgfXmG5/5oltXVNrXaIHt2bKfdbrG4uIlWhgvnznPw4GG+/Ju/yZPPPIUkxeiEyT2T3HXsCCZLmJ29zu/+m3/B2vIaew4dR4icd0+/SVfBw489TqUS8qFHHuHG1C3WWy2GW23Gtm93yi2gjZWm3Gy1aLda1rgqzQn8ACk9wjCg3mjg+z5BGBBEAVHgI0Rh0oddRISVjyyH7oqORknrKBJjg5QCo3I8Y/XIZ+cWmJiYwPfrLCwvcfbMaTqtVT7/hU9z693nmbqwgJE5RiuyRBIFAb5nr9s8TZFosjyz16oXgLBa9Lmy0ofCiJKHLSTkaW7b177v1Fd6fH2lrDHW5fOXsPQxaZ1hPY9aWCOojbA0P4fOYoSsU/GcWKY2GGGs4aVnr6ncXTOlUMOd97RwI+juKTsPI8p/dNq28miELitrtsPRz/V32y6LE0WJvj929Ak53FHR2hJePjDp7n+9+KK+gkr///dymJ6fT/GCsee+PB6lv49w+2hnoBr1GlkiGR+r0+4YkqToANsue57ZVmvh3VNswnNDmdbF1z1p7jjk7v9KsPXBv7YvuG+N4SUooHcotnYw+heL3rcU7+kjhfW2WtAethwyseVPDLazLCxZSgLSCJwNJXmS8+ijj7JzfJxr5y9w7cI5sm7C/O3bDE3sJ2iM4VdH0bJGrT5GozFInimCwKr+5doq59SkXyYoSkBUrRDnKWtLK8zdvs2B3Xt55IEHCDzDyHCF//kf/AO2Dw9w4/J5/uibX+fWjSv40rBr5wTbt2/jG9/8Op7O6aytWw55rpz/kqTRaLCer1vviDAgzRQ9/nlBO7TV4tRVr+3hMmU1Wrl/97tZS1kY80GS5AhPWFqlb5kKuVJ04xi/UuHs2bMoldHttvGdmVuiU/wwYHhkhLU1Ta7ysik4NzdDq9MiCAOyzLqRGyXwpc+HH3sczwt5/gfPg5Lo3FJOpYTLly9a5Sw0SdplfnEOPwqoVqq0WpsY5/qNtt/nLlSEb9dprVWZC4MpjfiCIMCa4GqrgCRAiN48BzrjyLFj5HlGp9shzzLW1tdK0CGl50RijFNbKpC0cf4bhigKKeZDbSVcMjQ4Qtrp2mgjinnPvFSZagwOYYBuHNNstbYAoVzlSCFJ0tgKzrjvF1JScTKySEjSrs3FimRda9I4pumKRlrZoe2StmVvEjzpOdACW6S6PXt/+thrPKiEve6WEI66ZAFZmiS97y3u4UJcxHXX7gS1HpJaVHGSwk51q7gmXeFJa2NBXp6461UgjaFSjdg1uZOL588jpCHutsBAGFUI/JA0iRkeGmZwaIjbM9O2u+uAtud5KGNncrSyQgMFUN/qZ1LE6L716EdqTWx9/MhAQ4gcrTJ8z6CckIEAcpXZSrQIMArwJL4XIhDkxk7dG09gjFUGOnP6Da7dvM72nXs5fuJebly5wDe+9nvkeU6t4nH27ddYXlokU4q9e/eysLjK0ePHWF5Zormxiclysm6HNG7x5vefpdNc4/LFixw8eIiFhUV27d7Hhx55nG435sUfvMDGRovJyUnePXOBXdu3s9npWBOfLKfbbLG6tMRAo0JluMqunTsYHR4kTWPmFxao1wIGhgbZ2Fih1W1TyVNGRobZvn2iRIzayYcVleoe/8AunluW8K05w5bHe85df7LxAe9839fvQDLaGKuE4PbLOCNAZWzl1HOqCbaarEHosg0oPVEGAV/ailqaJiwuL3Hrxg2eeeoJjPFY727SarUQ0qPRGKBaq2G6yg5ZA1me2S6j9Oy3+9ImmBoa1Qq7d06wbWSAbrtJt7PJjm0jrK8s0Goucu3qWS5fOk3S7RD5Pt12C6Vydu4apT40xF333s3Zc2dZXZwlrITUahVeffUVbl6/igwk23dO0E0yhO+zb9ck9cYQR2VE3E24OT3Pm2+eQRnD/gMHeeTDH2PfocP81q+ss7k6S1gJHIDPwCg8J9eplWFifIJunLCSLpOlmavIWGqNzh39xhLryvauNgZyC8a0sW7zBQXHVloVQhhynULuZPmErWxvrC3y/HPforOZMLJ9D3ff/SAnTh7j2rXrrC7OMlirUK1VEEohheadt95gdWWRzc01btzqkudN9uzYwTvvvIaOW6wtz7L34AE67TUiKdh76Lg1udy9G4NkcNsYudbUBwbc8LSLodouWNWogic96tW6G6TrGTVVq9Wy3e97ttKGEwvodrvEWUzuZAwxBl/6RFHFDsh7AY5ST9FAE0bjYZx8reHimVMsjW1j+85JwkqF/bt3MDPV5tk/+gary3OWSpQbVKbQXo4vbAcMpTAqczLDVt7Rc104g+vMuO6kdjobxmiyLCUIrcqWcR47WhtXKLeuwHEc40kfT/oYowmjkDAKCUKfhx/9CPUoZLG5wVAYMTc3hxd4DI4OI8MAIyUp9rvtfGURzPtT8uLm7ku1jXHmUgLfd4orWWo7fp6P0C4+yf4MvggPd4AG+V4Vu61GfX9M3PnA1xwo6Fus+nFHSQsqzE7pi41lhfWOxa7v8570kMDmZoYRhlrNo1aTrG/YY1Mq3gixBW7ZAXHIlR0mLq6DOyo/7zlWBQB7n1/e2/cSy2wFaWXnWWw9v1vfa1f2O79j63E1W/wL7nxsVZGxAM4an9oikxT2Ws7znIHGCPecvIfO2iY3r1xjcGSCBx54hPEd29m9/yAHDh+m1hgirNUxxsfkGiUMSdzF90Pnh+PZGSttlQIDT9Jpttk5OkKQZow2GowMDBCFHsakVH3BzrERokMHeH2wwb0/9jmazVXOnTvD9HSHbqeJJyWVICDNMkyeU40qVGp2gFtKCdLbovBTJEnF3IFNeLeCL4EVbun/jHFgVrqBqV7iLFwM0i7XcbMInkdzYwPpS+p1G/uUsoPWvhcQx7EVGpAeIpD4nkeuFatrK+AGsaWUqNwQVqsIfFSmyVMrj6uzDBl6jiJVKCrZXlar1UJrxfj2CTpJB53hmqoaIyyvf2RkmKNHj3L12nXW1zdQjq4khFfKx2qtGR4aKguASlk1pCyzc4dGSFZXVtFYfw5jLD2xmLHrz01s0mwLMgUNqlBZKl7XWpMrRafTAZdPGJfoVypVwjBkY2PDdiF1r6reb/SnkgQvigDKboE7ieX5zbOMTNl5LZuLmTKWakcZ026tKmjsOLDiBbg8VhQlfoS0QMCCUAs0PDc0DbaLZM2HNeRWXSpNMwT2WEgprS+a1uSZIsvTspvWT70zhYyuK4PI8trEUa2yosrM5ORukiSh1W6jjWZpeYkkTZjYvp08y2i1WpaSJj2MCYiikPW11fI4Fv9pZ6TYfx/0QHdPireXwfbP2H1ArPkhjx8ZaGjPkGe5pTVYUiGB8BisD7Br1ySr65tsrDXJ0xytbfXbtjrs4Ivne+DBpYtniVPNvv1HGGzUSTrrPP+9b3Po4EHS9hrXL18mTmLGJsZpjIzi+6BUQrO5ytrKCnk3phL4SJMzNzfD3iOHuHblOhM797C4sM6hQ3dz7wOPIaRkanqR0+9eYLPZxmjDxXPnWFxfY2Nzne07d9DZbBFWIvwK7NmzE5MkqCwlikKGhweZXZhn955Jzpw+z1333s2+A0c5ceIE28a3sdFJyZRG+RAUSggUS0d/9a4Yx9pa5ep/h/NSKdMIuy5ubeH/0BNavtRrYxafKccIRaHgYBPXYgi30Ko12DaiEW4axDiRNeEWa21VS7JOk7mpG6huizdefp5GvUG73WRtbY16vcHBg4eoerC+vEyaW9niPXv3U6nVsHrQ2EDg9tOLJEM7tiHQzNy+wVsXr7AxB831BZrrS9y6don15Wm6nY5NHIxgbNs2hoYHOHvuNAODg3Q7TbI0ptna4MyZU5w9fYpGNWJto8Pi0iytTszQyBhRuIs8TwmDkLW1TZTwIIjwvRC/NogSEZvtjPse+QivPv8tjOoghXTGivYEKaVsRUVIhPTJVI52SUyr08YLA6vkpcE4oFF0qgq5PTxQeYLwPdvKlALhFS1uRaK7pI4aYARoIci1YermZepRg2qnikeH+elrtDaW0EkT1d1kYs92up11dk3uZaPZIs8ylM5YXdlgfek27f17uXHtKju27WB0qMHa0jztNGf3ITson+UZ9aFBklwzNjRkh8MEYATKDRVrbZPaMKxSqVQBWwWL47h0lPXD0CbNDiTpvnmOIskUphAssIu8LyyVr/e6Ic9S0iQmz1LyuItJu1Q9nyvn3+WWH7Bn7wEOHj7M6Mgg787d5tXn/4jBakiCIYyqmFxhtJPGVcYOYAosdcE4EKhyWxsvCwbCFQ/sfaCdu65nQoT07KyPbcdQVAlNnmMKkFJWrewAYE6LPEvYXF8GU0clXVYWZqk16gyPDCCET44hL6SOEX15qCmPf//NXsT/NE1YW11lx44dtirnCbrdlDTV+NKzktGVkDKyFMm6sYl9AeTK6CH6PTd6Vfat8OaHP+xXvE86/kHJe1kx2/re/o6OueO1YseNMRgpyHNDZgxKGzzPEEY4czIndoHAGGnFGQ2u0KKRWrqKJngumTTu2iuXV5d3lOfkh1WL+o/Bnf82fRWoO+L01s31pL97Kld9nW7xQYS3rY8t64UWVsjC7YbSwoot5NDabLK+NMfVKzdYXFgljOrcdfJ+/EqFu+59iKjRQOORGEGeQSg9hIIsgyB06l0ARiCMtAknhmsXrrBjdAiTK2Y3btIZqCOE5tKlc7Q317j17luorEut5iM8w9rGOjenpog7TbQRVtlIF0miZmjbIOM7dnD23bO2I5o7v4wS4Ile16KItdKj8I4paCy4Sm1vPqOgKery2EunBmkLK9BoDBBFFTZbmy45M2XCmqUpCEFYscXVbreLlYK1CbHnBBoylduiiu9hjBvaNYKpm7dRuS26Cc/OOyiVEwQe9XrNFmbi2CXedq6r242xVXs3w4Tt3AlhXc3tvrvfXsqpuc6dsr4jllJsq+9G2fmVItmNogrrG+tYANGXXBb0mfJ6FRZU+LJktdh42Ztjse+3IM2yP5wXlnZD6W6/atWa7Vr0dQuKZB1jMMX8gxvk3qIIpVW5f3aWohCvsM9pbem+eZahnTR5f2yTxmBwqK141lXW7K+XrmpswU/gW/EYlSvibmzjvrGD21mmyt9dSPkqbSlS2tiChnEiKLmx8xCunWptEVwXrH8f7QC96yZ5Ej/w8QMPrSyAjSqR7V6n2h0zQWHmF8ddp6Rq6d22SNbnI1LcO45ZgejLDd83rhRH7UcHGfBf5Qyeojy785lWmCy3w7FhlcOHj3P16nXidk6WdsiccRlCYDyJEIowCslUjtEJnhCsLs/y8ovfI/QUWTdm6uoF2mOjVELJ0NAIYSRpNVc4eGCS8+ffQWeK1sY6g/UaQaOO9Hx27J7k5Ml7aTbfYnVlkz2TB9mz9zCV+jBpnrP/yHG+/uUvc/PWFCeOH+XVV17Bq0bs3L+fHbt2cePqDQ4OHWZ+7iYjQ0O8+fKLNJsbjG4bY2hkiKWlRRqDdXbv3c399z/C5OQBtu+YIE1ilpZWqY+NWo65BJ1ZPwnpjOb6l5USoYoCs5ZA3A5ZmzKV3VqhMncW2PrhSe+FrTzdslSIFD1lm/LJ8iK26CbNM5K4S7VaJQx8hFMHSuMu6xtr1OoV8jSj4gcIo1mZm+XWpXMc3L+Xr/zmbzBYr1MfqNHpdhgeGqa7vsLQ8DCrzRYgOXXmLJ/+7OfYd+AgQVTB+i54eIG9CeN2jEozNtdXOPvG83ztd34DozqYvEOabBL6gkoUUqsIslSjtWB0pIHnw6uvPs/g4CCbGxvEnQ5ZvMnLL6zjScGJu+/l5s2rXLjwDtVaAyFybk95eCIi0T55Bvfcew/j23exsdFhaXmFc5cuc/rsOX7yC5/i1Bsv0NloIx2nwxNWbYpQ0E1SlpeWGR2fIKqPID1BnCZsrK+TxAnCaKtOBD0/kQK7FVeAtgPkaZYBxgbrYmJA57aKHwRu0NFgyPFDzdC2AZob81y7cobrV29Tqw6QpzEbayuku8dZWFzm4KF9HD3+EItL8/hejlAhycYKM9O38DDMTN1g3/4jKJWTJzESrEyf1lQrEZVKzSJfV7nSGKd+4oMSVvlROXdVoUmylI1WC7/g83oevrRBTRrHU8VWUytRxQ5MumOAMU5X3VKnnBk6AHmaEXc6JN027fVVFm/fYs/2CZZnpmg3m3h5yo7hAWR3g3de/j7dlQXuuvcIyzevUKkPgG9I0xyUQeUpUVAh8L2+6o1G6ww3TILnBaDz3qA7RZvbUgKEtIN7Wln5Zgs+BdJYFTJP+GQqQXrWEFHIFBForlw6x5uvv8S9Dz7J9YvvcuvyBXbu3s3OndvwA2GHGBXgeUiEU4kyqP6Fz6bBvfggII47XL92hcGBOsODQ2RZSntjHeXUQnzfY3LP7tIF1yYnlGX5/up7GSH6v7NYVNz7RJnWvHeR+eDu63sXI+EkwHurfQGo+izr+oKacuBqq3+fSyiUHeiWnlWU2dg0CE/j+bIUocAUd5YoLjkMEi3skLjA5RUGyl6CPbUldcDuU//U3dZDV+6aMb0XilPVB6bM1pe2bKzEIn3Asr+IKBwK763177+1XvenlxDkygGo3JArjcytQuTyygbvvnOBa9emgYDx8R2srrfopOvsuStF5l2QPp6UhJ6k6kl8qckBL03JU+2Om+vYCIOUiltXbrBeqzLcqHDt8nmrjOdrXn31Be46eohXnnuWbrvJY49/hO8//z2u37xBp90mT2KE52OER6tpZ6KCMKQxMEC9XnPJEPY3OCfqAiAW5mo6zxCe5bCb8iCKUsAjy7Kyqm2r+ra7Kv07i222qt0YbNBoDLC+uY7KMrzAR+U5LWfqF4QRRmsylTmJUKsCJKRVj5IeTnXRAgyVG2qVAbQSrCyvYjTUa3XSPMaQobOYqD5oi5Rao3JLu7VrNszcnrESqwUwduddSo/NzSZvv30Kzw/tgHqRJwhDEEQoZS/sZtPSbJTjs/rSo16v025uEkYROlZlB6MwipOeBS+G3jyM5/uEkQ8Y51ei0bkqgUIBFnwvoFKpEMcJnW7HAgIjSLoxaWyNDJutDCEleeZUGh2dDQMisgBEudit8tyCBCGQ6F5kMlvFErSxa1VB5Ufj6N/2XOvisGorXW89QHS5ZmttyI1d/4oOQDQ4aL3cVEIaJ66DVphDelDMeJhi2NoeZ0vdctR1JyUMlHOK2g2xCvtkDxR70gr2KMXyylJ5TIWQ6ExRqVXYbG6QNFv4kVUHy3JNnqc0m2mPXuuOi1Y5BmNnZYSws7JxbAWNRNGt11tifD+tqrgmzJYY9MMfPzLQaDU3CKtVp+RhLxKMZHFxia997evk7iQGQVQmJ5bzp4EcFVpEGkUR0vPJ84TrV8+TdDMmJnaxtLDAjm1D1KoRrc4m3bbm4OHDnDhxlLNvvcrm+gag2bt7PyrLmZ2dZ9fkXlqtDvfe/wB7DxzmU5/5DIPDY5y7eInvfu+7XLp0kUqtAnlGt9PmqU88xb0PPUSz2+X1N99k2/g29u/dw7bhKteuXkB4gqHhIUAzNzuD70tee+VlPvdjX2RpaYHBgWF0HrMwN8VLz7/Gn/2LP0MnNWSpohraxN1yzt2AlgAp7QWnRW+h08ZqctvFrldV2UJwMIDoDfHQX21EIIW9YIULQMKYkh6F0M4UzJEFCoBvoBgw8jyPVCniVpOzZ85y5PAhtm8fJ89T1leXWF9b4uVXXuDE8WMszM1w/OgRjMp54/XXeeO113ne5Aw2Bjhz/i0GR4eJKhVuJAnf/843Mdrw+FNP8olPfpqvXDzF1zurfOzJpzly9CgIDz8K0doQiACdJly48C6vvfIi58++Td5ZIgo0gZ8j8gRfCoxKbZJrNFk3pdVaY+HsHFEgWV+bB6WJAoMUmixuojy4eP4dhLBqFybvMjt1nZtXrlATIZ/4qT/Nz/zsX2J5bZP5mSlGRscZG6rRHW7w1//qz5N21hHGBgZhLMezEoVs225lCqembzNze4qFmVl2799LbWgAldvqu+dJl4TrvmTKLvrWr87K1gl8kk4CwraapQYprUtop90mNza5rdUqaGHousr+zWubGCNZnJ1GmMgqowiDH0jeeftlut2Mhx68n3tPHuXqpXM0KlCvhxiV8v3vfJvJ8e1s6k2WFpf4qT/zM4xs34OsDrJ92yhefZAuEpVnBAKEkRjnvlS0UQUOZGQ5ubat9Xa7zfLyEn4lYnh4mCRNCep1PK+QELScUmUsPxZl6QoWXYuygFQsmoEnyI2hWq3SqEZ4ephksMaVU6/w8F37yJoLxGvrHNn9UR657zDnz51l8foFyDuceWuNNI1pakMUVgjDCJVlZCpjcKjuQA8l2BC4RNANuOdYKoF0fO2C1W+pGJIwrCDcDaWVkyHELTBa2y6Oyp3OvGJ0ZJyf+vHP8x9+/b+wa9chfvWXf4WV6ds89NjDDDY89h49hgiqBCZCCB/jaAWmOHJFZ6EoELj9lTZLoLmxwVtvvMann3mKrNvk8runOXToENLzuD09y+SOCQLPI85Sa0rV5wBhiuRlC2WqL0Gl+P2iF5KMcU7wfR8pN7b10evi9rKh3ncXqUFfYt/7EorqcvE/4ZBRfw5vdQJs2VkYN8RYZA+5duIVzgneDVUWohoFbUTrguJ6h/Gf2wxF0l4m/L3kvgd+RPk7jRA9wzJRDOn3/b5i33sYC2T/cemJiAgjyq99z9A3lOtw/+kovrMAp25PyZLUSog6F+sksXzven2QD3/k4xzZfwSynCgIeOOtN9gxuYdOJ0fkMaljlERSEBiDSrvYSQcFytJiAzfDZXSOLyVPfuQRhqoVKj7MXD7D1fMXGR0d5CMfepD1tWX2797Nd777LV552VBp1BgdHSaKArIsZ3hohJmp24AiTXMO7N1DnCS8/PJL+JWAXGdIvzhfjvKmDAaJLwW51IRhhBCSJE5cRRu0LjjuEkSPlkNReDM2WfalGxLHdq7X19bZ3HSFFAcsulnbJrWOpmU7G+D5dsha+naOQTnZ2yD0yU1OEqd4XkAQVhgYGGFwYIRqtYHKc6ZnbjIzc8Ou0dKn2WyTpKldr921i7QO1mVMdnkACLTOy66ydkPDxUMKH5sA5wjpu/dbIBJENUZGRti7dy+nz5yi0+3auTjj1isHGnzfIy+HhV1RQulSzl5I8D3figUUMrZA3I3xhKS12SQMQoR2tChcki0lG+sbZFlGVvy2siDbE1EByvmMkhLpirppkjrFpOJU6pKe7bnzKdypL2cQjMag3T1q7DxGabYsSnqVMcZ2fJQVOWlubKKUlTiOogiVZhhtJd91ppwEsKCgf3nYLpZSirzfx8M9tFZlt8E53JbxVEp73H3fJwyCcuaopEEBWZLa+ZFqFSGsuWPuaHCetII9SDenJSVC2IJgrVEvh8K1dmIO5fk1/bUKHCQjCKK+gX/t/KX++MePrDo1fnQvcRz3JvZdG87kirvuvof5+XlWltecEoFVnwrDkCxLSNOYqGLl0/qHTOwFYCvcGMmTTz7JuXPnaTabBEHA+vo627dv55577mF66jZXr1y2yEt4hJU6I2M72bZjF3/jb/0tvv/Ci2gMu3btJokTTr31Fq+++CKBEORZysGDBxkaHWF+YZHNVpvGwCBhGDI6PER7c4XrF8/yhZ/6CdI85ezZ08xMzzA8Nsr6+iaf/cznuXDhMj//83+NsW07SHPD0RMnqA6P0okTKvWIRs2gE0Eea1SaIz3DyGBEJYJ224KLOFW0uintNCMXklz4CC+gm+Z2oMi1Ei2XEsIgJMkVmdF4bqDWuAXVc0PXaAiFQOUFb9Al3HkHKaycocBy0a3CoQHhg5EEUYTWhn/5L/8lO3dsZ9vYCDeuXuQPvvyfCSOJ7+eQp2RZlzxP8EOfar1mpeGiiG435ulnnuHylSvcunWLwA8YH58gjlOOHDmClJJ6vcGbb77F/NycVQORHtXhEer1Ojo3TIyPMT87S7u1jhQZkW8QJkPrhFylZRVAObpSEETg2eHNQFhQm+eppdfkKcZoAjs9iucFZGmOMZ47nnWOHbubjz7xFL/667/F7j37uD0zR2ttnWPHjvLhxz/Cwuw0r7z0fbqtVbKkg8CKH4yPj3PvvfcyMjLKs9/7Hmvrq6g8BZXTGGwQVALanZargtob1XNcUVvtE3YwXGOrYmHFyd1aUx8vsC3PgcG6lRLspnS7bYQ0ZcKeKGXvF+wwn+f7ZLl26jmCMKqgckPSSqgMbGN0dIzjx48xNDzAzRvXeOftU9SqDbIsJ+tmHLvnfj77xZ/mwUcfJxceiZEoGfHO+QskseL4XScYHBpGGYMXBHZh1oY06ZIlKXG3w+rKCiurqwjf45777iOq1fGiwCZbLqsT2PZ0EbS0tlQxIzRG2OFrr6AbSMgoqskak8a0lxZ4982X+cOv/iYTAz43L50n7bb57I99nmN3neSPvvWHnD/1Jl7oI6V2HjGGwI+oVutUohrKaJROSbM27daGpU9pg1E413EPgyqtKqzvhykDvnAdl8HBYZTTKFfOfdYYRRBEZFlG6Pm242vlyECEmCSEgQn+7a//Fl/7+td448XnWJ69zf79+3nqx36Ssxdv8pf/h39I7ldIBRZsOJNIKUVZ4DbKylgaleMJQRp3ePfdd/jKl3+bf/1Lv8DZs2f47h99h5Mn72H/oSMoIRmfmGB0ZIivfu0bPPOZLxDVaiUv21Y5fdJUbwEDtsxvK5faOCcd0Q8O3OJBrzhSrCLFGmrVxixV0h45O/9lq7AeGL9M3osKfNH9KzZeXgN2pSppMAW1SOKAT2FsJwRI605vK4i+7eYYu2AX3Opins7zIMuMK2aUNGi7LctsIVPgh9Y8q0AMxtiEREqBh/1pEleEdHOouYEwtBQjY6zSnvP8RBr73jCEJLEH0Q/ASDszkiq76MuyK2hPSdmd1uBLW9UXTnv/Tqot2GFbKWzyXcR+rRU6z2ylNk2twVuaW+68o/9Vq1WWV1dR0ibbnucRRIFV0ROaii+RxipAVcOAKPQIPUHoQTUSDNd9AiCS0Ki4inEOL7/0Gv/rL/win//8j3H61Ft87eu/x8///M/z9Cee5PrNa/z27/wOt2/f5td/7Tf48S/8OHGc2vvUHWDhC/CLRmgxLwdG22HdQPpgFHnW5Yuf/wJTU9NcvHCZTpwgg8CZ7Bo3n2Xn4Yy2uUytVmFouMby8jKH9h/k8qWraNflrNUHGBkdY9u2bUjf480330SnWQkQC/NiIUApg1+JSOIEshzh+Ta+u4FhI8AIj1xJ/KDCyZP38eijj3PkyGGWFub41//qn9PaXOHk3ceZm5sljrtlwor73VmeEYVR2Zkpcq4iSbzzejDGIPEctUfbTo0yhNUa0rNyv6Ojo9QHanZwvbXJ4MiQpX/mabkNz7NEcLsm+RTUM+0MAYuHLKOE6ypojcp0Kalb7Fe1WrW/o5Cm73bdcPsdtQ/6fLwMW3+btmCheF/h+1HGCOP2yK3LhYJcT9DPgRjptiBEGSeKDkkvZpgtibjneVSr1d7cTWoBvDYW7fRLbffu52IbLhb5vs39hFUzDMOwlL01xpT5djHXEUVVdx4zOp0OaZpiHAXAqpiZ95z74pirPLeeML6PkIKsNDLUZRGmPKd6q4mf/TsEfuhiaa+73l5Y5o97/MhAozG5rUS29kdpsiwniiL+6l/96/zyL/8y3W63VB2wNveaILBttXq9jucLqlFEp92h3W5TVHvtII8uuyEUiZm7Yb785S8zMjzIv/k3/4a7776b1dV1vvf9F8iNz8zCMo9//GMsLC9w6tTbCCE4tP8A28cnePf0GZJOlyAI+LNf+vN89evf4PjxEzzxsY/jeT6/81/+C4vzs2wbrXPj5jXWlhcY3z5OY3CA1dUV0jhBabjv/odYWlrlv/uTf4b9+w7T6nTJtOGxjz5BqjRvvP46L734In/qp3+au44cJU0Si7wB3+sN4HhBiJEeuZTge2zG0E5ty9b3wShFnmbuJPrkGrSwQ2UaUNq4IVXbEgl9H6mhGoBOCxUagxSKRt2nWgGRgc4yKhWfatUanykFSysQdzW5UbSbHc6cPc1bb73OO2+9wdXzZ0CkQEotlEjPEFZDoloF6Qmnry7JtVWPqtQaCGFlBdPYKjdopayeOdZzIozsBZqlijS3ZkzVqEaSdGjUangStEoQZNQbVZrNDYxR+F7g2oaaJE5J89zy6LVBGEkQhGidW3UOownDkDxNbMfEC8B4aCXQStJoDHPo8FHefPsM+/cfZGV1jVarY2ljYWCBSpYghKa1voLRKUYrvMDH8wNXLUhta1lrsjQminyblGo7MCd8e8N6WL7mQGMQT/rE3YTWZgupDZ/58S/wR99+FiFcB80TdLodkiTB9z2iKAKdI4RxgV47+WBJnPYcqrXu8deLYAA+3WaXT3/mxzl9+hytTpvh0RG2jU8QBCFXLl9BCI+/9/f/IZcuX+PFF1/i+q3bjO2c5HNf/El+9w++yZ79h3jkI0+w98BhqrUB2t2YhZUlsjxHqZw0TpifnmH35C4GB+2w+K7J3dQHBxBBYLMgISjSxiIh7FVlBZ6P7R647MvTHr4QpMogPMiFPb7L01Ocful5vv0H/xndmSOSGdUAsqSLH0YEYYUsTWlvbrpMzgZmjIeUPlGlwdDgqI1bnmF5ZZ64vWEH/wxFq7HsXpii3FzQJygqh/YebjQadvZFKTuP4VrqURSRpikenqWaCVtdb9SHePzjn+PKtWm+9Jf/Cv/pP/06t69dJOk0qVbrDG/bzVps+N/++X+kMrYTFfoo4QZPsYm2NlZRZvrGTZYXFtm9YwcqT7hx7QrLS7NsGx3g2W98FZOlrM3OoboJT332x/gTf/Hn/3+0/XewZUl+3wd+MvOYa5+vV953V3vfPT1+BsBwBpgBMBAAQhQpUpRASqK4YgQp7YqxIUorSqvYDXmSCxIiKSFIAKQEQ7hxHD/T3TPT3lZXl/f1vLvuuMzcP3557r3VA6yGEdrbUd1d711z7jl5fvkzX8PNldscXl7mf/5H/5g/9blf4Pg992HiRij2hJgYpzHeenxQr/BKBCPqJN0gJMjKOybCuH4qofDU1ZAbb8wh8cKjvCQiMvlRgMF7jfdaknQt5bOi5lAQNr2wPhByZV5WAWsvr7NWZFrrhwcmxYR0EYtcpDHLUjr60u2rqKyltHZMGvaVpdaut4HD42yJieQeVFrhvPwRcQxNVZQ040jEBUonhVgkuvRlILKizDhpUEoTmUjEN4qSVjPFOyHvx7EmihUmUpjI0GgkKGWIoyDEoA1RnIqxo/O0Wy2qUqQq49hQQ7xAiK9JqsZKnDiBR9RFEqFpmsRgMzlxJpxAjxRgVSVJSqOlCPkhwWcN7SyNyGCARENsINKeJIZWqmhqT0RJ0yi0d8Ta8Ed/9AXOvnuOv/gXf5kkTfnUpz7F6XtO8ML3vsNjTzzKU888SZYN+M3f/E129wR2m8QNuTY+kJ2VxVGF7F7cm50FVzm01yQmJTWamXaDPMsoi0pU8jzC4fEerSJ0rCjKAR5PHDUQtbgKrTxpmpLnOWUhSZkJkLzaW0CgJ5YD+w+wsb4eHKgdeEcU1PRQimPHTvDg/Q9w7do1rl69Om6yRo2E0jrmF5Z56NHHMSbFWSFFe1vx5X/xW6Adyriwz1m8t+OLG0exSPdnOQcOHSTPM7a3NuV3cUxZVURGUZYF44mWEunWqnQ0m23+3J/7N9m/fIjNzW1e/MGLvPbqqySNhDg2VK4kioVzUtmKouYWmEgmGLhxs3NMBJ/KE6uqIo3iCeTL1hCcmrwt04g6PtSFkyTld3Mv6kAwgQz6MTqjnujVa4Gwx0hE0pOi203eT6aFtj6MsSdE/VGgxhAlMW5URCaSSUSIE61Wa1z0RVFEHCfEccJoNKIRi/Hhzt4uw9FonL8mSYKJozEiRQdY1OTEubsKBB+I2rVRYV3UlGWJKy0HDh0iMhE3rl/HRNHYoLE+x9Ok7loYYWlpidnZWW7fusUoy+Tnzo7P7dzcHMNsRJ7nKAWtVpNut8twOGQ0GgUYXIR3k6ZFHef/Ty00mgdng7aymKJ459FhYbQ7Mxw8cABjDDdv3hwTpkbZEB1FGBN0mY1IqtWLRNy0pdNUVRXNRntMHhr/cTA3N8fHP/Yx1jfWsdZx69Ztrly9hlIxRVWSxAk61iEwyMKcnZvjycef4KUXX2JzY5ul5f0MBhlx0ggBO+bIkWM89uSjuGrAb/7Gr5GXGUkSERlNpBTtVoe9vT6DrOTo0ZOUhSfPKo4dP8HPfv7nuO++B/nq17/K1uYmnU6Txx59nDP33sfi4j60NmOMonOONE0ZZYX4iegYZyIKDFlehQQ5opFoovD1owhUDDt92OnnVF6N21peKbQHmxekJkZVwqGIlEfZEuVLmg1NHHki52imCdaKqZCtKsqyYnZukSSJ0JEsmrKqePudc3z3u9/j0sVzHD68n/nZDpsbK6SNhCvXr/DOu++wsnqHzmyHqirRkWY4GhAFfwlqYIYTTGOaJmNnU21kalVUlqKytDtdoB77CclNQDZ2/HejRNa0lnTDMyZiY6QLUbvvTqsmgMBmlFU4q2RUiMF7SXDyosIT4R2URR4Cmgcr6lIYwOUCTwvStAKJMHLuzaQ7GsUm8JE8NXlXG8OJ4ydZXV0jH+UkUcLMzBydTpcrl68yN7fA3MIiVy5f5vDRI8wtLJAVOWurq2ysrhI1UuyoTxRLpyqwLbFBVjqOU6qqVkOpuzTSjVQqoiwsjz/2AfZ6wj0ZjDI6MzM89cwz/MzP/iy/+o/+ER/64Id44423uHjxEv3+EBM1SNMmjzz1LIeOnkTHTZyKiZIWOkkhibj3gftZ39jk3ntOozzEcYIx0XgTdBp0LLhoW4siq3rEjcCTqJM1UXbyoettnCQuznssFSqCfLjHy9/5Jr/1v/xDir1VmmmOdhlVnonxUkg2FFAEboysH4fzAmFrpC2WDxzFRIY41Vy+fAFXZhA01pXXQhAMKEWv6815krjVU6pmsznmP4yDObUbcEWel5KsWpGsJTIoHRFHbayL+PiP/QQ/+MH3GPZ35XrFDdLOIouHT/Nf/Hf/kCJqiGlfpIPPg3RdY+3QruLF73yb3tYmidHcun6N3e0NPvLhZ/hf/+df4fixQ2yurbK3s0MxGnHmwQd54KlneOWVl9ndXGc4LDj96NP85M/8IifufZi0M49HjjuKDTiLMuKyYEPc1QiMzdtAoJ86Kequf/kxJ2m8Iqe2lQlG2I1JtvX7eOsC4XNqUj8mwQcZbiPTWBWKQm9FnKCynt3+DnmZk2cFZVGMp5+2Eqy8FBYy8StK0eT3iNJMVhZhM1boUDQKUEyBK4n9gE6iKIsBoCl8jPOJTHtsSTHa49tf+wIL8zM8/tSztGcXcUQ4DErHwfBUoaMIp+puq5yhSHmcy2lFCldlrNy8QmJg39I8s902edbnzTde5+FHnqAzs4SK2ziVYFWCjlM8wqlKEoVWLnj5SNJnTIx1nkarRaxjwWR78QJKUkOSGPIio9Voob0mNkmYpgsROtIQxZqiLCmrCq1jjDYYPNgKnKUcDUkNNJOIbitFuQpcTivVLHYbNIxDVRm+KmjEMW+++Ra3b9/mwx/9BNpEDPZGoD3vnH2d777wbS5fvRC8s85ROVhc2ke/Nxx3oaXFZgNUwwmfSWtsWaGVwaiIWBkacUSsPZHSZJlAGK0PEVIbVCTVUlXlZHkm3Ci0GAzHsUCdtHTuvbN3OSH7II1aqw9J0uXGMDnnBHI5MzNDf3ePOElwlXgaaCOE56zM6czOcuT4Ca5dv8Vjjz3Fgf2HOH/+PFcuXSQf9SlGfSmocGNTu/EEJ+w7iwsL5HlOnudUVkjFCidTm+C54Jwdx1/rrHho5BWNKCZpdGi22xR5zt7eHl5BHGuKMkcpT5QYIRiHqaYcww/j9l2AFPmAmgjbb4Cr+fHfp4HhQl6f7NvTEDZnq/FzVZgKqKkp6pgbohQmJOzW127acqw1z6320KlfI7EoKELVfBzvx69vpg3ED6q4a1pUq3WBGP7W3hhlKYbPxkSSD2ktZG/C9NDLekgDb6I2LIwi2TNrWFrNi6uLC2elcYkXOPX0JMUEPkeapszOzjIzM8OlS5d4+OGHefu1N6gCLKC+Tt57ojjCRBGNRkO8O4oSpRXtdpvt7e2pgmtSMmqtiCK5HxRCQicM+MdQs3CNRhs7/B89fmSORk1moa68tJjyaa0Z9PvBqTMPXaMi3HhQ5UXQKxeTMaMnk4o0bYzfO0kS2SSsRQfnXe89cZzQ6/V47vnnxyc7y8XOXQxOIE1jiiLD2kLUFwzsbK3x/PPfot8TrevNjVXuv/8htI6wDuYWlrjnzH0M+nt8+7mvs7C0xPbWBoTunS0L1lbugDJ4B7dv3CBJW7Q7s+zubvO7v/O/02y05LtS8cADDxJpsFXBcNAjilMa7TbD/ghrK/QgkyRFRehI9LItDsI5qUYZWe5lAqJhUOY4rSh9QixiztipCt87S6Q1o0GPhjFkRUaMJ9GeWDnKoSVOtGAI8xxblXLje4+uLMOdTQbhprfeo4xmvtPh4NIc3/7aZbqtmPPvvMGVKxc5fc8pOrMzLC/tZ2dnh72dnhQXWLyrAkbTC7wwXF/tEck3pSiKPKAeZUVHSlNmg/G41bt6DC43WBxFeGepvBU1GD+lxOKQSUfd0Te1cZAJKg+aPC/w3jAYDMUR1DvpnnqNVwZbVHzqM5/ivfcucOLUaR5//Al6vR7f+Pq/5Mr5c1COULHBVVmQvouZm5/j8JEjaBPx9jtncVYEDjySEIIPgRmUj9AmIRsWFMMC34joZ5bC5TTnlonaXW6t7VBaw8r6HnsjgcZZlULUpCod2jQ4dvwYW1vr9Pp7otqGl85yLp1dG5ImPbUZWluRxAnDQY+tzS3a7Tan7rmHZrvN66+9xmAwYHNtnddefw2jI44dO0aWF1gLjXaHs2+8zqULV/jzf+nfo58VoGPas3M4pdhYW2NpeUkKaB2RJgk6MoF35INppw9wqOn5d7AaU6ARQ84xBKdOKIPmvXcVo8Eug+E2xhXY3gbV9m3aTYWzI7JsII7QwSDR2TLAFyQhcWHT1UZLNzmOiZJ4HBgFM+2o2xl3wWHUZPpYS14qrcbmb7Xu/vRovbQTUp+3FrQmbTYkNQpNlTIfonXMaz/4LnOtFuSaoiZhWsdHP/pRHCWoVLqjVo2JkMpbVFkQU/LSd77KYGeLfNCjv7NJrD2v2F1MNWCpk7B6dRtlR8SRZW3lKsUP+lRFTtbfIE1bXHv7ZX5rY4tP/NTP88SHPoGJU25cu8r995+hKgviZpPCC1tBaY3xCLHTixv6BKQwbfg3Ke4n25QkAp7wa18/V2MUIYkT8uXE50CKiroIcUBpxUh0sLvHcJiLMVzh8JYwpSgpqhFVgF5EtVa9Ff8ApQxl4NagNNWYVKvxWnwg0B6flXV5JVMJ5zE+Y9S/zdvn32C4t05ZVNzz4NPMLR2hsp5GGjPaXWF4413KvS435locPHqCYeHY3hlyz5kHccSgEioPTmkqW4JyxNrjfEWsS/LRkBe//iX2djZQriKNI5Jmiq1y+r1trp99HZPM8OSHf4LlI/fidJPcDfE6AWXQofOtsCjEa0IbgQKqrSHOCuRFa4U2oIwPHhGVOBJjxk73xoiiXCMR34IokpiKEzJvEhki5YNCXCryrY1EpjgCXiJODFbBqBzRiRvEcYpR8OBDj3Dm/gdpdzooZXjuO9/jm9/6JpeunOPWyg0Gwz0cJXGaUg6HdGZm6PeH44RNio26M+6Di3MghDuPo0LHhkaS4itRAoqNwWMobBVitKaRtlDGUNqEJG1jK4d1UrSW1kMU3KVjE3D4MjWrYWt1oicKggLBc86TNhos7dvHnTt3KEuonKIaFAFjnxIbQ15YKufZ3d6hrK7RH464cvkKO9t7bG1usru1A0oasgbJbZx3U0pGcq9obegPRmOcvFLSYC3LYnw/zc8vkucZWTbCOdkTyixD6YisLMnKPYajUbj3pKFWllbOs5/wJKRHEIzrlNxT9TR33KALe3jlgqSwn0xSQjgYd+brkBCqs7tyTFfj/esmRB1TlRo3dGSPszi8zCZU8MKQMyPrmAl0yLkJnKiW2rXWQrAdmcytodTlePJRS7XL+ZZrXuQ5WZaNf+5dDRsL0KWyxBs3HpWosFZkIjLhBNVFYxXgSSKs5cfHNz2FqfNuNXVOnLWMRiPKsmRnexvvPRfeey+IiUwgdFprTGRE5auq6Pd6ssd6j7eeXq8nBWmY8txN9vbCJ/GS01VlzcUIrZLpydOP8PiRC40oXGRdY/OcD3KBchHv3LlDFAmZy9pgSR/FmMhMWc+HL1OTRKfwX1EUkTuZ0UaxwUSxVJUIvm13bxetDHlRsLy8zIlT+7l24yZxE4a9PWxlRT9fy0m01pIXQ6RKtiwt7qOZRqAMSkV0W02Uq/j+d77NnTu32bc4P+5GOu9wVm40YwxVUWAiz8LcjATCYshqb4fRYIDWmsMH93PxvbPMdbsszM6yMDdPWVW4ypGX4nyNFXKiMqAr+QyL6CvrSDr3wvJUKOUoqxzrQUUQJc0gf+sCJEsH7LT4ChjtMXhiBbES1+8kiohwREqRl5VIu9mJDJx0WQxgMEoRRxG7W5vcvHaFWHuULbhz4xpZf5dRf5dGGsuo3EQMKxdu3ApvKynu6jGmUYH85MmHBcYoWejeo5Rc78qVKJULRtCFG1PJsShl8E42j6osAtY/JCaAVoZIRfgKokj0yJXR4oLqNaX1lFak3n7ypz9Pp9XlwvmLrK6sU1We/iCDluGeBx7myq01OovLXL+zRllVPPnhT/Djn/4MX/z932bl1hV8JLC/VqdNo9WkPxygteEjH/0wN2/d5OaN61RVVU9uJfjqiPmFfeSFZ/ngMWZmF4jTFsOiYnu7T9pJ+el/7ef5+je+wWMPPcJwNCBJYhqNlCtXLnHpwnm0qxj2d+nOLrC3s4MtKrybSBkaJQoaWqmpZK9O3hVpmrC5uSmOtXi8t8x0O/R2d3nr1dewaIpRSaPVJm22iBstmt02i/sP8tCTH2KYW3azEY12h3Z3lpm5edJmi91+nyzLWF1bY3FhSZL4gJoJMyfpopkwjlb15iJBV47SgQtEWl0Xn5IAeedJNDz/0gssLrS4c/U8r73wLbADtNV4n4MXcyEJiFJYqLDhWVuOu7I+yNIqRH2pCLh0rVStKSLHdreQUCiQRPnKqknxgYJmqyVSk2GTHW9vYUNQYUOK44TKVdjSgreit+5LZlsJUJFoT5WJ5rtLu3LcWqYGRsfC0QidukFvjzde+DaP33eCO1feY7C5wsHlJVRUsr66wuWyB/mA1RuXKQY7ojSnocp22V4bSjJS5KSJIStyqmpIu6FpJ3Dr9jW+/cXf49ThX+Zb3/oWSavFo09/kJn5JWlIaDMhJis1Lswm8+YfHoZ7alEKPU7cpwsQ2QP0GBamgLyscNYzynKBMzlHWVlGWUlRVIEbWGHLUnhNTj6jKkuUt1SF4H+cVtiqCM0KM+aXFHmFw6BNjDYxDkNVgNIxXgkkQRqcDuU9tsjY3rrJnSsvs3X7PZQf4qzj6nsFzVtLWKcw3hKlmqSZ4X3J9UuvsLl2mcopsqxitHmNo2cepTmzD0tDJtIKnC3o97bYXr1GO/H01m+wc+c8RTbC2ZJBMBV0tkTrnL4Dog4bx4/RajQwjXlK1cCbFpXTqEgHCMqU4y+SEPtpWeR66qqVNLq8w/shSZRKERKGVVp7YoMUgVoTR7HsEbrGknuM8jSThEhDI1I0EoNRjlg7mrGmFSsauqKpPA0NvipoNlI2Ntb4gz/8fQb9PlpF9Ac9FpcWuXH7Gru9PUwknW4Tx+z1ezgFboxpl2aOrENR9iEUpqIrMZEsMNqEJmg0cbwG8rzE+SGYmKTVIG0mgMI6KK3HeiWKV9YSGR3k74LYgxL5aGcD/l6BNnGAkwhurXIJcTqD8o6OTsQcUU2OS1SZCsqqpDfIcV6xubVDr58J9zSKSdMGSlkMUDkruUiYtjlfYwY0WS7FtEeHYbrH+ygINUSMsoqqcDinZfpVyZRXI8Z2PhRqddLoEYEZpTTOWqrCgpe1IlNoH2RZbSCj+6mlpcbTjGkSOH6ikKaM3Pf1PNQF7lX9NvXkQHLLUOhoLUVxSC3k+jOO3TbEIFHunDS1nIzLwzHUBce0pKsUqqL+q8aJvBvnKRPTuhq2VPtfOGvvmtZKNeiI0lRyLF9L/sjn2tA8HSO56mIixMrK1vy4ugAJSIUppEY9HdK151n4eQ3piqKIsqqEo+gJTVn5plKoBO8P78eQJ++DcpuewMwUBKWyiSJbVZV3G1sGY0c/vrD/JxcadQdRq0k1Uy8OUGxtbdFotMYbiVyDsABNfZIZJ6TeC1wqTdPxBa1No2qiTq3aIC9QoOXkKhPR7s6wsLRMu9PhzVdeEcUXLYFgTDI1alyNaQObm6tC/tIxo+GQra111lfu4EtLb7cvVbvzFEE548TxU9y+fZtmkrL/wDJn7ruXtY0trly9BiiyUR+P5/DRp7hz+w5vvfkGS4v7OHjgCE6JasQwF6JovSgD5witDUUhij1xLEZ2Fk+lII6E2xFHBq8N1nviIGViAbzAilCeNImlwEAUQWIcsdYkkQZbkOeZLJZSNmAZZ9YFXoI2QsqPjSJWnsW5GZ587BGGgz0akeGRB++XhFKDLTOK0ZBYi4qQRlM6IfoqhfhNBAlN72SDj2IT1AzCWD6JmW136A/6aKXJhkNmZmel8xSIarayuKLCOoWORFbWq4DlN5FgdLwDFwAbSmNLj4403ZlZGpUlzzIef+Ip+nsDrl+7JWaBxtNotnn0yWfoLixR6oit/ohG4llcXOD0vaeZbafMv/gCd25fQzJmKWSyImNnbweAk6eOC+wsTBJqgzkX1D8ajQZzs/O0urPsO3iE0ipu3Vmjlysef+oZjp95iIe2+9z3wAPcuH4NVxW0Ww2WhyM21jcosyGRMfRHOWUlXTxbhWuOjE9FGSnAkoLEsvg8RFir2BvtoXWMc57trU20Nhw8eJCNtU1wmkE/x6sGKtZ0O3McOXEK4pQHnnwGnTRYWdugPb/AzOw8jWaLtNkgbbe5cUOgkXUQk5xSZCDFGVXgkEYLZGEqy6TGn3ov8QRP8HeR+xRriY3ntRe+zfJSi+sXz3Ll3JsYXWKLEhVbIhOmEkpLMWGrsRIJXrqesmlYvNfjWOKc6OTEcULpq/A6AgE5dEkJxSLSXa+PfYKdrZMeqOFT9XhfIwvBh+mMJHJ10I7AWVoNw+bGJspagaEYQ7ORsLZyK8D0LEYnQZLRUuUj1m/d4Ltf+SLZyhmGWyuUvQ30fErkc3zZo7eVYSLNys1rWFswOz9Llo8o8j62FAMpFFA1mZ1dZGlhhpl2TMNUqLzHnavv8d7rL/Ldf/lHHDh+kvsfeAAzNx+SHIlTOCYOwuNrefd/x2VXXYB5C15Pnd/AMbOhq+hKyrLAWstglGGtZzDMRPzCOoFY5k4KjOC+rnF4V4IX+E7W7+HLku2NVZqNlDwbUGQDcOJDQODHjQYjnFPMLC5jkiaolGZ7FnQCKkJZK2vEV2hXkfe2uX3lHVavnUVVWySmIDaK7bX32Fi9gnMKbEVrtoVOcpSG3naf3tZNlDI4r+lvXEXpkvsffZbKpuxu7xHHETbrc/vye2ysXqbbVOysXqURKWJng7mqEJwTDUZluEhTuD47a1fwVYFTbXRznpl9x0haszglXjdhEBTicM3iCiRWdEhSlXAb4pgq8LuKOHjIKB+gV6LgZYxCe0UcR8JrGE/4RKwjMREagYA1Utk/Golhtt1gtpWQuIqUik4SsXbnJqNBj9u3r/PiK6+ytbHO4oJAd5udhihIhbGBTNcjdnt7KBcm2WqyxKTLLsl2nTRqPa0YFgqN0Bj24xaIQMua7S7tmQUKZ8mHGcoYVBQTxxGREukUjTT+BIbtJwWN1pSIapCJjBgVBg6HrOMKE7cxCqIkKOz5iRJl5C3aVeiqDM0OjSNiVFicUzS7s8SxFiUvDdq5ccfdj+VVa88fNdnPncNVFUprXDDXy3IH3gT1PI+rCkwcy2daFya1k8RMa4XHSjGuTSjsNDglDdJQXDlbw7Emnfm6ISuolYokjsPbTsz36nxxnNT6WpUpQBbDe6ZpKlOMer+o881xghyEKe6KOrVAhBvnSIIsmCTG41g1PoYgmR1I2sYYyryY+ozJBOUuszutUfW+F244b4WXXLu0j5PwsPSmn/v+96v9K8ZxdNwckI2rhp0qgjmpnqz0+v/rQqgKcaw+z1KIlNLk8+4uCJ6cW5mYRcGMUE5hmNaPDSwnU5j6v9P9pR+RefGjFxoTvJodE6N0ILpVlXyJLBsFL4kAa3G1a2YSiE0uvNaO4SY1h6GqqnFVV99QQrR0NJtNTEiaWiYizwt29/Y488ADzM7McPXSJfo7W2JoYy3KKHQERVkQJTFJErOxsYbyEa60gVwXEyUpp++5hxu3bjEcDom0BFfvFK1mi4cefIRrV66zuLjI4vw8B/bvY6/fZzAU2E9VWpaWlvngRz7Gyy+/yvUr1zh/4RL7lo+g4ibNmXmsj0ibLtyMmjiKaDQUzWZMVZZkgz6m3UTHQTLMOxSi15+mKaUzVNaDDp1C53FKOk4GJPn0blLpK8Efy/lWlEWOwhGZ4PcRHJmVcyiLbNomoRgWHD98kAP7PsPNG9f48pe/xOkTJzhy5BDrW5sUriQfDejvbdPudPC+IhLLWZz1QaZOgQ0+K77uZprxjaS0IW20OXrkBNdv3hDZ0RIW9x3Ce8VolI/JedVwwLAYUdqcNNHYqqAqSsFd5yVp2sBagYMlSSomT1HE0sISznn6vR63rl7nBy/8gGtXr5HnJVHSoD2zwJNPPU1hPUuHjpC0uvz4pz7NyRPHuXHtCm++9oOwIRuUL4miiFE2YpTJ1lBZyze+8XVAkSTxGAsrIkMG7xy93W3uOX0PpRfS8vbegNWVW+Sl4/FHHuT7L3yH5eX9vPjiC1w8/x7Dfo9uu8ncTFeKuTxj//IyVy5fwKHozM5TlZn4cyjIgsCBtSUekbATroRhdnaBXi+j0WoxMzuP0pp+f8Be/zrPfvijvHvuAlHUApMwt7hMe3aeIydOcP8jj3D+8jWur6xz5Phxjpw8jdZRIOGW7PYGzM/PMT+/MOYflWWFqiwmEvfa0WBIkhrhGWHGhn1+vDGokNDIubRhjWgEg2+8Z+3WdW6df4d3X7qN8iMiciJd4cpszIex1mJdLh2aMMY3iGpXWZUB0qDFXM9obIhD9bTHllloVorilRB9Q6crxPnaIbwugrTWDIfDuza9OvDaqsIoUeKxQJaNpEAN96l3Yta1tblOkRVEcUKcxMRxk85Ml/WVWwx7u6j2UoiPjqrMGexssX79CrfOv8PujXfIe5tEFFy/ej5MM2XKY1RKXhToSNHttCiLEXk2wmhNmiTS/HGWA/v20W2mrN+6xp2ZDg0Ny4ttvv7F3yXbXqVx4ijVoMfu5iqWiJm5RRm1B/MnFbqech3lu41hDoG0PZ0BCNcKvFMCTykFQpAXBaNsxHA4IMsyRqMRHk1RWqyXxNh7MdlTHlTlMdrhbYZyOUXWY297nd2tVap8xPXLF+i2W+zsbFKMBihXSkc+iYnThOHeAOVh+chJVNIiabQ5ceoMeeXBh+QyjtDagy3pbdxh49Z7GDck1hWuGEKk0KrCVkNZq7Ght7WJ1iJ4EitNFCd4V1CUFV4lXLvwEseP7meUK25fuS5eNcMet86/g9IlgyZE1R5VUWJMFPZNMChajaa4zgPlcMTGymVWblyj36+Iuvu459FnOH7Pg+zu9DBJKtcZEVBwheDstXNgIqK0Q5y2MFETZRIqa6nQ6DghyyfKTkZLLMFJIZdGMba0GFXIfqNAGw+uZG1nkzSJMRq6nQ7tVgs6HbqdBBW1KLI+cZyS2ZJrt+5w9p3XGfT3ePypp9nb2+HVl19kfWOVPBtSuDx4Bil8jVOvC9XgbaCQxkQQ6cR4McITVs2kEFBK1oxJIqqRSJCGXhTtVpsTZx7g4JGT3Lqzyq0rV8kqi7da+D/hntWRxCPxTwomZ6EbbIlFcVMZbFlBWUohoECrCGVkCuidJP615LyIKVkSDaoq5bnayLwkhJ1IKyqbY1SEV444MSEeBd8H76RodCVJ3KAsC0nSnRv7OBRlOeHFhc9VeHzw+HAOKAqiKKZWcVMelJEpmok1kdFYV8oEx1XkZSkcnUhhyYVrW8fhSnI18VDS4zxRuhJyENYF4YwwYVRMoE16qpioVZymoU7jbroLvk31NMBPcTLrpoeX7zP5sXTla9SMCt4ZPsQrP56qSEJdluW4eT5dbNzN8dCTSQ2hkFViBqi0lonS+Jf1gdQJ+uTv0+8hKq5yrrzy4z1nPAEK11J8YKanEJJTRlE0bm5FJiIO/hjT53Ea4lRP6KcfNQSxnlbYMNnAh4FCzSeZHkP9Kzx+dDL4cpc0TQP7Xm52XNAoH4+nfOhcy5ePQvCoRzw6wGBqcxQTiRFJUYgOcBVI093uDMZEbGxsAJpHH32Ume4cvV4frQ2tVpflA4c4deYMt2/f5tL58/zg+efAVzhXgfaYSOGwVN4x2+mKilXlsaWlLCqiKOb06XuZnZtjcWmZl156mSLLsNbR7nQ5ceokBw4s8zu/9VscPniAnd1tiiJnYf8BGp0uK3fWKEYFH/jwx/lrf+M/5nd+519AZem2ZtjY2uWts+f5D//G/w2TtGUBBlWiJNI0k5hGMw1THM1Mt0Oz1RBeQlVSFgX9QQ9lIiEAElNUjtKJTntNeI8Tg7YWSkukHK0kohVHNBPN0mIXm+c0TUSkRPLV2RJnK2LJBElMRJZl6Chhd69HUYrShq0sV69eYWV1jV/9n/8+9z90H+9efJeLVy5gbUmn0yYbDihGgleUG0AFPK3HOkRlQUGUJDimiLs6QvuIvcGQuCig1QIUaaPJkaMneObpD/DQQw8xHPZ58aXvcfPWVTY31tjeXCfPMpmaoZifm6W3t8Oot8fjTz3DzNw8t27e5NzZdzFRzMmjx0h0xO0bNymKkrm5RVqdWW6srNNZOsjHP/1T/Gv/xp8nSZu4omKwu0c+3KPbivkf/tv/mtdffo5IlWjlwFdhw5MOca2Q4UJQrTWwFQ6jEKxslFBYx8HDxymsY3trV5RyKqDR4EMf/jDn3j1HWRTMdLvERnP7zm3mZ2e5774HOHHsJF/5ypdIGxFzsx1wFWWZMdNp88ZrrzI3N0dvuyf63SbGK03lPJ/81KfZ62d05xZIkgYX3nuP1ZVV9h08yEOPPsmdtQ1+/DOfY3ZxP3dWN1hYPsCxE6cwScLeYMjqxga28mxtb1OUpYxYq4rhcMihQ4c4fPgwuzt7RCai2WzSSCXBGQ0HNNtCpksaCVEcCSlNBX5G6LMqBbEWIz1lIkBUdFKjIMv5b/7z/4jr519Duz1c2cMVQ7SrUFiiZsJoNKDT7JKNRhR5ETpqhHVoKPJMikQdoXRCsz3D8vIhKTS1Ytjfobe3TZVnYEWCGKXxaqJIUgdjX28GetLBm34Yrcf49qKQc+WVCdwjRxjsYlBEcczszBz7lw+SZRlrq+vsDTLSzjyFNfzV//K/44GnPoZVLYw27G2tsXL9IrcunuV//9W/Q5pW5P0N4sgiZkpBZEFF6CgWDXnqiY4mCljlqihJGylWx9z/2LPc99BjXLh4iV6/x/GjR7n43nvcvHGLD3zoY9xa2+Seh56gUCmLh47zmc99nkoptK0Ql3uBEtaFBkqaHgDYKSWaUFlaaxkNc3r9EVkmBEtpQAUyd1WGfUESExuUpKwLAxGLQIhchfYZ2XCLMt/lxuWzvPnid/F+SGumARSM+gOMlg58HCCP/V6PI8eOc/P6ddJWh9J6HJpGq8Ps3AKbuz2KUYHKCxaPH2P//mVsWbC5tkJva42st0Ur9mhs4IxJ59UhsK04jXBVjvMV7ZbIfjsna9thMFGLwagUDF493tNi6hp5h/YFsRZVsTiJsSFRrKoK7yExMSZOBUrmFGlzhrTVpVIRM3PL3P/wEzz3/Pc5fOw4CwuLWFuwvnqLW5cvorD4MkN1ZpmdP8ihI/dy4PApurP7GZUaH7WIGi2yIsMpmY4aLcakaRRjnEd7gUklRoErcVWOdiWKim9980vMzc9SOcv99z/EsWOn6bTnAYg8dJuauZbie899jXy0x/rqbW5cu8be7h7OWX7uZz7DKNvl2rVrXLjwHpubGyJ+oDXWWqIoIc+z0KCSKbxCybn0ClzwKMGjtSeNY1rNhvh5WE+kY8pC9kwXis7m7CL7jt5D3Jpj/8FjdLqz3Lpzhwtn32L15g2i2NBMU6y3NBoNiqrmhUhiJo2+ia+EJKbyO1v31sMIVSu55iZIrfvQ3Y8iTRnuEeuFU1NPA2wp7tSpURQBAqijCIUSQ1CjxRci0iJLXMOBPNQafyKuY/HU01TxN3G2DPDjidiODrAu50TWu91IyW0m6AdvZSqIo6iKoMAEzo7wuDGftlaUqqFFWZaNpVgn3fd68iQNKflsM77v66LBh2JRlCv9VIEwmZiMwVdTExW0cCpMzS+YogfWMTuO01BoiTR5WVVUgRNSv78PHJOqtGOIUf37OI7HCb3IwwqPKc/zMQXAGENZFHcVUvXnuwBnQk39zgkMz9QbRZjL1d97+o9CkANVVYX4MD11CQWZgna7TacjKqB7e3tjq4i6gV9PNWrfDCGYB9+YqSKuLk6iMPUqswwdSTNkGtoFUPSH/B89/pUKjXo0JpAouQFqdbfa0Kp+iPRXTOUsn/3sZ/n93/1dFpYWyPKcoshxTpzFZ2dnKYqCoijIi4LPfvazWOc5e/ZdsiCVurOzg3eKxx57nCzLuXN7ha2tbVSS0p3pkJqI7fU10fk29QkQlQoXOhSNRoMkSqmKiiIv2L9/P3/2z/xZfv03foOVlQ2UickGQzyaZrvLwr59HD56hO9//etCMksj2t0OcaNJo92m1ely59YGn/uZz/PZn/vT/PZv/zbPf/NbrK+s8tAjT/DX/uO/Se4UhZWiLIpEJUEHoyMTkvA0TRmNRmR5xijPgnKKLOa5+QUcEcO8QkCORtQ4vWCJlQZlLY04ItUQKUekHI0IFCW+zDE2EMy9A2fHeMFOS9S38B4VxqVRnJIkDZIkoZk2ePfdd/gL/9a/yV5vB9MwNLsN5uZnmZvpcPbs2zIO8z5AhpCOBorSelSkidMGpRWCVZKmRHFMVTr2toZ0F/fzt/7W3wo3ecRzzz3H66+/TrfbZW5ulm9/46tAxen77uH4iaPcuX2Lra1NTp06xdmzZxkOh5Q7m3z6p3+GD37ow2xubvHCC9/j8oVLaGBncwvjFYvz82SjEXlhaXcXeOiJp/nsz/8SDzzxAUhbfPGL/5KL597j9vVr3L5+hd21W1D1wVQYCiIlhHcXoA0SDJNxt8aHm10rRRxpGmlEr78bbkQtiideMb+4xD333scrr71GHCfjDUZrw8zMLGmacufOHZaW9uGduL8+8/TTeCyrq3fY2trAaEW73aIqCtbW1ti/dACtI7KspLKe9uw8ndkFnv7As6iowde+/GU++vFP8jO/8Is0Wm2++8IP+Imf/CxeReRe7t3ShRzIBIhFZRnlBVEUkSYpoNndlYRgOBzgbEVvZ5dsNOTkiWPsX17CGMFyxklM2mwSJw1MGqNNFLwktMBNQpB1NgsbRyTSw5UjVoqUjL/3X/5NXn/uy5hoRKRL6a562bCHQRXO5hW2lGTMBF3w0WhEkiQA5EWBd4qk0aY7u8TM7CJFkQcn+l32dreoshzlCBu2AyMdR+l+Tm0G+PFYv45rtfxhAGSMY573nioEYYHVqXCdxfdEElEXGi8iDBHHLcoq4p9+43kGtMirGFuWvPb97/Ldf/l73Lp0FpP3Ge6uoMlBlViEDKm1wSiBKTRaHQaDAdqY4JYrynTeeXxVkdmKo/c8xN4wQCmrkiLLSOKIT37yx3nuuRe5/7GnWTx0nHR2H4dO3ccjT30IqyCJgqmoI2yWcp/XX936AN+Y6kBKh4wJARuQkivI2nodkpxqLA3svacoSuH4oYh0RGo0tuzz6ve/yze++ges375CYipaLU2vt0akCqASHoxS4012e3ubNE3J8oy5uUWBZTSbwc+oJMsLispRlRXd2VmGw6Hgr8tSuvlpgrairuSdZaIop4Xj4ByNRixx3JggBVpQVTLN1UZgKkVRkSQNqqIQXpxSJFGMQpIeG6YvaBUaMZJYxHHKaJCFznrwUlGapNFiZn6B/iCnKB0mbsq5cw4dKeJYE8cRnW6T9bXblLkFn4BqcfDofdz78AeYWTiIidp4kzLIBqys3aGqSma6XZYWl0ijBLziC7/3exw8eICnnnqU8+++yTuvvYypSmbmmmzvrNCZbZPnBVHS4ZM/9lN86EOfxDtDPhzxX//Nvw7VLnEn5tChJUaDPttbO8zMLNBpt1hbvUZkPGU+QmuZTYjSjqfIS37+53+er371KxSlFHI1Tl3V8NzQ2PJBNc0YRaw1czOzRB5c5fFeU1iRcPfGkMwscviex8hczPziAeaX9uG8p5FEJMqzuXKLr335i9iqZGZhgWa7Nb7XBQ3jxhLd013uGt6kVOho1zKtzlMz06YVjLz3wYVZ0AB14uaxAXrjZb3VXWRd8538WK4Ue3eXWmstE9q6IaImn1tzoVR4XlmWwnMMz6vRJt4Lnr8ohzLZCc0Ej0xYvS8B8Y6aLgKcmySpISWght2M73xjxlzGGn5aBj+i+vdxGsygrTSckyQZf5+qqoSz6zxRiPl18VFPXKvgLVEW0gyfEMLdhLOhp2BMobCp3yuOakWxmDjAv6Q54gKCwI4LCuedQJXC+2dZNoFETa2R6es9OV8BnlRfq7E6V9gj6/PIVKESSPF1UVS7g5dlSVXmxElCaSuBwdWFa1UFuFy9F03tVfixyIm3jCc308dlrcWXlTSL62MO07f/vxUayWJrXLVKhaWCsod0p+oTJZi7MNWIY3RkSJKEQ4cOcenCeQmoWo3dDvf29kgbAdM3dWKNMcRxA2vDRbSKQ4cOsbu7F3R9NVFkQDliNEWeC9LaBb1lBWhF2mxQIYRkpcQ10VkvhNqyxBPhVMwv/Ol/g3azS7PZZn1rm7fefZf7Hrif/tYWr736Eg89eD/vvf0m/eGQqNmUqrcUY70jJ+/h6LFjbK+vcufWLebm9/GLf+4v8ODjT5M5jYkSqrKi0UhIE8E/jrKMorIs7duPQ6MDDEfuUU8cRo9JGjEYOSorwcw5R1EUZFkmuD3n6DRj7ty4yv7FWZbmO6yv3uDqpXf51je/yjNPf4jPffZzdDodhlnGaDiiso7haMjyvgP0w7nNs1y6dCaikcQ8/91v8oXf/32yUZ+PfPTDpN0Wr73xGi88/12MVqSplo4ZXiBr3o1vYGs9OopBa6z3Y03mIi8Z9HOe+PCn+Ld/+a9QliXvvfsuP/je93nv3bPs7GzQbjc4eeIoa2srrG+ssLy8RKOZoo0mzzO2tjcpioLl5X2s3b6F0YZm2sQ7RZEX2FJcWg8eOEgzbbCzu0NvOOCxx57k0See5uVX3+QX/syf56vfeJ6XvvUcB0/fx8nTpzl8cD/Li7MsL83ypS/8Ls9940t4l6F8iRp3hxQqMlgrN1llJxMN2Xg8zXZKWeXjroODsRGPKDxIsImMBLO5hUVAFNm63S693oCtjTUW5hdYu3NnLJunjaERTBLP3P8A12/c4p577+eDH/kYDzz4GK32DHdW1/jSF7/Kc1/+Mp/4qZ/i87/4p9Fpm1HlmVsSmFQUJQxGuXA5nMOFAFQ7tBqlKMZk/0l3xVpLURScO/s2D9x7GuUqEqPFxbsquLO6wle/9g2ysuTP/Nm/wMzCoijtOC/TjCBjXauVBX0uyrykGI7Q3nLj3Bv8j//Ff0zi+2hG4HMEjKTxGmydcOQl1EQ2NLZWFonqDVOOvdmeoTOzQJS0cB6SyJBnfXo7mxTD4XiiIYITYF2tejK1CSASgzV/TNcOrvi7AjPcrfbhvQ/iD4aq8jQ6XVITc+DgMu1uh8p5Njd2caXhv/+Vf4zZd4RMNXDeECvPF37nN/mtf/Kr+OEOqhxR5T2WloV/McwzHAQN95hsVJAkouWuI3FKjk1MGiX4ytFMFK12l7XegIcee4LV1VVWbt+Wyabz/JW/+n/hK//yW2z1MgqV8shTH+KZj/0ER+65H6cU7VaTsswxJp5sploIuZWzwikI+vN1QiSdtyKs+3isKuacB68Eoy2kPZFm9aV8RsAGV2UO1nJoeZGbVy7wn/2N/5DdvU3iyKMpocqJQ3HYSBOKIqcsC9rtFkkaMxwNKAKRsdkUzwnhMgmx2ZgoaN0H+IarAg9BHOGdc7jSUuZ5wEcLvKTuFI8JpKULDTXZd2qVmziOsc5RZLUq2mQKhAYdKYqiNrEIEp41vMMbXFURaemkWh9kS50kLI1mE+eEq1SMSkzd6a2zAK/A6MCrarG9vYNTCVHSJYlmaLfn+dAHP84f/uEXwDucK5iZmUEhnd8/9ZOf48tf+TpJ2gTjGYwGtFoJh5aXmGnEfO/5b7J//yxLy4tcunyZffuP8MQTH2Z2dj+372zys5/7POfffZsXv/dN3nz9JQbbmzz7wQ/ywCOPc/36bT796Z/kv/ov/zPO3Hucvd0Nbt+6ynCwh9FynpuNlN29PRppijLSca9qMQcdvDMcGGXAW1SAYcdRxFynSztJcJWnslBYh9cKZwyqOcu9j38En86i406YvMcksRFeo/bEWtFIEr76pS+yefuWTEJaDZoNgX+XQSmxqEoUZtxMAIk9JjJ1aSGGVWoinlDz08aPYNBbqy7WsUQSVDuB7YT1U8cWmX5UdyV7jF8/re5U/zdkV34CdRTqSf1c2bugxuNbKXp8FcBpDm8r4TD5gnpCUU8P6jU/MXZz46JIhH9EVh81/T3F+8VVkrCbkIjLr12Q7HVjg756OqKCsWt9jsBjYuEYTMRups7JGK6kx7F97DJef3/JnGkEmGl9HaZ5eeOCMyTcJhQndRHS7Ypcf10ETE9cJs2lirK0wcF8MgGur0FdDE0KDT+uj+rpx/R+c9f1D99Ha/HxmZ6ovJ9zUv/8/c8Zf2/UOI5PF4syUQq5/9TviuCX9v/r8SMXGulSezx60TqoM1lPo9EYczTKYmJsUl/kmYUFPvaxj7G6usa7777DaDTEe0e322VxYYFL58/T6LaCqUlMnufjRVqP5I4dO0FZWLIsZ3t7hzzPZDqgvEClvEgdKjSREgneqqrG1utxI0Un8VggD++JtWG23aXXG9IfVTRasxw/epzP/ORnefCRR1nZ2ODcufM005RvfeOb3HffPRRFxs7uDiaKOXr4EMPekC/+0Rf5H//u3+PXf+OfMur3ePqpp/jgRz5Ge34fwwqImpSBZxJHhjgyoD15UZCkbZqdLoWDvCgZFcV4s7ZFHvgtjXGSVptFaSWbjFaaRCkakebX/tGvsHrrKhE5u1t38HbIaDSk2exw/OQpjp88xfVr17l16zYPPvIYv/BLv8T9DzzCYFQwGomqSyOV0fPlSxf4r//23+bo4YP8+T/7Z7jn3tPoJOb8hYt84xtf4zvf/Coba7fYtzBDf2+bMkyoZMEqqsDRiNNUiiNb0Wq3ePSxJ/nkpz6Lbiyw3cv5o9//Qxbm53j4gfs5fuQwRTbg8qV3aTZjvvudb3LjxhUWFxZJmymjLKM/6IuWelVBNmB2fh95UVBmJd4LPMdWjmarxZNPPMlLL74ogcUYDh85zsLiMq+99jrtzgI/9tnP82f+7L/BhYvXuXrlCjubG+xsbXD+nTfwdsCN829hYtBUaF2rXYhMJaFY8CjKUnhBURSRtppoA71BLyRV4V4Ifgg6jsP0I0baWCYktRqtolDIO/I8J01istEQjUx8RCdfkyQxnZk5rFM8+MgTbO8OyCtod2Y4//Y5aHb4i3/h3+bAwYNcvHaNzvwSR0+fYXH5oBhgKeFsOGCUZcRxQrMlbqOVFe6U1gbrxRwKxdh8UnlPWYyIqfjd3/rfWLl5lQP7lmjGMd/62tc4+fAjrGxu8+/+lf+Qxf2HiRJZuz7gZL2TKaOXWT6J0rz52qt85Qt/yKHlJZqq5Au//g9IdU6SWFDBOE2aflS+ko5z5VC23kanzJkUYvCmFM5rWu1ZurOLRHFDphLeUVUZW2t3qPIM7RQmSCLa2r8lvM90oaHUZOOo3ZqVujtYTwK2YJYFEqDwOqLRnWE4yNi/tMjOziZxM8UC+cixf+kof/cf/jo7pLg45cqF81w9f5ZXn/8G517/PtoVJMqRZ32W9i+y1+tR2BJlJFmucpESb7VaY7WX0WCIUoZms0M2GqCqTDb8pInXEaWtUEAaJ2g8adqi2Z5lp1/wwU98ilMPPM6B4/dw8OQZokZLeDB+mkAoKjVKC2SyqioIxGFnKzSBXOrknAo22lNVlshE0pHUhkgryjKjLHOaqcG6kijS7O1t8965s7z64g949wcvULmS3d0tIuXE68aWaO9QOOHheA8qJCyBL2RdRRSLcqE0wwIm2yH7hI4Eh6xEUEJ7F7Dn0hwR2VDZ4H01mQTLIGeyecdRQpGXqDhwYbRAW21lg7JWcHP3LkB6NVEaoTTkRRZI9iooF2mBlCjheinv0AZZz/hgMiYdWA3YssKVhXTBA0/ORDFRLHupiRvoOMZpj9KGPHcUmaORtoWXoMSDoypzTNhj8rIkTttkpaPdmSWvLPc9+ACNRsLu1gabK7dQLmdz4ybGaNJmi30HjmCiFp3uEkeOnOa9cxd49KGHMdrz5a98Aa00f+ozP8Ujjz3BD156jdu37vBjH/kYJ48fZNjf4lvf+hKvvPQ8m2t3RMTEVeMkzmvhWvrgSSDQPInBkRa4iwqqhJEx7JtfIKostnR4Yyito3IeayIac8vc/4FP4pM5OrP7GOaVeK7YCleVaO9pNWLSKKYY9Zlptrh+7TKXz51lY3WFqNPCRJpWq0llLQKZ1ZPi0kTkZYHFBS5YIXEb2a9rXP00fj4EEt6fhk1ii+RRY5xGmBzWzV419fzwf1JE4CcZK4y9gES+NrxfjQqrD8OJytYYikMZ4q/D+0rgc7ZA+0lGXCedEicnxOq7xTNE+c/jgiGcGjcc6u803ayp4UDTvIZxwuwn8CL5CrX8sR//3KjJ9KB+TCf39bGOz1mYYMt9OinmpqcA09dnzKmYmk6MlbbgLpWm+jEpQGpJ5Mn0dwxVcne/Bhj7Ov1xj+nvV6tKoYKwyvv2penv9P7vMn799Hu/71DGTTclsL3pR97r/YnHWD9+ZDJ4PbKpDfZarTaddofV1VUiHcuYUCE+GRLN0dqQ5xmvvvoSWVZSFBneO+IootvtMr+wALX2uXPYMJWorKPRbHPPmTOsra3R7/fZ3d2TABzGe1opcZN2Fh3HLC0ssru9SzHKiE1MuzNDWVYsLC1SOsv6zhYLS0tC6HSObqdLb29PpiUVRNpx5/Z1vvn1r/DaG6/SG2XMzy9x6/YKVmt00uKJJ57BRBGXLl3k3Ltn+fGPfZz/4NS9rK6ucPv6NXqDHssHD/BAv8/BU/eSWEWpDNYrGkmKCRwVceNNidNEKmPniZEkqQgStiaO0UlMWXjp2hBIVV68FFQo9nxIaDfu3ObWtSvEkSUfbtGILc6VZFnFxYtvs7J6jSzL2dvr8dy37nD1+gU6s4v80r/+5zh97wOYNCJ3lr3RkFwZ/up/8p+QDYccefBRfBLhTcSRU/fzbG65s7pGd3aO/UuzvP36qxSlY2Z2lkajQV6U7PV6HDhwgJOnTvHO2bcZDQeUZcHly5fpvvoqn/6ZX+KZj9zP4UNHef3VlzHGsLW1wZ1bV3n15Rc4sH+JfNSjGRuqYkiRDcjzgqoqZSKmHJiYdtokUhFLh5fZ6w1ZXd9kft8Chw8foSJmdvEArVaL0TBjY32XtZVt4uYMH/r4J/nJn/kcM/uWufrdF6iwZGXO2XPvUOQjYm3BaJyvxhjd2hxIAp90H+Mo5tChg8x0u+R5xs3btwFDpzODdZbZ2S7ee4aDPnmeiSGUrYn7wRTKyvjaaY+tCgTFpET/XxviJJZCuiqJ44i8KKi2c4xJeePV75PlDutj5hYO8NiTT7N85Dgf/MQn6I2GXNveorOwQGd2huFowIXz5zn7zjkee+wJDh8+QqIjtre22Nr07Nu/PJYJ9gFPW/lg1hM6b1Ql77z1KveeOMz+xRnOvbHK5p1rtJtNdve2MMrz05/7LK1WE+G01BAAUUcR93cnBGzvWL19k0vvvM5oe4UPfOoj/KO//z+AL4iieqMhjOUn0ApnHdqBR6YWNfROoEyBCKikM22iiNoMToyU/HhDUAH64zzoMAFVYvJwV8ybDrR1sNa6lvebbFz1hpGmiWxqwXo2SVPOnLmfc++eY3trXaYmhcfpCOc1YNBJg4ZKeP773+Pd117i5uVzrN64iHIZSoWGCVZcaZ3D9fuUlQUr5lQ4sGVBVYipoDFhohJgOZUXeGVZZXhl5NsrjQsE0kEwuityy/xMhzOnT7B06AiVr/BVieR2Jmw+alxk26CNnyYJw/4QgyXSHpxFe0caG3a3t7l67TIPPfwQC7NtIh3x8vd/wEvf/x5PPfkYB5b38Vu//b/R29vAZQPiZkLlLTs7W+zu7jLc2xJUucsFnqeD1LoHW9kAm5g08kvrREocjzJSzFsnKju1tKfkbhUKKTzwoiJUVpJ4epB7wSukyxuSMV8TWXVIbj3O1Z5RQgoWU0GRVPco0rSJVQSonMSPqhDSbS1VrZQSMJyTyYVDSK9aK/HUiSIRzNTy3lUp96UrBUJD8Edy3qEqi6XCWUWZ52BKWddG1IO8cwz6o1CUaLR2gMUHf6YoBmszIhPR7w0EglQdRdkW2hdoVdDv7+ArR+Usraaiv7NNUWyy29iiLAbcunUTpUtOHjvFiXvuZ3H5IM35/az0chpLB7jy6lk+obv89u98hW5bcfnSTQb9PMitW6LIUJYFShnhcmkdlJDq5oyoWZZlRaxUnYtLTA1JXBwbgfCGgtRgxhyUjd0dLDFxsyPY+zjCuxTtRUxlbXuH+dkOPm2w78gx5hf3UWRDVtdWeOf11yiHGc1WiziNEQVIKQIrX6AMREpyGmX0OMEXWJwKkC4QeNUUmSA8TxqhCqXENwnG8wPJv1SYCBsjiTFhWqYDETpM1qaVjcfwqbugM4yLDEnWp6Rfg3eJ9xP4jvM+rOvp+EgQyjDjvFYFRcTa4K7+7KKQoksUFIN0brix6uaNxNg67sr5kdPjJ9c3lFf1elUw4W+EiaDkR2osTFT7WdTKadOd/Trht9bS6/XGBd4fNxGo/65UfS95ajRDUYj/ibUTmFr9fBDDRG89NX5seiKgvL8rsZ+G5E0/pmFZ9bUmXH8AVxcAtdRivZ6QeKTqCz5+XzV+LfVkx0/Wx10E8nqKNOYB/skF0B/3+JELDZhUkfXIvq5EJ5bscnPUN4BUfJbt7W2RWUROitaaLMtYX18nSVOUmpBPZufmMEYUGXZ3dxkMBgyHI8GCRvH4nLigbmSt5cTR42xtb7O4bz/ba+soYHHfflrNJqtra8wtzHPkxElu3r4lBFLnsGnJkSNH2N7c5tlnP8arr7/B0uISSZqwunqLja0d9np7PPXUs5y85wydzixps0me5+zbf5DdvR5vv/MurTTi/KjPqdMneffds5x9503ml5Y48cCDRM0uWZZTOSgqaDVSIhNhnIxXTRwHdQ3BQ5pgdOZsFW5+qOyELOnCnW+tnMdIaaqypNGMSZspSZow24lpLLVZu3OFJNJkxYA8HzAc7OK8KDQtLMwwGOwwzDL29rbpD3p0Z+aJ0gQVR8y7fTg82WjIys5uUDvSxMbQmZvj/ocfRWu4efUio6KirBxF6YkTTbszy8HDR3HOs3pnhTRJSeKIne1tnK0oy5wLF8+zsH8/9545xRuvvcQ777zJaHeLvZ111tbvMOhvBJMzR5GNpAvpPGkUEcURo9GAgwcP4QqHLSoG/SHNZpsHHjzI0eOnmFtY4NbNFZ546oNcuHCBVrfF8oEOnU6H7uIin/+FX+T4iRNoozl0aJnrl66Aq1heWuT8uVsYCiFKWRtkdUOAGweYapzADocjvBfPD++9ONUnjbCmGXdNoyiWxEJP7uZaOEHWdChAvMdE4uxLUPISjHDAunuLCmPiwXCIrRSHDp/iQx96lmc/8km2Bxnf+/4LHD5xjKPHj9Jud6nyAb3egEhZTh47RLeZcvnie6A0cZLS7LSpqgLlxf23cpakId+hTq60Bq0d3/3Gv2TjnpNsb66RGNga9NhaX0HhaLWaPPrII5i0HQq14L6tCL4WSmSSvcPgePeNV3jjxeehGNBNPVlvA6jQOhKVF+9DMld3oy04mZqpIFdZbzBj2dmwEcmGI8lFHTTVlLLGdLfPhUgaBtI/FPf8D20C9TWcDtpQ+73IJiIJY2oiZjpdbJlTVYVQVhTgPAcPHuJTn/4cGMMbr77C2Tde4dyr36O3uUI+2sG7nNofwRhNb2+PPMvBQSNpEBnDaDCkkabYMsd5T6U1BNPCQpYQcSOltFVIuD3iQyCbjwnXF1uxf98Sa3du8fYbr3F8kHHo2GnarQ6DPDhm6yCpWSfb4Ts7WxIZj6EiwpFlPW5dvczbr79Mo5ly7t23ePfF/SzsP8Di4iLvvvUWL7/wAhvXzzLbafL2m68xHO7gywyTxKKA4yxKK2KjBI9uAunViQeR8lIcWmfrbOmHEqba6EygvPUaABAfIRcmO1pHNBptfJ5jS3HNNbHBVxKbBdolij3SNJR1WZvLNtoNSjw6MmNJdpcFYqktcd6O5SKlqSyfr3zYUxV4JeIScpPLOifAS2SaiBToLjjGE7xbgkKjCmvTAVjhLoBHGYPXIv+sjRGxCjvCJIkkx9ailUwvtdYo56Tw1oqyytFGs3r7KlGcUGYjsuEeeT4MRQ8UmTT2ksjg7YiNtRuksefm9Qs45xj1c2YW9jEoKsr+kEobjp66h83tPZKkw8WLZ1lZ3UCbiNmZGUaDHbk+1grR2ot4gEO6tWJcqsYQbh/u+yhKSBtNrINYnEPDRFmcJ+RuFenbRiOYzuU5SsvkK47isR9Oo92FKGar10fjac3M0p6fxzQaRCYGX3HxwnlGvQEq0pi4bmqEazwVz2uTXA9oVyewQbnIM9U6Dkm+l9+rcVNrEoPqyYnzEpdlSjumqxNGDFNxavIZE4LyFIl6HNQmXXWYUnYiHCvCjfHKyz7mJ2IU03lqHQMnxxvitq+9KCRndMj0bbz2mZ4wTPZDIdpP8U4A5acnFVPnQ0vDaTxJsVII19OgGn48lmme6uTXsCZ/1/n+4enC9HHI+Zrs35NJDOMC4K73USIlW8vZTv9O+8kJvKvAYVJsjD/bT+1Q9bGM/xU+qD6pTCBQTN0Dk8f7ShnPH3sOVFhnd33e1LH+KI9/hYlGTWSZSNIOh8Og31vhnLqrsvSIoZrSIgNalIVI5wX95EG/x97eLkkSh069dFtwnrgRU1nH2uoqe3u9UOkabFWMR0/eKZrNNg8++ADz+/bxyquvkrY6dOctVVGCNswtLGLihCPHjmK948L5CxRZjtaKLMvozszgUHzkk5/g0o0bPPXsB2i0mly5eoXi7DmyvM/Svlk+8IEnqSycv3CRQX/IbLfNiaOH+fbXv87tG1eYn+3w0EMP0molDIZD9va2yLMh7bl5hkUBXiAjaFFjMoRxoYbKVegQGJNIobzBRV7keQsZp0nuUBcflqIoqZxjdnEfw94QowwPP/YIthxQZXsszDZZuXmFSGsSI/KslRVp4XazxcGDh8gqhzIN1tfWiNLLHD1+ktm5Raz1ZHmGB5JGg431dYb9Pv1+j2wwIB/1yfIR3blZ+v0eSitarTYmioiShIXFRRaWlrh8+TKj/h6VLWg2GyRxRKfTottpcvbsW6go5r57z5DnfW7euMz67ZvgcuJE0+/tidKLLUmThjiqG02j0aTVaqK9Z3lxH3lekTYyBoMME1nmZ+c4fOAgR44fZ211Gx0lHD52kvn5BU6cPMXho0cwUcTiwjyvv/wySRzTW13l+oVz7G1uEvuK4e4mSlUoXxu+ETTMhTyFjsabRdposbvbY319A6UQQpYXyI/C0+v18QE2pfDYqgxdnXBPBZiP9zWvSBMEDFHaEQHOlyHoCodAS8ZPVVa0OjPMdBd57LHHeOrpJ4GKK5fP8/2XXuKpDzzN0WPHuGMde3t9Kus5fPgo95+5n7TR5fqNizg0zXYHry15OZQiX7fAVsQ+GR+rd45yNOT29Su8984bVP1tvCuZmenibclg0Gdmbo4HHnyQ7swsVkWUCATF4ULXRLrHkdE4V9GINCtXL3L9vbdYmG3x2ovfRfucOJJESyYYMtEYY5hdPfKvOzM1PnoqaAdVlVCKiOeIZ+zf45xAE8cbssxBQndsgv99fyCd3mAmMVHeocb5KiVqRLJvKHxIFDfX16iKkTinI4WicrC8b4kPfORDrKze5uzbr3Pl/Nts3b5GlfVQSszoXJDJjCLDaDSiyEoRkYhTImOwcUUSxQyyAQooR0OUEd5S3GgwynPQinKYhXNXTfYhCIon8v3jyHDt6iVu3F7jwPmLPPTEM8zvP8rS4ZM0O11a7QbrmxvEScLM7CxV6BZ762hEntR41lZucu3yed585Qc8942vsrA4z/rqLd62JUuHj7KwsEC/t0d/9w5vvXETX2Y02imxriBVeF+AhUjUPKWLWsl9aLRMJ2xVQj1hCtLEoeEq113ViZq8hxi4elRkJg09L2shDslHDW0w3uENaIOYlrlQmDnZA50PsCoUzosculERKtboVCYmqlRYLL4SfHtkJnCJGv7hQwNCWt6yCmviMH7iwF4XwBpPcJEV6TrJYifYbaVx4Xmu/uJ4lAtiHUqSDh0J5FjkV+V7iSSn/JEmuxjWxZHEvO2tFal/nMNVAboW5FaLfESzkZImDSpXkg1z5uYX2d0ZcOvmZYpBiUpirNbMLC5TOsWxo0dZW18lSWN2d7fJRiNmOikz3TZVOSQbDiQuIpOAKiia6YCokOLWiVu9V8RxgziKUSrGE6GUxdlyfKHHzQErcbbdblO5COslqXaVpZzkg7S7XXCO0gopmtIROY9PWxy//0GaacQwL8n7u/RHfbLREDsajREKOorIy3JsnuZDys5UoaqcTE+UVJ5jE7jQ1mHswUM9CPNjNSelJnCjcVEzDWdRU/8jOKrxDf++mcaklqmXXh1f68lBfTxKPHGiKEG5Gk5Vv8iN97Bxwswknsr0QiCBotQYUYO+VB1I64bHVMzVU/0gXx+sn5bfCMu25oaFaU49oRhDPutirIa93nWewv4bpp6Eczqd+E8KNIlBTBeQYyL35Gf4moR/d6Egx3vXNwrn+I9/yL5SFx7hkD3ve349Xa+BdOr9Txif6/pz7/77n/C59WtVDfOb2h+5+/c/yuNHN+yL4lDxBh6GJ+h+h8rdW6qqlrYVElCSJOLI621wmCR0bFzo1MgiNVqgD+1Wk2wwYm+3hzKGTqeDLcugPiAnQCsvXRgdc/joMX753/sP+N73v8+h1Q2uXbtGt9tBxSW3VldxSvFzP/ezJEnCr//Tf8pw0A9u5aL4cHtlBY/mvSuXOXbvPRw4cYxOt01BxY3bNyjygt/8Z79GUWQcO36KS5ev0m136bba9DbXOXPPMXY2blDlfd56/WUq73jw4Qd5/MnHcbZkbqaDjhNKcbwZQy/G3QkrLsetZkQ2yomANBKFHudzUmNoJylFUbI33CMbDBkM+vR6e1TWstB9jPmZJpHy/MxnP0PDWF576ft4FNZHFKXl1ImTXLt+laIoiaKERtJid7tHYT1R6rly+SpFpcFHbHX32Ov1ubOyypNPPgmVZbbdYmdzjWtXL/H2W29y7fJFOs2Yxx95mFOnT3DjqqPb6WC0Ynl5H8v7D3DuvfNsbG7y9DNP8urL38ePXHA+Lllbv8Ne5rlwLmJvc4Vuy7B/eY58uEV/r8BWJWkSY0uH0YZOp83ubg8Qsl8SJczOzFOWjhOnTlFWlvXVTdbXN7ly8SIGw76l/Sjg7Llz/KV/799ndn6BtJHS7Xbp7+3xpT/8Q778pS/Tbba4ceUyo2EPRYXRnnaqGY0yVOBXiAdP3TXRNFttTCQOw4cOHuTWrVsi8Sw9KyEMBiKnD91C6byIehUqGgcvr4S/Ik7QMgGwHrAlSgV3Wo8EQK2DtjVUHvLKMt+d4YHHHuPEmXu5cfsG3/jGt7ly5Spoz/rN9+h2O/R6fbK8ZG5pmfsffIS9nVVO3HOGhYUmFYo7K7dZObdOEic8/PCjLC/tI4oi8t2tAP8QNY+1ldt88fd+G1VmtBsJjWaHubk52p0OcbPN/oNH+IlPf4ZBId1v6TYyhmtorcBVwd9BnOt1NYSyz+7mNn/0L/45edaj20qxVTEOlnVTQTo5IejCOLhKd1MSybpb5WvVl7r94wnThio47E5UP2oI7B8X7MedoD+mu3X3c8JUZNylBMYeQyXn331HXOx9IfyqokDpBG8r1lZvcfHGS5TDHW5fPY8vhmBzlBaIZIU0GdqdGRKTgM8wUSR+OMDy/v1sra9LhzckpUkUMz8/R3d+nhu3brHbFzliWwRhAyXX1aGIYxMSdc+Vy1fYf/g4w609rl69yltvv8PsvkP84p//ZeYW95EcWOLqhXdY3r+fuW7K7qYYr8kUdsSg3+el732dHzz/LW5dv4zWBWvXVogbKXHDkKqCtVsXGY6GmEiuT9SIgApvi8ABEmUZY4xM9YJ/greiEe+dH68pax1xI8FVFfi6Y6nRRhPV/kxWJhfeW3zw/VFKyXQ8EDkB8iyThpeS4riWAtdWPECcc0RJGrrewknRROA8WVaRpi0qL3h/ZcA0E1xR0ohSEmXIs4KyKINwAcJdQlE5mVRQT/+Q3EIrR2ULtBGlQo8bd0R1vfb9hPwaqOh4pYgCbFG6vRa8+DVY5UEcZyTprRTKx3gPReXR2oWplTQ7Yq1QRmRuXWgaeG+xZY5JU7yyaA+jUY+8GAm8y0RExnP40D7OX7hC2myzuXaTsiqY33eQtDnDoYNHGfS3ePmFF6iKbVwxxLkGSsXCq7HiduycBOBImTEcG4SUa7RAcOIopdHqiM9W5YgbbcrBHhrxFrK2HHdqbWUpi5JKFWhjaDZToiihLC2jUUZZlqRpOu62NzszY0J2XmYM85JenrM/meeRDzyL9hXXrlzm1pVL7G1uYIuKWGmarZQ8y4nTJPC+RClJ5M2l8eIRQRpPMPZ0NddAi2S0G/emJb6EZDhJE7w3FEVxF6m5nmhJBzvEt3FMCp1wLfBS+dz6s6W4RHYvuU9q6M043nqUAzkwFWKpPLeuTlzI65RSY8lquRdFpa8qq4nC1ti3KNTIaqpRpGse6sRcrp62CDn8bmiTUqKA6r3DVu8jbasQ442RRm0dn2s+QoCcGRM6C3pSNExPkyRnC1KwgTpAaIp7gpQvSByihjKFiVJtNDhW+p287/T1qz9n+qGmfsfU3odnXPxMv06Nn6mnPsZPV5fjgnQanuXGlPM/vrmmlAp+MsK/dW6yON8P7/qTHj86GXx5VqQdy5Jms4lWmtFwKNi70FWU4CDKCzro9aIV1pZUTrR44ygK8p5qPK6qrGdpaYm/9Jf+EmVZ8txzz/Hyyy9PVBeUulv/F/Bo4rTFZz7zk7zz7ntcuXpZCp9am1prynyECTyRZ558mtXVVXb29sjygkarxRNPPcn3XnyJuYX9/P1/8Kt84ctf4Lnvfpu1O7dxZc7u1hYYcQB99JEnWFvbYHFhifvO3Mfs7Cx37txmef8St25dZ6bdYWtzi4OHj3H/g4/Sml3g6Y98kl5WYJ2oFdUYvtoWXilNmiZ0256L56+xtrLK7vYG165d5oXvv8AHn32WT33q07z95ju8+vLLnH3nHba2NwXDXxSceehh/pd/+L+QjQps5fDW0t/d483XX+d/+h/+GxqJ5hMffYaL588xzEakaYMoiilKy/KhIxw/dR+f+snPsbi4n+u37vD22XdZWVun0Wrx5S9/maNHj/Dn/s0/y759i1y/epXXXnmFV176AZfefYs4UrRTw/7lRTotkcR99PHHOHn6NL/yK/+AtbU18iLjg88+xfXrV9nb3RaMPZqsUtjCouOIH//EJ0njiEsXL3D1ymXKPMc7kf/9iZ/4cV556SX6/T7NRgutg7MyhsV9y9KF8pDECfuWllla3MdoVPDKa2/yn/4Xf5uHHnuSS9ev8fLrr/PGq69x49Il6crlOQ44ffIkm6t3yPMhSapZWpzl6JGDfPs73yDylrLMZa0pRRQnzMzOs//QISrrqdOCtfVVstGAZpoyNzfH1u42e3t7KO1JIkNVFNIhjGRN6nHXxE86UorQz1R4LSpOGotWQvyUgCMKNHlR4jXkRYV3EVHUII4bGJOKks6wj9GKPOuxf/8yWZ4zGha0u7McO3mKnWHGtXffI1pc5vS993Pq9L1oE3Hj+k0OHT6Ct3DmzBlee+V1rl27yvbWNmVZEmtFb3ONffuX+exPf459+/axtrHJ9Zt3mF1Y4i/+8l8ms56stDgVoaMkqPa5ACMTqZh333qD0yePsnbjEn/wm7/GWy8+R2IsWd7DU9FtNijLHB/kd52tR/kO7T2CJ9dTm6E86tG18DsUlYXZuQVm5hYoS49JYryvsC5jY/W2wN9QsoFC2HT9uAkwCbaMP6ee2E4CsuCPxdHZoZylYWKB9OiIiqBKAnhVYVUlTY5C4Zzm8Il7ePqjP8YLL77MxsYaZX8PNRqgXSgEFIKvx3Hmvnu5c/MOw2EWyL4Jc3NznL7nFN/51jeD8pBnttshz3OyosQZQ5ykZIUoJ/kik1gaJSgTg9Jhk1bMzi3SH2Y8++yHub26zo3bK9zzwMP8W7/876Nbs5y/dIG5mRYbGyscP3GcsrL83h/+AX/jr/8N9nY22Fhf4Tf+yT/m9o2rlFkfX2a4qiDWUszkeSH8Pu8kYVUyIUgj0Z4fS2aOdf5BKUNVWsG6h2ahdC7deB+wrgwXSQelwoQ43DO1ZG5VichGlMTjYjQK0xEdR9g8iHBEAjOqkEZaEgxefe6kMIkMjU6bOIpZX11DKUWn1aaoCtoLMzhtycoReZEDikgpbGmJg81cVZTYyktjDf9DXWitJnLJXjnKIsckE7iltVUgpU+gtHXHePw2YzKunCeZIjalkRGgLCYxYW9V4DVp2gyyvMJtiLRnVGTSHFI+wKQJipKWot9HRYY0jsFDFImPT8gjidOEfn9Iu9Gi1ZrDYshLUFGTfQePcN+ZB1leXOK3/vlvkPU3SSIHNsdWGXGksbYUTgOi7tRsNVBAlmeS1Fai/R8ZKTKyYcHhoyd47KlnuHz+PVYuniMxjqIYhCTciMx8a45nf/Ln2Bx5PAlp2qLR6hIn6Rh+qZRnb6/PKM9od7pjL7DatFMHo9zdrTV6uzt0mw0WZ2cweK5cuMDr338OqxRJI+LwoYNjXmqr1cI7z8LCEvlwxGg0kv3QFVSupKhKqspSVi4Q1KEsRN5fG+GoKKDRFK+ioqin47XhnwclLuDjBJFJc2achDqLUwHeGUYsigBhctNO3mEqFhSoxGPCi18ONYk5kMfDf5WadMAn0xe5dyXniVFehHpUgE1N4qzE79psrp7a1F4hdaEh078JUVsKyGCOqFQQl/Lj95QY7ceTvx9K5lUwQ1TcXWiEczaJ+UEKtpJpyTQEShTjJhQCplTExnvFVGI/2T9+eHrw/v+f/pQQGO6aR9xdcDB5rr+bpF9XrnUxOvU1J4XGnzCc0FoT135RVRXMticP2x/98S+cPs4ftdBoHVyiLEvBYnoXKlQrsoalaBynDZForS86QBXUOrwWsxHtVBhzKoqioKoqZucW2NvboyoqGs0mUSx4xyiKxnhBpfwYqiVBwWMraDQagGY47BMlMSaW0VaapiwsLHD16nVsUfLAfQ+wvb3L1vYORWk5eOwo/86/+5d56KFH+G//3/89Bw8eZH1zjUsXz7GxdkeI265kfn6eUZ6R5yVzs/NUpSNOmhw/fZrtUZ/COn7pl36JL/3RF/jXPvd58mHJ1eu3+bFPf5ZHn3qazb0Bs3NzqEhRlvJdoljjXclrr7zKgf3L/O3//P/O1UsX0DankRjm52c5efo0L3z/B7i8Yq47w2AwoMgzoiii3W6CVjz+1NM88ugTvPHme1y8dJ2DB4/y0Y98gtOn7uXv/J2/w7WL71Fm22hlqYpcHM6XlsjynO3dPf7Wf/r/4KFHnyButNkbjPDK0J7p0uw22d0dUjlLnmc0Gg1+77d+h7dfewNfFGxv3uHW9Yt02gmddsz6+gpxmnDfA/dzz733cuXqNU6fuZdf//VfZ7bThuAE3W61mJ2dZWdnl7IsWbtzmyhJOHHiBMP+gL3dPWZmZti3tMz5987hvefee+/hYx/7GJGJOHf2XV5+6VW21rYRSagIsgLdaEhHqLLoZpvF5f1gInYHQ06dPsOnPvMZHnjoEeYWFpidmeE73/wG77z1Ju+9+w62yHnskfs5c+9xiqzPd775Nd5441WwFudFKcRby4GDh7jn/vu5cu06P/uzP8dv/rN/JuQxJxAvnMXEmjjSHDhwgBs3bowVOHTQTPfeY6IIT1CmQORe6yAax7EYHXrBVoOSoFVDLjTSxVSeGuagiLFWUZQOZ6HRTIjjiMKNAsZZICC2cszOzvPBD3+Er33tW4yyAvJCOjlxAsZMTS0jZuYXOXDwMAuLiwz7A9589XWoHOQ5MwcPcejYCdqz8zz21DN8+GOfpD2/yCi34booyqomjcnYNQo83C/8we+weesK69cvcuPcm/Q37xBHnoqCJJGpR5UXWOtxTgth2iuUGpdiglUPiZagaxSG2l22jjswv7CP2blFRllJnCagLNbmbK7fxtlC4NGWcTNjGrtcJ7bjsfT0SD9065QWDXfBBIuhUBLG/w5NFYqhyHgRFgjiFbFKaTY6oAy90QiVxKhIUez1iH2EClARIsGkV7YAHLGJqJzH+cAVUhqVxJIEVBXKidKR0UZIh9pg4piqKPFVhTay0YQrg1cRWsV85vO/yJXL13n6qaeItealF1/k+q1bPPDoY3zyJz7FP/3nv8WBg0tsr99he3ONUZ7hlEzZiqLAU5LEmnY7JVYyqS0ygcBIkygGryiKCusdaRqTpgnD4RCbhwLDKWwlnV+tAnmSiVxo5QjXN5IOfBFcfEtJSpNo2tgL8QkpRFigbmrV8rE+ZPVKGaJgZlWVQWq2hlEogURZa7FlhTYRXhuStEGj2cAjE4c4jmk2U3b2dsSBvrLY0o79VuqkTWvxN/HWUxUVvpLuqKaeWobOLh7rJ2o0xqhQbILzQRWuXov1OcHUjWUwChOJHHQ9XMPGOFvzmRReiZqVtZbIJAixtlahksQpSgzOiyu0Npo6FzMeyqLEVeE+UQqPIUpiVGSonGj5R5EoaCkMeAMqJkpaNFtdNrd2KH3OqdPH2Vy7QzEcoJFOsC3LScKGp3JiYueD74ghAqdQJSwfOMb65i73PfwkZx56FOcU5956g7XL79JtaCorvCiscCR1e4FP/dJfYLvQoAx5VjHKKjyaVrvF7NwsZVliKxf8qjx5no8L1iiK6LZbwvnwFoXAt7JsyO7ONkWesTzX4et/8LvMdVN6ezvMzXVBwc72Nr5yaB2FZSZNVq0dyoA2ku+gI1Di2t1oNIjjePxH3LclFtU/08FQTYoWWRTTcUyI2nr8XUaDIcNsQJ5nlOE8G21QRmOLcrwXTRcRHik4VB0bnVwLcdYWc1JCbCbsbXEci7P9mBguRHJvbTDxlWtKaLiNDeKiuycZ05yPes1LPjgtP/6+qXPYc6bPQxTdrZRUCyjIKiNU+ZPiZQJzDCsxvJcO07HxsHxqwjIhd4fZZEAtjD/ShXOppqYQ6n1FU7gm4/d838RAhXgxfsjBT/3+h6fzNVxsusZS7zs2AMvdBcT0cUQhdjj8BOYXzknVy37odT/0Pj9qodHcN4/SE9I2YXwNMtbWWhMnQrIqwwgpjiXpqE+gtTaM5wg3WSDShG8cRQk1HszoiRtjq9ViY0M6SNZW4+p4pjPD1taW4FAVnDp9kt29XXb3dgTX7xX79x/kr//1/4hz77zHN7/5Te6srNNodzjz4IP8qZ/6Sd584y2+8AdfYLbTYZj3RWLRQKwdCitKP3lGWVZhY0olGEQx9z36CN2FBQCeeepZVq/f5viREzz77EdodedJOzPoqMn/9Hf/LrdWbnPkyCHm52dZWbnNt7/1NQ7uX+bKpfN0Wilb66vEyjHXbZMmCRvb2wIF8KIeEkcxcRyRJAL9GgyHoGNm5/fRG5YcOHSCP/2v/3k++rEfJyscw37Gr/7q38cXe7z+yos8+8zTrK2u8PrrrwnM6cABFIZf+/Xf5Nz5S7Q6M3Tn5onSBjqOcB6cUgzzAVcvXqYalmysrHD+7Ntcv3KBUX+H3e0V9nbW6M40QTm00XRmZlg+eIjV9TUWFhY4d+4chw4dwmjYXt+gt7PDkePHuHDhIktL8/T7fTqdDnGcMD87z9LiEi+99BJaRZObXSnm5xeYm1tgpjvHz//8L2G9Zm5ujgcfephf+ZW/z8bGJh/68Ee4774HuL2yxr0PPMAoz+kPRugoEbWmqmLfwgLf/c632b9viZde+gH7l+a5fvU81y6fp7+3ye7uFkU+AleRprHI1zpPFItsZBmC5uLiIkVRsLu5idJCGK3KnFazgXVlSES1qAOFxMY6CYrWiiIJIZkKOdu4e9NoNCj9REWjlgItihznCxJjQncT8BpPhEfkTmXdW5QWuJJzTrqVTjrEyoHHyL3pxGwtThPSZpON7W1MlFJWFY8/9QF6e32eefZDPProY7z00ius3Fjh2PGT/OW/8lcZFZZRWVE4hVMxziRYNEpHWFv7DMg43buKohxx6fx5nn36Yf6z/+tfYzZVXD//NneuX0IrizcCy0zChmetkEB9kLJEEYoMN9bylkLDS0JNIMeqoJjlFIuLy8wvLDEYFpgkJooUw8EOuztrlEUWOBxmHNOm1xuoMfmyJmdOc9CmC406tuEcSb1phsS0cg4VNmWdhPdxRmbpIXurFDhf8dQTT/P2q2/hK/ncoipAedJmgrUl+UimGV4ZDh46zNziAm+dfUc2zCB3HQcyskeJYaKQe0jiaEwGl81CiiGiBo8+8QGefvoDfO2rX2Nr9Q6jQY/KO6Jmk7iRMhwNmem08a6gKkbBXCtFGc2wyEOCXJDGEUYBgVuCFZ+hNEnJyoqyqELsFwiO8mBLB5ZA8qxVYgBdJyKC2LDeoRBCKdSSupNqsN1qAFCWok7nnZMkXcl9VVWVSL8mieD+K/EmiqJIioIqx1UC2/KungZ40mYDbQxZJt4zOih6oRRxI8ZEnizLMMh112giJb4hGI2Jx5gJIaiWlUw5Ky+u7qiJ+VqYdPow8YG6qJWhhQuGqzBJcgySaNYQDaUVOtZ4rbDIdzE+DrKg4Zwqjw6eM1pp0iQVuG7AqSdJzGAwoNFMRFLaB6VD73GlmCM658XPApnGOk9QpBGYbBIb0igN391gTIrSRhoiCtAObWRCorxHWY8tHdZWRCaWZowP58KXUkz7uskQs7zvKCs31/nIZ36ag8dOU1rF1uY2u2t3uPneGzRUjnU51lZoD5VT0Jjj0R/7LGXUpdOdQyk5Lu8VWZHTHwyweNJUjIAj74MAhXT+rXX0+wP6w4xGuyneI0EUpO7+p1j+8J/9Y2xvC1wJRsnvbCUxwVbi9l0X0gbiJCJpJKSNBnGSYqIUHSWkSTIWz0nTlE6nQ2QScai3jsGgJzA+5ynLgjwvyMqCfDgiL4sJj8OL23VtPidcw4mQRhTFJElMmjZxpYhGSCHkQvyWqyxTtboItuNcrR5OjBsZgWAtAgZy+irr6jpe1qtS6Ehg9sZoyqqkKoU/VgUhAz2V+BPW+4QM/sel1AHmY1Tw7wivAWKjJ4VAPS14HxFcxfF4AlTDr9S4Wpe45apJcURQpZNG1NRBvG8IUR8HiP+GNNInEKYoqCMWlZh+ThcbtraLCB9QNybumoRgpiqxySHUoidKTQqjqRP1QxMMH8q/+rXTxZAOp3w8WZo63/+nFhqtfXNEsR5/8ToJcgGzVfMPxDk8GA8xWSB+GldWj6YCQLqa0i+uYQtGKyITUStSnbn/Pt577z0hKjtHEqcsLCyzvr4uik2RIYr1WE9eKUW72+Ha1RvMdGcp8orKeqxTPPHUM/zFf/vf4eHHHuPv/b2/yz//J/+E7kwXryoqK9rR0oUU0pt1FY00lWMPBD6HotXtoqOEvb0+S4tL7G3tcOzYCT768R/j6Q98iDP3PUSadvijL36B//XX/le21u5w9NghDh45xNVrl7hx7TLGKCJEnhJHUMoRuUMddpiqEJ5KXmR452k2WyRpQmUd2xs7nHzwUf7af/Q3OfPAI1gVUzmNRTPqD8n29lC2wtmKL/zRH3D1ykV+4ed/npWVFdrdLifvuYdDR47jtUgoem1wXui4c3NdRlnG3u4umgjtFb7M2V5f4f/1X/3n+LzHvqVZVm9fJ4oUlS3Y2trClyU2TWg023z84x/HaMOlS5cZDvrMzHY5/945yrIgigyf+MTH8Xhu377NxvoG3kGZSVHQ2+oD4qptrScbFbTnFnn22Q/TnZvj3/8P/jJ/5+/9PcDwxJNP8+hjj2NRfO/7L/ITn/4psqyg1+thjKHdatFKU5Qt2d5Y5+aNq1x87yxf+dIXWLl1FU+JMZ7BoCcdQy/4aOWnpe6kb+O8qDDoKAJfG7Q5ikKcluvkhgB5kJdPRpzeKTHpCt1TubUlqMdxIoR/Z0nTlAmpWWErIYZbXxGlicCKwvE4j3QnK0ekg8Y8Hq9c6LpLIV9Zx2BngIoims1WILdaMa5qNEjThLXbqzz57Ad55tkP4jGMhhnHT5zi4JFjHDh8jJmZeUonruKj3LLXG7Hby9h/4DCVU1y8eJEnnriXF55/EecUH/zAU5Rlhitz/vv/9v/JjQuvUfS3yId72FLM+lCSpKRGU+bFWOFHyH9SWoiKlacmgEsoCf4WyEZSd66sU8zMzTMzu4C1irjRACsQre2tQM52QozzdTd43Pbx42aIBFM9loyFsEkaHaQm/RgXrLWeKIhoNT42FUb4ujalch5nhWuACXFSi4rciaOn2VjfoN/vBShQHFxna4yxvM7EMj0eDQaggwIXCDyvFu7wAgNTwWSwVpVRxoCW31uraHdnaHe7pGnM9uYmZZFLbA7ynElTiOfaO6pxAiMO2YWtRHZaCek5isUnQylwpXTgq9KigxOx6NkHiJoVsQsTmgoaNZ7+ybV1UvBEUVAb0qEQkIzFOUcjTSnLEq0lQbG2wnlRPTQmdBmVFO9RJA0UG4oIpUUutAxNCF9VggIJ52/cfXWORqOBMsFrJsBCvBZ/AFuVAtu1QsqNTRQkjh0mFhjxdCLgrWU0HIFXxEY63NbZid8eUsDWsp91w0B4CnKdx0mkq1MDxqabKiQxtv65j4NyXiB1KgV6UlTLxAnQShKhSNPr9SVxbiX1Lo63TiR1vUB7RI5XTfZ7paR+DolJI2lMHY8eJ0t1wVsWuRxzmNy6AEtJolTuq8kJE56NdWgTsbhwgPXNIU9/5Cc4ePJ+dNTEeWlQ3L56jkuvPsds6rG2oCpzFB6vIqKZfTz245+nZ2OqwpEkDVqNthDMlcBW86KgsBVlPsLlQ2ZbKfsW5mgkCWtrG9y6s87hk6cpjKF0jnyUjz04YqPZvzDD137/n2MqEU4pipEQ6L0oILmQsIvwTSXTcMQjRJsQM3QE2oQJgpxLsVMxuNp93ImJHlZkmpXUq2LuaF2Qzg5wptopupQC1kQRSSOVCQqEotyQJglRgC8VZSGFXQ0bMxFxbOj1ehRFESB8KihtueATUquF6XEjuvb/0lomlrVS07ijrhBuliuJlKF05biAqR8TmGo4H7qGjEkc0KHYdkEJS09PCcLG7espcb2kwrTECzhA4qX1RNqEPaGm8TOGO4N4x03NCsPkRAEB0hiqqxpSC4ynIiaYV0sDXaZRVVWRlwWVFX6Yni4A/IQH7Up3FzcaNeXkzaSZMfl3OLeocaEh33tiGilvEwz4pou28HMdYtz088cF2NSTy/7/caHxr6A65ajKiXFTjWcExmPiujqj3rxDNSsb9YRM4+tpSHi+UtV4sx5Xi9QdRvnMW7duMT8/T7PVpNfrs7O9S1HK6FqIg1KtZ1lGmqYsLi5y9Nhxrl65ye7uHkmjReUc7c4Mw+GQ119/nUcff4ID+/bxE5/6cV78wQuAFx+QQP5DQbvTDrreYRQf8JJlWZIPB0RRAXnG+u2bHDl6jKIa8fzz38LakvnZGd584x3+xe/+LnlvE+yI1dvX6O+tMhoNMHaERpPnwnNRXuBlVTgHFY5iVIBRKBzNRkOUUbSh0WhyZ2WFn/7853n0qWe5/757abSa9IaFEJeNodVt00ybtJKEPBvy7Ic/yvzCIpeuXqfZbPDiK6/y6NPPBBhEWLyIA20UR/T6fZRSIkGMwShD3G6SphEf/MhH+aPf+ec0kohms433JWVZsLy8n498+EN85evf4IMf/jCHDhxid6+HMTFpo0Wn1SUfDunOzjAajbhy+TImMgyHI4o8p8wKjh45xn333cfOZo+HHnqUOG2wsrqBUhHPfOijJI0mL77yMn/n//MPuHr9Jg8+/Airm5s8/4MXeeKpZ3jq2Q/yla9+nWc+8AxJo0G71UJ7x3vvvsX//hv/BDsa0O/tMBz2mJvp0G4cZ339DhvrKyLR7CUxAnEoNbrGNAfHViWJT43rFefvmHa7xWDQF9KmEqL3+42DVEhORes/EPFUMBoyEUkc44nBltjKkkQxOnRwXZDTVBiwIudXWYfzMjYvbY7yGldWwafBCWEz1iRpQwQaTITtQpykJEkqiUZkiKKYtfU1jIaDhw9w88Y18jynLCzD4YjZ+QVas3Ms7FtmsNtHJQ28Mhw5dooHH36MpX2HiHWJdorXX3yB9VsXKfKKw0cOY4KCV3duhvOvv0LVv4PSBRKcpWsYRTGuKsizYtJNCQFO6jUJKOOkp94E1UTd4/1ENhsMCJWKpYYIG5R0d0JyHvYM8eGog/y0bOMPj+E9QclHT55TPyzTm6TnrkLTM5brnYyf5dpXlWChb6/cki57HFEGeNB0h6veIEVO2dDutCiriqooZQMzsnmVhZzHpNEgz8tx16w+KhdMVg8eOsD6xgabox7dbgfncrQOZD9fCZ/O5uR5RawFClELgLhKCKXOSnKAUVRFgYmMmEwqTWQSsNUY3++rsOGrACsMBbRRUTizk+LPBhy00galzKRBpYTLYFVQ+bIiouDD+pBaz6GihHbaQiCK0hSou5QOPxFi8J4kSlBRItCnUDS6sJnXhPH3wyQUijIrwpQjTAxRAS7ixsmYn1rH9RrVRoombRRlWYbrIu9ttBG1Nq2pSUQ1BOt9Tci7Grt+nKOo8XkcZy3jpCP0ypCJ47j5pwkTFYn/OgqmvL7uYlYB5q1CoSbPN9qMP8N7BxXiQWLMXd3haYlV8bUAG5LC8fnR4UC1x1spBCsrfjEKQxynNJtddraHPP7sx5hdPkxvZDFRRZo2guu7wdugFuaF+Awep/xYKhwHszOzOOcZDAZkoxylNZ3ZGZI0IU5iTCvmle++ih3s0kiMQLpNwp31HY6fPkWBTLnxHl8ZIqVoxBGDQR8TJbSaEWkjpcyHVGWGs8W4KVtZWbPKG6pCSMzOWTGVBLwq0FFCFMVYK/uqmLlJg5N6iuIc2tuxWpnDkzRS8R5RarwPKV+NfTaEzFxgS8Tt27kQfw3FqC8T4SkjPa8mjR0TxzJBCbKzMi2QJK8shTMiU7Lw+hArPMh01dcR0WOrILlcq8ZZi9NeQqrmLrK4xNAaOhzWcB33nRpDHVUIqG4qHo9vk+D6Ol3ETBLogB6wPhC8Q6yvE3ElEyDvBHaoxvejHKAUIhEKL4gC5UFLjFICVQj3kjjcW2uJIlEbLYIUeRSbABP1k2MKaIaqqih9OU7ygbGss3xv/0MwqHGgUGFNeT+ejtWPulCrCzTv/Vi5T4Wpbc2X8aH5JpN8M3VtfrTHj1xo+NDym37zCcxg8vd6KjGZatcbqiTwYpIUDGHCBKbuzkwSDFnA04F9b3ePmdkZGr4xJhKJDGvQT1FSwdcTlcFgyJ07K2itabe7zC0s0u3O0usNyIucwWBAb3eXy5cuUdmS2Zkuu3s7OF+NK0alJxtDngsxWKQQlSgMei9Sg7YkaTSJY81gNGBlZQVblmyurnLp8jXefustOu0W+Eowkv1tlBIFBV9ZdPi+Chmve+9otpo0Ggn7T+2n9BWD3kC6cVVFNhqSZxllXrC1tcm5d97h0JHjnDrzII20TTkqcL5ElG80lRODn9P3nkFpzfdfeJ7tvV02t3dZXFgiq7HEIetSWpLkvMgC1jJsBgpKW7Gzu8f+/fs5eOgwM+2U0UCxtztkNCxQKqI/zLnnnjNsbm6zs73HKMvZ3tqWRKMoSHQEZYnxsH57BRUmAmVZYEvLsN8nNhH9fo+t7S10lFJay6HDR7j/gQcpnOPXfv2f0ml3eOjBRzl+7CRJ2iROU3DQmemyMDfHW2+8wcqdO2jliLRib2uN1ZUb3L52iWF/lzg2dO4/Q6uZ0Gyk405IHZB86ELhHVoZojiiKEpsUdCcmcHaAE+ylrLwEihCh6TevJWedE/UuAtRj3FrGI48byx+oDWRiSmtuN0bcXrEVlVQnlKhQSbBU4srFLYUvKxBUbmKtBHjtR43E+tkpdFMcQ6KPENpxYH5A9x3/31cvnKFq5evEkcRe7sD+rt9arWNzfU1Ku/ozs2Sxgk7feH03Ll5mZ2N2yztO0SzPcORIydpNzzXLl9kYXGRNAZXZUQGinxIPuoRa2ikKc5V5K6iKqeN76QrLzKbjukIWl+byVjXh4SC6XxqnGzWSi3SKWQ8Tp88VN08x9bxLCRQ4/dTP6w65UMHRULi3fGvTnbHKV4ogu567dTLJIC78dobjPqkaSOM9EspgsYqMn48eakPsXaE1Uo23PH3qDt6oVtZ84WKorhLhlFgRgFvbjRViUg0e9nYq6oQWJ+1Y5nR+jqJKZ4ed+zqbp+IcUy+pKc2AKshGPJTHbw4agx+zT1yYZOXbmKYAnmCTGWIm0GpSRTHbPBxU+OEWuuIOBLobX3+bTj++to4Z7FjcyskOY518KaYXM9a5ARXZ0p+DJMKq2iyfyFyvPVkXs5JUF2b7P7EcTJW1yrKcjKNoE7ew9qru6tTRe4ftybHx6vCtVV1mTGZZKAmhUa9kCbd4vAe1uG9RikjCo9liF31P3VCF95H1epAbrLKRfLXhHs4+H7UfDU9IaPWE3ulkKmrUsFQs4b3STPSKU0cJSRpi8oaFg8c4vg9D1K4iH5mKfOCqrIYb2mkiUAHrSSjtW2R8yKLXJYFpVXCLbUevA7NTy8Tz+GAvMyY6zbp7Wyi8gGZk0lykjbZ3c0w3mJtRRHI6bE2JFEkYi+VJmm0aDYNuBZV0aAsRrgqx7oqQFlL2VO8IxsYsmFffhb2A+sk8e7MzVOWBcOexVWilEW9DoNJXq1UVu8bM91ZtsoduZbjaZf8SRtJkGlXU02HME93LqBVHCJ9GIKXCjwPVJjmVWJUGJAmda4msN8AdQwrPWxPcj2dG8c8KT5CMzkcg9ROIc5pha6TWjWZSgpctp7M1oc4aUhNjjrE2OkfTn9b/8P8BPncOraFs1YHNlW/1o0L8pqPMr5/mEDRBJZWx67QuB7zjqQALG2JCRMnUWmt78Mwh/RS1NRTvqoqBSXhp7/Sn5DpTx13ff7r7zW+ealNGMP30BME0vSp1bV8PHXsVpM4ot6/n/7Jj3+lQkOUnyYmLOODHz/HB9ybHxcd9c/qxeGqEMTDcqi7dbVj7/urLCH/CV6v3+9ThIrQhcRUZA4hSWp+h3R/Nze32Nzcotlscvz4MTozc8zPL3Dr1gqtVpdTJ0+ys73F977/AspXdDtNVM+BtUIor4uZLEMpUTBJwhhda4EIFKMciyIvMtJmk9WVOxRlSZ6XnDv7Nm+/9jo6SlBGkw17gAtyg5L8qHC7GRXs60W3EbxMVpI4Yv+B/WT5EG8dvV5Piow8p9Xq0Gm1+c63vsWjTzzDw488ztK+A7RnQXvxHImTJuAoywoNtNotjhw9ypn772d9Y42Fpf1ESUJUVJS2Cp0BjVEwGg7R0cSVoE6eRqMRly9d4tKFixw+fISTRw+xsXqbG9c1ZWnZ2enxnW8/zwc++Czfee55bPH/Ze1Pg3bLrvs+7Lf3PsMzvOOdb3ffHtDobgANgADBCRRFUqIch7Qtxhadsou2VXb8yV+SVFQqxWW7kkqceEpkWSqXHcmuyLEdyTRJUZZEmaNIAgRIgMTQGLobPdzuvlPf4R2f6Zyzh3xYa59z3rcbZLMqD6px732H5znn7L3X8F//9V8d1hVMZzOqquBwtaIqKlyIbNcTmqbBa2+CRi/cv3OXt9+8yTdf+iaLxZrGB3b3L1PWM770B18SvnfX8vyzz/PCCx9h03bM51vs7u3x4N59vv2tl7l06RJvv/k6X/3yFzl49ICtWc3jj13h4594gYf3b9J2UFjPvbtvMZ3MtHG0wPsOa5AALEWcDn6zxghQYQytF8Qo+E753h2btRdqTM/hRtEON1LzkD+rcgrQB38SP8t+7zRRRlHc/FisK7A2aInaCgqWcoJtxDkEeZ9yUgtqUjqMM/ikUqBloWiKofMdrUqJtnsbpnXNlUuXePM7b3B8eIT0fgx0DGeBtoP1Kbt7j7E6PSIkeHD7dR69e4uymrK1e4Gnnn6Oy9euU5eBvR0RCwhhw9HRMa986xtAop7OqMtIDJYUOpJv5b7SMPSIlPpppAkJpHPFwahd6QOwPGVWDIsGmxk7G2yTsSLlGtMQsGdjnW1Vb+zeY/8GUMVosJkQ5OpMIJgN9+gtEme/NwTPeo1J9Oml98zRbNYyOyIpXU5/P8YhgcjPab1eD5WB3AdnLU5pEV3nKcqq/1ygRwBTSjx48EDez+XqshEaC6mn9jknyFyKOYRQW58SZelwVpVhSJKQu4LCyeeHEPA6gNQWDleKhn6MmUYlztYH30sNC3irA+aKPDVY9nvUioTMh1AKVgz9c8k0D6n8Wrq26/sEY57aa/qwuQ/kvVLTiqKgLMuez57VDvtgOg2NonkC9XmwrbdlGtGnmGSmyhCui9ypY5hcjPb/jJG8vKX7XqGhunZ+T/b7NiOx+T6N0aGhRmlMChb2sVoOyjLAErXPC0yyPVMhN7OrUdD3SyJhrVQ0oB/kZ5IRCg8SZBknaLpK0UmMkJOglE8rkIVekP3hXIFxJbaoccWUar7DMx/7NNgp1jrqOmgDdwPRM6lKZHz1EICnKBUv4zuIkeADq/UaZwvqyYStrW1SjNLUfbpk0yxpKzApMJ9NcJRsVkvazQqbIo6EiQHftNJIXRoB5rwAWpP5NvXUYZIntCWVnxB9q8FiIkSZkeMQyqfvPD5EnAFb6MTvGNnd2aPtOrqm633OGACRydfoPCaHLR17Fy9xeLTQvSFJrtFkYWdnl4ODI2azLZlpgSRgMUh/icwq0+b7KEIMhU40N8iMJ9/JLKTcg5EByEzDCnE4Y2f28uh8SA9b3qSyH6q66u3BuH/BnHuPbAsG2tAABg/JwxiwHp2X/r8hWk96biSpDe+F6U2UgZcYSSCg75nKoKxRwRZUyMJa1/eXjBkN+e9Zpn7wA4bOtwRV9kpJnmP0Qfr1gNR5vX83oGn53jX5H0iUemdJ+tvkswalS5Ntjom9tDnmrNsbJzPyLLWS0n/HcAbh+2NeHzjRyBtANkrqF3vcJJn5t5nDOxi6oQdDFt+owTOaBQ/SYDlLdnb43RCCDMNxUj7PzqksS9qmEX1s5enmYYIpwfb2Dts7u3z84y9ycHTCyy9/i729S3zkI89z8eI+b719k0cP7rOzNeXh5lQdizbkRaWkhEhROMrsuNsWgNl0xv2796iqmhg8i9NjlfSVxqcYoJ5M+vf0vumzS6GLyCZ0o+cjgF8Ckzg+Pubhw/u8c+sO0bdsbW9jrCXEyPbWDp/5zPfzxhs3OV4s+df+lZ/lhY9+nIeHj3j06ICnn31BELvQDtxna/G+Zb4958f/7J+lqEqiD6xWjWzGpNcm3obQtcxn2xiV6ASIvmVxfMibr3+HX//1X+fG9cv86c/+IM8+/TQ3btzgG994iW9+65ss12u+9a3vcGH/CmG5IhYFV69fZz6dcvDwPsvDY65euwLWcPvObQyG6WRCWVaE4Dk5OUHmqsz47Gc/y6vfeZ1yMiP4ll//9f+Zuw8e8Ff+yr/N73/uS+ADr7/8Mo8ODpnOZkRj+M4br7Gzvc1f+Av/AtMycef2W8xnNRf3tnj9O9/m+PAB04ljvTila5YYUyBDhJTuVEqFJR/isiiJKbFYLIQSUglqFmPQxrlcjhWubdd2lHVBCIJWOFvqoLGATGcvIImRiUkpHNAbRR90knBKdNETvOzrsqpxtugrdlmaNOisAFeWkmiUBTEFVmvl7+vU1HJWEvyGrm2ZTiYUhcP7wN27d/mFn/8FiDCfb2lAZoi+kxkwKK0hJZpFx92bN0nWSC/JWmh6ZnuXabHD7/7Or5CM5Wd+5l/mxY88w9WrFzk8esBv/5N/wn//X/8tjBVUxncyt2RS1xgi69WK4IMMoVPRiHEzWnYIGaVH/927j3TORyjqn53dgLZp0KgxU+zvzw72h1y6H4xq7ic7D6yMMpnhsxNnTP77BYdjB5EdUi6NxzAICOSpt+/3+2NHPLbF4+t0zmqV16iNtL29BpkMXRQFvvM8fPiQqpIqgA8iY1jXtQZGskPH1zFQFqSabJMEHM66Hk3N1xRjpKoqprXQP5um5ejwSGYsWZk8n4KX5ELPRZ7LGIKXz87rnoMtC9FLn0TK6KtzvWphbgIPmsBmhD8nGtnJBy+CD10U5bda+z4ybarrujN+bBzI53ULIQx7IWjFwynlywzPLDv2/Fz6fo+UKWNJgJcRZWU4A0NCO9QFzr560PLsV/t9mCsrxuk1Rfm+JJlC4Wsb8VXOWaH0Aiaa3n9ZbI/ARqOIeK6GE/tKrzFZNUdpG0mQ7JApa3q9NvczGcl/gooFiLJekinm0VIWUz712R8FN+PotGE622JaF2zNJkTf0SxOWJ0uqSsN+EzQPdARkqE0hrosqUzJ4dEhZTllUgeqssJZuZ75bMLlqxeojMzq2KwXVFbmdzmLTIxPgdJZ9vf2ZA+FSNd0NGuR6C0mM0wJJjrpl0sVMXTYrsH7iIkdsWupChEZsGWF854Uc39rJFnH1s4e3nuWiyXdei1rr37BaM6fEqDIuatq9i5cIr3xNigIlaugxhguXLjA/QeP2NnZlUA2iccnJem98p7l4qS3hZNaVK9C8DRNQ1EW1POpJI+ahENOuEsgyRBPwX5kzTMwMYrsQwwEta9y9h2zmYB9Xddp/DVuPE8alLv+5zOlh4RW4fI+H9tn08epea7T+GyMaUpY7RlT+6PlInKPg7UFmNjbgpxzG02ysj3tfHumYpTPeVmWVJUMdOzps2rP2q6j7ZKcN7WVsRHwrc8UEIAtV3fHIEMPZJ37c/wsIlLRL4pS6NjaN+a9rG3XdZpQ6plNEZeMVCMZ1BX7KYqj+/8grw+caADKwxM+d+ZAOycNLiIBlyW+5NNDEP3xbFCttVSlcGVFvhBVqJE+hWy4k6JVgjAPo+FjjCLv5xyXL1/m2rVrvPTSS0xmtfyckYEiKUpW6YMXGlMI/Pqv/ipN11FV73B0eMjtW7e4ffs2Fy/t0W6WpBRoVeJQsvPEer1iMpng2w5jpGpSFAU2wWa1kkCwbYid57Of/SyXLl/htdde5+WXX6EuK9pmSVkWyhkN/UKSG6KSYTads1wu8cLFoqrF0TdNQ4iRS5eucLw4BivTRmMMbJqG77zxHdrWs7U95d/79/5tfuCzP8L3/eBn+cSnvpe6MnTLjTRemULnQEyI0dL5SBc8m1WgMFbVTHLjuVCznIXt+Yz1aolJlsm01mDJk/wakzo+/elP8vYbr/NX/+p/SuEML774Its7e1y5doPX37zJYuWpqxn/0V//a0zqCd/4xjf48pd+nwfvHmDdDFvMufnWGyQcN554jL29XWazKTFG/uAPvsTe9j5PPQWvv/oKKSXeeO0VXn3lFT77Iz/CP/uTP8lXvvgF/syP/ghVOeGll/6Qr/7+52k2DT/50z/N//nf+T+y2Sz5uZ/7u/z6b/wa1iQ+9MyTzKclv/Erv8ykLsF3TKpSHb2gQilG4bi3rTQfB8n4m9hgraN0WjVDKlwgxV9rjfAWjZSAZ/N5PzDLFdIcPilqtra2KcuSt9+6JSif1Wa8JBxdQFEoi1OaR5ZrzQhrVVVEn5jPt+k2Hh8CDplNk6xwvo0xtF2DcQZnS2mUDonT4xM59EVB22xISapptrS0ijC3m4bNas31xx5ncbqg2Wwk+PEiLVpUlVR9CgcpYqPQtZrFMe+8sWKrmnG6WnJlf8rUdXz9y5/jH//Kr/LqK69QTytMavF+LUILSZSmopdGz94oFQUEBgQ6nQvUGSoLA1MkQVS6lHK9ezRMAzll/PeIlqBSw/tl453XOOcORsGbLDV4Bk3L4EDq7e+51+DMxnYsv6wib0EnGXebBlMUyu2VNxxXhsfvMdadjz6cQQSHfo7M224pi7oPbPM11UVBF8U2l67At61UM6xQ2HwnzapoU29uquyD7hD7r+XZGFYrtNbkAMGy2WzwvqWxYDpoNg3dZgXWcvnKNUG/o1bp1NE3yjX3IUilMNBXb9D9EhRRl149Qxe8UjwG1RpCj2MKcpkR97zeQXuqkgy4y4FJDiDGFSvxf1Jlz37PMiD/xshUcGNFKSizAHJAltcw9yT2iKsqJw6BldDV8vk/u6XSKIAb9vfw7XN/N8rNxIoQRT48uonF7wrNKJokgW5UapsVfyXJnvxsTAnv86A5kMGBWVQhqt+WgXKRRFFYCgfOCSDjYyCHHgIGQDKGECXIkYGIAtJs7eyxbhOXrt7gxU98P7OdyzTBEb1h1bTsVRPqyrJYb3jn7Zu8+fJX2ZtU2NQK3z4mqa71wKcAPbv7l+iCoWkaFpuV0FK7jumspuwC9azEFo7QWkIaVDSXTctqteJw4ym3dgQgcyXVpMQVFb6rsfUBSbg/iDEqMLHEugrnAyYFvBWp/sARPllsUdFtPCaIiALWUU1m1NYyPTzi5OAAQ6Qw2Q4F8vyLSJKKhi2Zb+8SdeaDgDWQkuzN7e1tMIbZfE7TdnRa6dKNTew66hgInczlMtbq+AA4OTpivdYBkAhNeHtH5oysm1ZArpQoUtJ5ZknsRm+3dLtZtQm69iJbHFhvljRNo4CAOxOIi70aD6Eb9ngMgRRUhj6XRPtqgsFkVTavzmIUGdsRGI6DWEiFwo6qf8AouYF6UvdgTj7D0qMps+GaptFZGwI+dF0r5yIuyX0OfdP6+X4J/TOD7fK8bH/mkvbGZDQhS2KfoZLl9xtcn96DSBgnoBOdYfGBKWEKp30+vUkYJTFiOQWYkSRDBgy/F3j7o15/okQDOFOdyBWJ1Wql0yCLM7SAMS0qL6jvVDbNiMJIlrDNlQuf+apG5mzUtTSsioZ80MZcx2Kx4Jvf/GZ/LdOp0FFWqxVlUTKfb7NardhsWt566y1msxlxseDxx67z+BPXWa6O+epXv8z2zhazSclytWFra66bo8Naw+7uriq+iCNbr9c9Iuic4/t/4Ad44okn+NznPsfvf+lL+C7ILAdjwDmqUilRROqqEEcWxfA75T2u12uMMUynUy0BSzYZvKGu5ywWK0x0BDUcpTagvf3mTYqyZLVpcEXFT/zZH+OxJ27wh7/3ef7Gf/pXqadbfOzjn+BbL7/C177+Tf63//v/A5/5gR/E2JKQ5NC2/eAVXasUsSQKJ077//t3/nsuX77MpUuXODk6xDcNq8UpX/3DL/Pmd17nX/nZf5lPfOxFYuhYbxrqeoorSr7xrW/ygz/0w9T1hMuXL9M0DT/8p3+cH/jBz/Lqy9/iF/7Hv8Nf+ct/iX//3//3uXhpn4985AV+//e+wOd++5+Q2hZbWB4dHrGzs0vbtrz+xpuEmPjEpz7FD//AZ3jw8B7/7X/zX/E3/qP/gP/FT/0UV65e5cVPPMf9Bw947dWv8Tf/87f4U3/6R/jn//xP8mN/6vv4pV/6RX7vi1/g9OSQuq6IQZrvU4jUZUXnAz4IDc9ribIotBHUlcqrlf3dBwJedKetNZRlQaHqMq6UhNBaS9d1mijLGTk4OFTU0ihqLUhtRt+lXF0I3xXD7s4um82Kpm2kaoBltWmZVnNAVNWCl6Ct2awJKTLbqmi7jsl8Tte1ajYygi3Xvtls+v129eolXvzYx/nwMx/m3r13+YX/8Re5cvkqjx48ZDqdUhYFIUQuXNjn3t37NB1Us5LUisoIBggBVE89xUBqGv7+z/8d/t//5X/OycmCoqyo6wl0HSl5DIFkotoSoeyJWlSlQffZioZUK4ZgakDx9ds9999oIKmodVJeLdIQHqPXfhcN6LKhTEOT7flSfX6drVAMgfr472d+vjfAfbmw/5mxg8kO1VnZZ+V02quLjCsP4yRo/NlFUQi9E5R3PjSOZ4AnA0IZEc/vmb9uk6DITSs0USmVG50Mr9UsbRDGciZZ6Sfx6nX5RtRqirLsfURZFJIEZ98QIkVZcOnaFUwSSuykqrGFo7TSDyFy4pogJqGRadSkql2hRzmF0urpOqle5PtPKfZgVS+5aTLYcxYVjP3Zk3kD+fk2TXMG8Mq2IN9vbuQO/fXYM3QJeT46mHaUCGZKllVKmsH2z1HyKOWlG3eWhvfHOHaZ2jxUuwTsGJrZs+BKftN8rW3XAZ0mr4XuI2UbxNA32Io8fU6+0IBHZHolcMxnSas2hl6wJUtCW28zg6q/rpxsyTA0PTXeszw5Zffida5de4Lt3UvgaiyWy3sX+Pmf+7ts7t/CTQyuKphXJc8/+yy3X/4KlZP3taoU1vmI6QLNpuGk63DlhHqyQ1XVwxXHwOnpCXfu3We9OKQL8vuGApOM9Od1HdeuX8ecrknVhK71HB4ds15LP2NKEWMLXF1AKIi+IaWO5CzGlhQVED1lUVE7gy0e4QMEH7CulERoOqXdtBhbUE9m1NMtmZmTlAaVEwkrqL3AXQYfEraqsEUpEuo2E/VkTxbVBOMKXFFRYEWQRHtnrVOQd72WnwGsIt/Be3znpVJYFKQUegUlVxSsm1ZN3UCXysmG0EuNyKqnIXnICcb5AFuCbK3octau9nuOMYVRhAVMIZWIlGR4ahZryCp8wlIYVQTNEDSLshZU1ZRIEDXH/Kxzsi1YEtFn1SW9PqBrOtarVW9jJLZTfpVWBBMQY6cJYZaklnk/UmE0Ot5hGMgp50eZD2pP87woAdeG+Si9zetzrdyPpRUIhNVwpnI/ehZZ8GJsY7KPzH8XNkHqewb7B/ABXh840ZhO5wBsNqszco5ZhaRQY5ZRoPwzvQxfDtBgGLqnG2YoRxmZxKnLmJGrYlKz2WwERR3ddFUVpOQoCqcP22gGblgul8pHL/jsZz/Lcrnk9dff4M7tWywXp8znc5wxXNjbAzzXrl/hnXfewTnHbDalaaSMN59vs1gs6LpArWX/fC+3bt3mO995jZQi8/mcupr0TXAhBB4+fIhvW0gBV1VUE9HCrqqK5XJJVVVaoreqHS2bJ0ZD5aYcHx8LHSgBRp8jCZ9Cr2teO0tKnv/Hf/h/pSiq3nBMZ1u88eo32N67wH/2V/9DLly+IgFeEn6+KyaiIpGVxBI4PXRd1xCj43/9Mz9D03q2ZjMq5zg5OmK1XPCv/Es/SwqBrml49OiAX/u1X+PO3btcvnyZT3/v9/Iv/ks/SyTR+Y5111JO8gCiOR/79PdgpzV//W/916Sq5otf+Rpf//bLPPuhp/kXf/ZfpXCOz3zqeyit5bd/+7f4tV/9NU6Oj8EYfuc3fpPf/Se/halKNs2GelbwG7/2P0EIpKDNaNZhior/+Zd/UQYrhU6UgJylLlWK0ha0TUvwgc2mExqAQtgysV32vLWWNgf5TpK9TM8Io3LxwJHvCDqIqV0PQY0xhqqomepAy6KoqMqSthV0LEE/gKmuKx48eMjOfBdjLPO548LFy5R1xaNHjzhdrGibFdPpDps2Mp9t8+mPfx+PP/E4v/hLP08bRGrUpoixlfT/JKUq6ZRpay3PP/88b7xxk9u3b3Pnzj2+uPUlfuiHfhgfE6fLFXU97Y351tY2n/7MD/CTP/0v8l/8zb9FVRo+/vEX+MIXPsfNm69hnaDZ3rck32Aw3HvnbUETCaS2o/FrmWy+WetQT5GYt8YSTBRk2FoKTeIdrpflTbmiEYfGxWzkEoy4uecTEeXHW2WDh4xu5gAWmTaechl4QLnf7yUu/b1JBiZL74qhH6h07w0KzycLfd+Efm7XrGXWg6rzGWuInQSr4lgC1moVI0baTYPTqc+SDKu0qerDZ2QvKcJYVqWuaxDqkUoLT9UWydAwQ4heqwJWql6jJHugDOnsAz+shzHgW0/wHlsIMFI6aBtR9qmqCt+2rJcrCgWU6roWOsYoELeFo920g0M0idIJJSvoXBgStH51RuEpJ1/1pO7BKrHJuQqlvGlNmKTiK6FaWclzDbn6rBx3UQvyuk4ix26xRELvZ7OctAHpjdLnnilYWUHRmGwvZG/nAbf9myelUPkIbtjD45dUKUZJ+HinJX0fO4ghZPEUeWZn93awMvci272gc0RCzPLAKj+PVG1TFFqpzLfRZAYIUk4k5WtyUKgkqnMOjMHHROg8rRfqkQRj0oQsczjQJMOoP7KEzpN8pGs9pycL2tjiqhnTYkVaLnj6I8+xtVPTLBf4zYqrVy/x7msFrV8JoS8ZqRwn6dGx1nBxb5+HBwc04QBMyfb2DvP5HAxs7e5SziY8fv0yh3dvsznuWK5O8O2asqwgRA4Pj0muJNMxZ7M58/m2DllNHB0+oE7a21BIkiL7KKoSnqFwFa6y4KQSUlqDbxuCbyhtIc8GI77HWpIPgrqPpjJn0DIZQ9AAtKwm1PWMVdv1wbK8rCRVPlK4goATu5jAxAhWRgns7FmcEeq0SSq7awZKptgUdG4MWi2U5DOmRBcUgGKwg9YaiqqQhDsMAEiXBT+QyoQxem6cVANTkh6zMV1UqPkDmAJGZuxocmIcFEmUHbMsuTG2lz8/D1ZBTjR0oGjoRqIW4p9k+aQivrO1Tecb1us1bdvp4TMQ1daaQlRCe/pVno2jhwLt25KLwNU1FqHjgYhYiL21PeiT6Zuy5jIXKwP+ObHJ5fS+L0bKEiM/pQlGGpK0nGj01dE06nvUqxxmSantHAqhDKyAP/71gRONfqiJyRK2nEGJxojOUGYuzjT9WX34xtheWaSqKqEJaWJS17VwdEMUxZwgKjpR5fJyf0YuGfXla2uJWka3xvXJzM7OHnc1CL5//z6r1Zr1ekXXNnzvZ76Xb3zja/iuYbk8ZWtri8cff5wYEy+//ArOOTabgdKFHq6MDp+cnDCZTKjrKcvlShu7Auv1BmMMs9mcC0/cwBrDvXfvEUNkcbrA6DDCo6MDcdIhsb27xyc/9WlSNNy98y6f+d4f4CMvfITf+Ce/yXdee5Xj40NuPPk4zz77IebzKW+88RpvvX2TK1cusVEd+K4TOkxV1oRuxXrR8fD+PV7+5tf44R/9MSazKZu26xWNcnZsUpYWFGOcN11ZlErvEYQzhcTBwwPu3r7L93zyEzx68IDbd+/yY3/2J/qDNZ3NaEKg6TrquqCg4ODwEbu7O7xz6w6/+7u/y7Mfepbf+8M/4OqVS3zkYx/lyuVLPHxwn9feeIMXnnuOS5cv81/9rb/JS1/9Gtcfe4zZfM58Puepp55mZ2eHf/DL/4jr166xvVWxt7fNyemJzE8pCl76+tep6prFYsXe3i7WTNQoNERtuLaoypBRSkPK0otoqTeNAp6id+LZ2MYYmU4neC+SfgltoLSm18Ifo5qCkAgqZJyjKAKbzaZHm7O2tqCeAd96jtoTrl+/zmazZm/vAtceu87h0Snf8+mPYkzNt771Ha5dv8Fjj93Ax8QXvvwS23vX2N2Zcnz6iKODe6JGpffr1NlWVUUbOr797Ve4cOEixhScnC4By9HhCY/feIrlcomJieXiBIhMZlNa3/Ff/L/+S649+TTdZskLH3uRb337G/JcrJM+pNYrypYgigCBsfJ8rYnEdkNZqLwvgoxkifKcwPfBclJDlnqzNgRT/XwSIw2rKakmu5bkrR0JBKX+PWLUBF0WUd/svcjZ+5Wizfv8XP73mM41IM7pPT8zfg0UmbPKHa4s1a4KmlwqjVPeZ7g+ERhIvc56tr1juoHVnq5cuZA5E4OdBul/kP4tCaS97xg3MvaVilbpcqPkyNqEb89OsiWJgy8KJxWQ/AykyUdEFpDeBxNTX7VJKfVytr3Ckz6n4RkZvO9omxZ0oGUyEnjEEPoqCqDDv3JvhiGqTGzUHhhzxgnLLsgDwzJyZ4HpdMpmszm3tlopcI523fYVefmZ2NOHxjxta/OW0948tQ9FIUHVWHkx+kBH0v6VHNgrXYKhrydX4/Le+G61jhhD/z3h7QuNKqLUp7y/ciO3LWTmQZsb20vq6Yz51g6TyYTlYsHiZEHwrVY1pGqasx4RxAh4L99rutAn8liDtbUkMsYQo9WZI3mPOFw+U5r0xJCoy4oL+3usOsvJacO9u28T44ayNOxszVkmz8l6wWw6YdM2zMsSdJZBTEkYAU7mbJ0Gz/6FPUIqwJXEZFiuV6xXa4rSUlUl062p0IN2d9iaVbTNmhRhszlmtjXl5Gipz0D2Z1nVFFVFPZE+pDz/y5CBCwWwrKUojMxsSSIVPJ1v8diVi3TrBVbPSBdhOpvLkEhb9Hul02F2ObZKfVkJcAVFWVNVFWuMJiI5aBbKFAkmszntsgFy/2bCFQkfPEU9xYaWna0tNus1lohxSZiKSebCuFLo8zEm7afRnjZrxLFqz9aAvA82M8ePKakNUMR+tVrqMxL/27aC9OeAOv9eDr6NyafW9GcKVQnNlKe+Ihq90PLOJRo5jjTJySBAwJlCgLMkzy0lBpnelDh6dNCDSfTqfYjvMVYU50KH6DznagLSc+WczmMaiSkFSIT+voY4Uz5fBvwOtNisDtbbohiJxvTqUHKa1eeNEjSnynm5z82o0ZB2hMHfna/6jEE7ENDD9GeeM9XWP+r1gRON3EgYY24ok1cOktbarNRzd9FmMifITqua8NkgJuXK5kSlVITXey/Zud68aLeLcolsIjWQilKfdUSy6YM2ksnnJd5++y3u3bvLZrMma/d3PvDOWzfZrFeC8mFoNi23bt2RJCckmWYZs8SXyBaiQ1WybKn3nqIopJJitOm2rDg9WYAxHD46BQJtE3CF8KBnWzOuXbvK3t4eVVmxs73L3t5Fnnv+BW7dukNZvsJP/bP/LNeuX2e+v8t3vvMqhwePeP21V3j5lVeoZxMWi2M2vuVktSRGCRa6IDJ/uVQWQsCQ+Hs/99+xvT3jk5/+fqrpNo33MuQm+j55Ez+mTkwrVYLIy3Tj5CNVXXP9sceVo18y2dri+hNPsLd/UdRCFJ04XSxYbzY8eHiP77zyMsdHBzz34Q+xu7NNVVn+0S//faoi0axPOD1JRL/m8OCA5eKU0DU8evAuX/v61zl+9JB/9S/+RaxznJycAIJ+vvjiJ3j9jVd58cXv4e69W2ASp8sTaZAuHdbBbFqQUkvnI+Apinz4pMk/GVFlssb2+zmGQLJRE+fM8XYqA2f6eRro+hs7GggEovduRIJvoGRIEOqcVDM2TYPXmS/55dsOItR1zcc+8jGe/Kee5O//0j9ke3ubixcv0rQNL3/7FVI07Oxc4Ic++6P8xD/900wmO8zmO8QIDx8+4vY7b/PJT3yEv/Gf/T/58HOXOXh4j/XyVAZKWen/WS5OKCYTNpuOGzee5uDwiKPjN1icrnjl5VcpyhofEu1mg0/CBT9dLLj59lsU021efeWbVKXh4OghRWWZzicacAQJpnSqdRgZU+S0Ct3FCPJrFYUPuXxujNCuEr2Gt5q2AWnRgKgfyMRQicgITgjSxGbsKHFx6uwz2huzXGfqjfEfRUkZG96xvcnXlak1/Z0aSGmcmGhSkY32+31IlP2WbEbeFI00qAoeOpV2FPD2BZXBGZyncuVnNN5vScU8cuBKGvphhNKWn6k+Y1UPIpqeM5zVmdasSU3sxT3yM8iValAgD+nZi0FVo5TeFhN0KumdUci8sn2AodWUyWRKiommaQFpmq5rOVe+60jQ01qNAlrGGEVZR3QiVavqVWAUIZX+kIHfzahpM/W0Jk0UCocPXV8VclZmR8jjjFhti7DW9MmgUYBOTIgmcL7rv5afHRaKsiBlfrkmcFJ5GxKwcYUJBupS0vKAILHyXG2hyHhEegadY3t7n8VyRVFWxOAJPuJKGbS6tVNII2o/Vc2pkllBVTu2d2cii6y20ymHvetaTk6OSSkgbFyFFazFOLG3KRoIgS4lscdRZnGkmGkm2RbInms2nainFY4yGfZ354TGYWykrhxb8ymEhs1pyWw+x7oSnCMFodKFlIjGSlWORNtumM92pGpqi36gXOEczgoro2s7Ou/ZmUww1YAuc7SAJNWe+aQiRfH5rpTPXC1PMUp/yX0IeV6asVkQ2UqPr7G4oqJtO+69+y50DSl0xCBzkLYOj5hv7/T7IsaxfUlDQKkJnkz8diRjqSYTCNLaK7SgCZumFT+NqFvZIAFt0sqUVbvrrMGVFX6xwBlEyStJvAUyZTwG2Nu/SFlVHB4eUdUVqE0XJshMGS9a3bSWqpriO89qvVFAw4nP6LwcAO0fsjazRgYfkoPrceN1b+d0IGlRisRwBpnyT4UYCa0M8hz3ZQhAGGSvRVHMGwCuc4CRJvVZ+c/qkEpR2RZbarFgci9FtvUjHxgjyQ4CJNm+F6qS13Ve4rfsp/Rn+q+TSDEMVzWqbGagwmr18kzFXT87M4iyz7P9cxhVMcY+O2VGwdnkTP7R/98Hev0J5G1TnxQMqlOD/F+/eOcctjG5mcb2X3CFI5f+8w1k3mo/edwMnLqxbKNVBygGNasAnEUFBe2Tv69WK955520ePHgg013z56bEwcFD6rpivrUtWtzGs1yuiSFSFiWXL1/m9q07MsgqBVbLJSGGXh0AIwnYwMvrZOheG+g6z3SyBViefvoZbr51k/V6gfexpznEGOh8x2qzplytePDgIUeHx/gQOD494dHxEYvlkhAjexcusH/xIqfrBSeLU1GIqQu64Cmc0KG8DuCRIXMWkmdSV7z52iv8yi//A8qy4ns+84M4U5CSJYQOYwSJyuCYMjp7NDgndblRemdvB4yUyqv5jGI6EUMefb/xXOFYLE75tV/5FV595ds0yxNef/kbXLt2lUjk9PgR3/e9n+DRg/vUVc3BwSNOjw/wXcujhw3fefmblKVQze4/vM9zz7/Auml4+PAh1+bXefzGE3ztG3/I4dERd+/epapFKUZUnyAlj7WR4JuelpfpI0JFkJ9zWiUb77WMFg5BnMVmVFyDX+GfZpQwH1BJ1uS9xMBUVcVsNlcliaQVuwmHh4f4thVngAR5OJhOxBAvl0tc4Wjahv0L+6SFqJB1PvLw0QEffv4Frlx/iqZN+GRxruLqySlHJ6d87BOf5sd+/M+xXh3z1hs1t99+k2V7pBr90nQohs5xeHDM7v5FPvvDjzObzGg2HYvVim9/+9uYomBrPsW3LctNQ3z0kMvXK7a3pxwdPOD3f+/z3H9wl5SEVmIZgp9euWl0vg36zLT/MPO8c1AtztL0xjOXZDNadpZbK+sTFTVDgzyRA9bgR5PAqIEWkFMLCXJRNCamXqKWc8b5/Wzg+73GVYneDo+Dv3z95x3k6JnJfbt+Pw2OIp1Bxs6U/PX/3++azycjZyhh6jx6YEEfdH93hv4sgDpIoz0dZIqLJCaiXDYkGPnng4doZH1qKuHfa+9JTjRyZcX7MEraR3QPTeoy3Sk7937opX4/V68zVWxICCVQ7ysOevYVnBsWK3/B5MBNg7ZeYt0hMbvsZ7H/tq9sOucksEcDCxN1po4M4iJGrHXEOPiebDsyIp19WKabGJelMEOfLPYrNEo4hv3U75z37AVSxJCDKAnMUjJU1YwZFcaJpGqMCVuWVPWMup4QgwGl8OQksfNoIDtV+p0ZGvRTwhYddSfPVG5JbYCTRAOjSkBR/J9N2T64PjG0GKmIJqT3wDju33/At7/5TXwQ5ZwUPDE0HBw8JPoNzXrFarng9TffwJUTXOXo2gavfTsB4bvHFHHWSE8bjpAabCGTmqeTiiJXVjcNRVEymUxIQWxx1ObpxekpTdNhXCHzPSpHURWEBM5CWTomlSRqBhE4yJPijUFoSuJsIRm6ztOtN6RuTehaQaldwWq5YjLbItPThrV+b6CdtFqWmQVZ9Smf8IRhs2n7nzHWDpPodT9ZV0jyaPTvKGimk8rzUcmiDWVVC8UJtNcFQsj+Rfa0tZZoRFilS1Kp2DSt9GlVVs9SgUmezksPnbVKsxqBOkER/XzPmXKV7azIczsVL+CMrU0pQeGU3prPnVYHolSWJBCPg0UcBfp9JdEAbhwyq9yt00oLBkzUZml5poZMSdQhp1FUR88mAonoM/ho1E4NoMYwzHp0HeODP76ilHowaGwLzydOKY16FPPv5fi9N4Jnq76SxAxZ3B/lK8+//kSJBnCmwVAeXDzTYzFG+3KWlelO+Sb7pCLkCZbynbIs+xFIVulTedDJGQdiRAUgRE/w0rQmSFQepy6flVJivVnTPZBBPTs7273hpoAQCgrn2N+/gLOWWhORzXqD7zqefuppgpcy+HK10IxWApcQPD7IplmvVkwnM4yJbG/tceXSLmC5fOUxTk8XfPrTn2KxWHF8XLBpl5wcn+B9x507twgh0DSerfkee7sXSEkQh1/8e7/A0dERMUWOjg65cuUKW/MZj11/jEeHD3lw/x5VWWIMlGXBZr3BoE09SbJrocwk6knJ733h80xnc3Z293nmuY9hLHTrDivDISCZ3oiklFRBRtA+q1SVgEq0omtiC0EDE0PZHcN0MsUS+cbXvsqD+/ewoWV5+Iibr7/KbD7l+Rc+zLNPP0FppPl/fWrx04rWymT3ZnXKtWee4RGRf/CP/j4/cvKjdN7TNC3XHruGTx2Tac13vvMqTbuiaR2TSc3+/h6r1UIGI+Wp3Lmcqt5apBntOa5rHOQ4GQ6h7ONBIz5KdCu/q0PGBBcZAkaTbN59WOvY2tqmcAWr1Yrlasn29jYHSfjm/YBAI0bSOcu3v/1tvvCFL1BPpvjQUtUFzhXMZlMePDzg7Xfe4vU3Xufh8ZJ6tsNsa496MmexXnJ0esLbt97h+Y88z8GDd2mWp6wXJxRG9ulidcrO7j6LxZL9CzucnCz56Mc/xWe+/wdxTqpwL33jJY5PFxwdPmJ7e4u23XByfIT3Hffu3eaHf+RPcXxwjy///hfxvoEUhIihdsGZYkBIxsEcaGlbjW9vDQb7IsnQOSOc84qR0csVqBBlL2YRCmMEacaYfk3IZiclSPmTtVEvB9PxTBj3XQP3sdE+gxaNjPUwnTm/zAgly++dhpsf/XBv/BUhQz9vTB+Qa8i/8N6A88wn99HnmTDlfe9t+B3es275+z0Sl4PllNWZXN+LQJ/4JIwbAKS42ZCy+pM+e1KiKKtBaEHpYCmp6pCTCeNEehDKIH6ibypNqac0jtdnnPAWbpDozg9OktABkR8H6QPqJ8+jKBzBMLAh9P6yZOVkMqFtOrq2JaYgk7FzcNgHF+/dL6OvnI8XyBWZIVEeraGiicag/P+z2ylXZWL/dUtMYuONcVT1nBASPljm833pPatUScaAsSU+OLyXs4rJcsWxP9vJ6JRqoTjgQw6OSubb+/o++n7QKwGJ75QBkTFK4mqN6xONPBuCqMNSrWXZeB4+fMTddw8g5WRc3uPde3d597ZH1P8cx48esjudEg1EW9LFDa2XuRzWB1arFdOtfU7WS3wqiMliXUksK1JRkopC2BspMpnMqOqaFB2u2dCsViQs67ajaTuplKKN/V1L0wUKZykLpzZR1tCHSO5F8coUCN6zCR1tK428RVHStiI2I0dW7GEPaqrFTKnfAIPfzRsgDqBH17bY5IUgF6WnJihabowjxk7BsxyvRWVuCEibjKy79x1N59na3SfFDmXdiexwURCSMD9srughlPnOd6Toe/PXtp6uayAZSldBIfcsSp4lq9WCGKVqJdVg2+9jo0lQ7qUYn5+ktjTTy/IMnpyAiF9xFDqTyqRB8U36IlQcTHtbk1FFt/zZBjBJ5Z3lGfVnAAAR8nCFkUpdTMQR4C4+Xs5LpkHmighIb18IXntwtDcDSzLD5G/5TElCnIrUpJiGtT9vN87YFvpE1Wh8ljS77CvbSgHLIGy2/9ZIla+3q/Jm/X8ZF/wgrz+R6lQuSYtTL0ZNhtngG1KvGGD6mwQx6lmVoetaYhw4xbmx1hlRj0oh4ruOSKDJFQ47IDwxCJ2gKkVutG1bDFarDfIcQpKEQg6uND6eLk6YTqZsbc1IKXF6cky7ScxmW/zMz/wMdV2zXq85ePSId95+hwcPHvDTP/3TfP7zn+fg4IBnnnmG+dacxeKUe+/e49HBI6qqZrNYceOpp2g2Ld/76e/jT/3wj5Ki4ZlnnuUXf+Hv851XX8fHxIdfeIHT0yPefPM11VaWQVqzmZQV77/7Lut1S1nX3L17S2Tb1EkePLhH8KJ1PJlNmU+mrFdrUoosSdIYXsucBd95HAXYJJPHY2JaVXzut/8Ji8WKv/RX/h2KyZb2aBjhmRptSnQawIU06sVJOCuOJijv1RhBnWKSuQ091zdBu1lx5dIlPvbCc3z5+IDt+S6PP3aV7a0Zy+Upb37nZe69/TqTuublb7/MM089yY3HrnF0dMTXvvomZWnw3ZoYGzrveeWVl7h0+QrXrl2naRfcvn2TJ25c58G7t9mu57Rty7179zAGprMJm6ZjMpmoGIA9c+iFHwpNo/K/SvkSiUBUGSySqS89ItcjQxkJ1sb8PoDRSNIlfOuZz7do1g2PHh5gjJWKk285PDykrmv2Ll7k+PgQMFgj6NvDB/cJ6iwink3b8J3Xvo0YmJKyKoix5T/6j/9vPPbks/zIj/8En/zU97G/f5GYGl785PP87hd/m3/0936ef+Mv/mtYB489do0nb1zj9OSYb37rWxSuZP/CZT764id46ulneOyJGzw6OOKLX/wyXduyWCz4iX/qz/E//dLfoygL9i9cY2dnm7ffeYvVcsHv/vZvykRcRCLPaHIWYyQFKV9LX+ggXnAejS9UB71Hf/RZxxAoVVRCEGEhtmfAwpnc96IVk0zrsJaAzCPJPQdRnU+PzPfl6oHfmx26rN6A8LwHMcwrPEoysvHNQMo4wMXa3gKKTZc6YaahmN4NpB4ZGt5X6Jm5ipNMopdozA4uMn6H932Nq8vpPff+R7wSvQPpK0HqWDJfONtiaR63OqtDfjnzfZ2RBBkQmmYShShjpI8pc40lYHZUVU3TtqQ44h8j6HVUJbjgZX9UVUVC+gbbdnMG5BqvX16XVivxRVEMjahdpz0ZkqhE5WinKPSEaBMx+X6ac/B+oEsoLcgYCEGle9uuR3qJw5ynrhVqlNckSahbsV+3NNpjY4RzvIZR+z7M+Gtqh/Lk6zE4MkZhhXZlsJTYoqIoambzPTAFXTDEKDz5ZDJLICFdkU7Pnfxd3l+oyK4w+K6lKkXlrFNKnzWZ1mJ6qh0oyJgGScwQRXVRPgc55zkRQppTc7yDTdiiZuomFBGwAlA6E7WtVkBGK29M8p4uwWYl+2LdRbpOgbFNw82bN3n2+RkOw2RSU1QTQkw0rWezaknG0jQN07oiYumioSqnbO9dwpZLTo8bLly+ht1sRAAnJbq2Y7FYsVhv8N0aGzqOlycYJPGIMdA0LV6D8rZtaddrKqIAhAoIhBApjBGRliZgjQrnOKHDhDgk1QL0WqH7pghFLdQ0tWvJWqIqWKaU+r4kEJXCpL2zCSvDYItCGsAlVuZ0uWLTdmyWC5q24tnnX9CzIKIiMnfBslytMNbR+ci0rHFO4oaiK3qQxHsvDdbJUNdTtra2BnOjVY629ZpOyzy2six6v2KdpSh1Vkgh9yznNTFUIYXunKdZB4mmccZSV5XMtioNlkFhM1t9Y0RCu2t9f45ygid9boHQyZDomFShy0igabDSIN03Z2a6pKL/6gvrMktl5x6NDGIKiFTWIkThbKk9hhJHhBAwmsBYa6D//XFFhzPPM8uiowlOBkaybG/K9iIoiJp7TfQ25GmKv80+NyF9Tj0ntPfpfKCXSd+ND3DuNbu8D9AjV9Ya7egf0EenGv55Yms2/qvVqs+0pTQ2IHVVLfJykixIQ56JskHyzxRFoT56GOwnzT8GpxNtpari1DDLomfHP5lMdM5H0qxeAszJZMILL3yUr/zB1zCu5JlnnmE6m3J0dMjd23e00bvkp3/6p/mt3/otDo8OegcCEAm88MILvPTSSyJTiyW0kcJVPPvh5/jZn/2L/PZvfZ5f++VfhjKj6xFXJMqqALxWhxLWlKSkCgnWUtcVH//Ex+jajgcPHtC2LXu7uyxXK9544w0ms7p3OGVV4IyhricUrsS3HZuVJGpXr1yQ/oXVhrKeceX6Ezzz7EfYu3SVf+vf+t/x6Hih+uUGjAYD1vY62sMrEmJHSFFmi3ivBqEk68EXzslsjq4ltA2/85u/xj/6h38fR2B7a0bXbrh/7w6bruHw8ICL+/uQYLU8pWka5rMZFy/t8+jgQNEJ7cMxUJY1YFivVzIzgoAzEJPHmDzIx/R7FIbAr080rO2TuyxbXFjX5wj5oIo6jDuDJsuWOjtELqbcXKua3cZQGOEhl2VFjDCZzGjahvVm1Q/jEeO66ZWm5HNR9Es/z0Vi9JTO6ZA+Q0gWV085Pd3wf/+rf40bTz3Lb/7W7/CHX/k6dVVz/eplvv7Vr/DnfuzH+Xv/48/x6N4dLuxtM9+asVyccnhySrfasHXpCutNy4WLl+lCYrVeI6pgE/6T/+Q/5ud+7u/y+d/5HZ5++gZNs+Hg0UN2d7e5d/e2oD/Ba4OdNCYChM5TlhU25QY+yKFqGk2oNcZgkyT/Q0lYEN3Ytj0nOQRxvGfWD9OvjyBV4nisLYg+0TYeYqfWz1JPZ2xt7zOb7Qq1Cine3X77Dbp2jYlRp+oK7PreFvCzhjwHee8diuf6v/usfoSmFDkw1GTp/PuKvxp/PfWJbx+EJk2WA+okh2QlU6DyKzvO8WeMP3v85/ui7GM4rHcm0miZES2p1omsc36vsizxUbj0ub8LDfx3dnb6oVBd10lVoiiEb+1KfAxcvnKF1XrN8vRU5zWJ+kpKCd+0hBCoy4q6rinKkpgiy+WyVzUa06byf3n2TF6P8RrmACgnJ5KYZrQ8ScKsGV3fFC/ZF7mS471U8gX5l7kjxgpKmZSmYXWKcl/pzz0fI3vT049sVnLKn2m0b7Htl+M8FaJQPxlzhtjf5yBeQjRMtnaZzncoigkhWMpqi4STINzYfr+B8PclIQJp8s7BjdBq+snRVuyZUIdt77Oty9KmOQFSRaDR0MtsX3N8los2ujv7QEosh6DSrihEAStFysLpID4v6D+GQq+hbdZMqxrfNX2SnAwEY+girI8XPPbcx/jsn/pRPFYanY1UZXw0GOeoy5KHt9/h8OAB8/mES1cvUdUTUizYdAGnlCar4gIxJWzpaDdraFc0yxNIXhgDek8B6HyQ4YAhUJnI69/+Jg/u3KJ0sFmcyJyMJM3LH/vM93Pp6jUevXuXb/7BF7FErJUHFaNQAhNGZskYS7W1y//yp/4Zfve3f4eDB/eJ3ZrCicQrOD71fd/P7/3uF/nBH/txqumULkS6EAmqqBS6lhQChZVE8v7duxgily9fUsBH6V9OpNsL61icHnP3zm2dr+RBhRCCbwfRBQWUiZFCJbhTHKoguTJ4fHws+8+Kkuiwl8WGOSf9MMYMXze5p6aTnhpjDEZpi1rWJqUoSZeJOK3aOGMpnJW+2bIkE6GrugagaRraVlTvShWZ8N5L1TKenfGRgRen1QKvNqcYVVqdEzq53J8VW6JUxfV6rUwUg3VFPwRYJMaTUAijSMD39U29r6Jw77HvPcB0xoZnGyN0cUlsxQbiw5kq2vie+lcGnlyhYiz6NQPd4TF/3OsDVzTGeunGSGOn71ppAiKNAqbU81fbVjTIZ7MJ3sf+xpyzOJ0gG6KoLHjvKYuyLy/1hjTL5XovVQAdZjXwez2rxZqqqsCg8rZJVJWco65rFosFW1tz2rZj68Kc7a1tylJKdk88/iR7e1f41//N/w3/7X/z/+Gtmzepy5r5fK4N7oG//bf/Nhcv7YsaRNdRFI7pdMLpcsG3vvUtfPLs7u9x7cp1SIZHjw658+4d/vGv/ENWi4ZYIEENSRx2SLSbhqoqKF3F49evcffuPVWwgKoquHLtIq6E+w8OODh6xGa95uDwIcYYpjNBL4Q33XL1+jXeffddlWG1bNqWT3//9/EHX/o9Hjx4QNM0XLx8hQsXLhKBr3zp99nav8ilf/f/xKNHj6R5LtpeXjCrLDjE+TVNo02WBZbAZrkCI83LvdEwhrJwdJslX/rC5/j5/+F/wLcL9ne3uHfnFvfvLunaDcvlCkxBVUvylxsup5MJpMS923eIqnTkQ0PlKg0kVr20HkEmYXcihdEHpMYa0eIvS5wrempeURTCIY5JB31ZKlcRjczNGFQlBgNirSCRgrhrIpIGlZz8yoeyKFSy2QeSgaYTJbTj06M+MMmIsHGWvQu7WGv7htksZxpbca0+iRRjIkoyhUw8TrGjLOE/+L/8uyzXDUVZU9YTjHW8/HVI0fPzP/e3+eHP/jDL02d46803uXf3Luv1muAT84uXaTuRvl03ng8/9zzPfvg59vf3uXbtCn/pL/0lnn/+w/zlv/yXefnb3+APvvwlVosVJ0fHFBaSRc9f0fcagTQbeu+RSSw2FxqUBqFoveatofMjeyK0AqylqKrevozL4+OgevyfFJmVDqWVi1Fnga6PXG/K72WG9zTWYpPtE+q8rOMq7bDOcjUSt+TEIv/cwLF3I2nH85Wc93u95zvG9EETVtC9EHWPqFxjimYIeNPZN8lO6Oxbvje5OH9N/b97JzIESPoNQOZfSKCj8rlOHPZqs+ynCMcktIqMwPm2JbSB6CM2DXQQY4xypCMHR48oioLp1oyqCzSbjSSzQUQGDAYfWprTNcbm+UuDChzk4FyGwAolwOBMofvuLAXNOkep6y7DN8egmYgVhOB7irAAZDoHQisz3mcfZfvryE3uKeZYIgmaa/O+NvRj6ZHqVIop19f6fUbezd9V1kUTfGL+0ff9vmQtBSEYiAVVMWMTPd6LCpOzlpCGoK1vd+yNnthLuSwN+3VvRG003ixksG2pCl3ODDZSqrNj5oOcUb394VzC6Kxrn4EtFEiSQ+t9S9e2OFfQNBn11s9KSYZWRk9ZTukS4GqVb5aEr7CW1Hnme3scHTzgF/7Of0c1nfHs8x/hxlPPEI3DFRXgMCmxf+kily5flL2eIoGSgKPcmrPaCODqNxu6phEKcWEhBS5tTTluPM5GRHim0z0mCVizWWMxlASapqGqa+aTUhKNoqBTilOeOZbntJVVSdu1SiGydF0PP4MZYJLpZKb0n0L6Q7pAnWd6WUtVlhwdHtKGSEi52Cv2zAJtipTOSUN9EnseU8IUJSgDBWMpJxPKzYbCWC5fvsx0OsWS+nljst6DPcziHwLEuZFkruypne29M3GdD16D7hw36rDMsVSw9zQbr3GnxKAhiqiEdRYidG1D0qA9EEi+IzPGc0UzxIjHi1ACYItCh+2aHqQeAzdytGS35gqpUF6lQmucpTGe5D11XbFZrkTa23sCaE+ToVmvKKqSGDQGIFNjtZprArHLgIjwKJz6hkjuYfFnbHuvrqXAiKxukoQyixklAT2MFgVSBmRS7u2hj83O+MGQxkbiu1bUz7/+RPK2/fC8siTGoCpOwi/P06zFAA+NOyklVaySwMRabYgLgaqe9Bsol5kzOj6mJIypCSY5Ep6UhAuYUqKqJqCbb71eU9UVe3t77O7u8sYbb+hQK8lQP/yhZ5lOp9y9e49PfOKTPH7jCf6Hv/vz/LW/9te5c+sWBw8eQIpM5zN2dnawFvYv7LJcLvskAOgldfPr5PSYxx97jMeuP86FC/t89Stf53d/93MQEmVZE4Ogv4KmCerTNJIMvf766zp0KhFihw8Nb7x5zBtvvsrOzh6r5Slee0VEd90QQotXJYGHDx/Sti1d0+rhtXz9a1/FWsd6veZf+At/gYcPH3Lzrbd5+PCALope+Kvffol6usuq6bBFjcXQhYgPksWHrqOcVEyrgqqsKMoS33UcrddMplO6zZouBKxJlFXFN7/2Df7BL/0iX/nS79OsF9SV5d7tBpM8xgindnd3i2vXb/DGzXdkyE2IVIUMpYrBk2Kinkq1pixLZrNZrxpTGHtm+FY+VGcy8AibTUNRhH7/5QFoKWRdbyfNqUGcwBDIZrUfcXnOiYJHlhsdVzicaqafz/6L0unnGbounOFnx5hkOrb+u22bMyptKdEjVb7z6vwLbCFGufMdJEvtCrrlEhPFCXnf0GhFUIIcz6/843+IIfW0j6qqeO57XuToeMnzL3ycj734SY5Plnzlq1/j5s23ePrpZ/hP/+pfw9rEV77wBb75lT8EKwFW4RxdsxHagvekFIgIwlSW0qfjQ0dRFaSRcogY4pxMWEE6e3UmDapSLvdG5js7Iq1rXF8VHVDOcaIxNJt7n7BJk01NPLUUkD9Fg/6sYiUIqfRSjBrmMv1i9FnjPzn3vfH3c9VV7nsIOsnrMXJSZ98/KcXd9nTEnjeL6Z1Enxz0mQvDs/kjkpjx575vNeW7/G6fQvX/l5urdeZFDHSd0g61E2AyqaVCUFhF7ZUSUJQUriKV4kC9D3SdVLPqiTQiT+qJBHJarZEBa54i9ygoB3z8fLMdyLLQ5+87xtgPuwqx689pvqMYhsGz0nCZq04Dgjp+ImN/NKyfvIRKEt6z5oV1ff+iV9VGq3x7k9dQFzmmRFIEONsTa+mvb3w92T6due/3218G0KS/61qarqFGWAQ+ONquw9pKWa/C1e7b1FNQ6pNwzHOCnvKZ1WRss1pz8dIlCudo1Cf2QIA2EPfBzjguJpMu89/GVBbpwEgm0YVE4bL+FlSFSGkHL2cF5cwbJB4oCpGYzwBDfhYhompQYAmkZKmrgsLCmy9/i7dfe41rTz7Fp773+zg4OuVkvaawjhg9pnAUk5rCyjC+zgeMKyBEynoig+uspZpNcDaxOT7EVRWlE7Bl5uYCdjmnk+QNXbPBpcDy+JB2vVTEXr5fTypCaGhbmZRdV5UGfbKe1ohUubNSXZQWM0NoPXVR9j2H0qScBLE2TocBmz4em5QWY2U/hpRYLk9lwnfwOe3FFY5yMqVtG63glYTUAgVtF2hDJOn8rvVyxbu3b3P52lUwg33xXmhekkR1lKU096cYmM3mzOZbtK3IRLdtO/jLNFCbQKhRbSsARN9/lCKZqFq4WsQporAxCucolGp3dHhE9CrNmqWGgRQDPoYhIS0KMj2pawQIxSSZ6l4K0yM3lRsMwaC0sEBR1jI4WvtyQowYV8kMOFPQtYHkheoX9Fw4V4o6mHPEYLh+7Tqdl+dfFSUP7z/QuWfZj8j8IoywPTKj4sy5Z7CBg73QVwznEv+zjI/8s+dn98DYpw1CIh801fjAiUZuys7UqYz+ys2nMw5gbMDzDbftSt9JbybR67pnZ10WhUx3DFGaY+RJACKjCwMYlORZq6yeTFVsulY2SNeJco8bsubJREpit27fpihKus7z1a9+lZdf+Q4/9EOf5c/8xE9w8OgRv/kbv8HXvvYVmq6lKuXnFosTrDPMZhOKUqQsN82G+XxK1/meEnNweMBytWK5WNF2a1whWWdVWwo7o21bVV5JGgSKQa/LSodQRZ3QKVQx50pJHqxTJBFBzFOgrCowgWQSvmtxStZNSTDlrlsLQjib8Vu/9TvEEHjq6ad59kMf5vU3b1I4y6/96q/yk//Mn8ekRNuswZZk5ZvQtZIUBs83vv51acw0hru3b/HSS9/gX/83/w0mW5P+IONb5tOaa9euEKJne2cL364pylp6arTR1xVi2Nq2oXJFHzyJPGUCa+m6gC2FS202DSHz9EFR0IS1unVFiFp7K3ToD4Z205510Ko44JyTQVhKAnbGaEVDHFweGGcL0/++lH1VstDoUCtdQ2VpqtqUIPPGWsqiVBrUCL2EPpgJSRCb1AdyAAYcNJ2ol8kgH0vnh0FaMXqIMhehtJawXgmNAT0XUST0Nk1LNamIIbC1s831x25wcnLCT/3UP8eHPvRRjk9XfPvlN3BFxXQ242tf/RqLw0O29nf4yMc/zr27d1itlnzqk9/Dxz76EV595WW+8PnfoXBGHUdUKWVN3pwlpA7rxFBHq3KtSSkY4uHpolYyYnYVcr6dnn2DZZjelTQRQf/MwhD0iEumSkY/gvY1WswOCjWmgs3S01fyG5k0NPGfL0H3hvePqBKMjfb52L1f1/4/MdTyO1qZiIPBzsh2bgIWFE858p026wVBw/pU6n2vMV9LrvgMgghZPpiUenWv4T3OOo8h6ZAZL6vFEhFC0PU1AqRgZTqzb4J+ttPeB7HHm82G4HMAZPoG7YxSts1G1ywgRI7Y06FkcNzZoXxJ7af4G/ozJL0wAtMmq3xsshLcqLlFn1dMXm2LPs8kgIOPQ7NoCL5f25Sfc5KKQPAjVUSTqQmQMLRN1zfIllUhzjuMkj9M1iSQoN4YQSojGCNKX/HMWqQ+wB/T5Yb1Htaw/4tJQid0Fownxk7nlZQaZOoEdsa5ipxNa3MnWn5Do4lglPkumiQfPXwkPt8VWmkSamufDGWpZ0Aqf9ILgu7DnGhY8tBLuTsfvEqQJ4gekwLOJoLvSKlQW6+DHjP4YyCpPKoo4WmfmGDFWU8RZ1T2V+lAvgvcv32T33h4j0TJZz/7pykU6Y7WECxsuoYYPcumwwdDVVY4IpOqlLiga+miINatD0OVugu0nVfQKlA5S1GWhE0n59HK0N3QiVzyZr2W3wuRdiMS7bas8W0jLIYUZB+5on+ekh0nmk1DYYWSGLqN2mfT0wtJidVqRTSOptmICqbaxhg9m82G0gmYLJULlaVOInkbQ8RpMpPLYEnXamc247EbN+i6hsXpkrqumc3mMrfLB0KIVNUEaw07OzsE34rC5vEhicT+3kUFUnMPH/2+y/M6jAtgKgonFU1jIHWeTbMGY0VGvhzUIUnSO1TXU6IPEKJ4bGOQ6pyORtR4QnqpklBtnVRDffJCWzXC8oAhEDeAwxJxhDaw8it29i9QTypR0TKG69ce4+Z3XusrASaNpHGTDPmzxrF/8TLrVautBo44iYRO1ix6mM2nwqpRSWyHgrPu/XxRvjr5e9H7K7UVkNtUtFqZR0SeBfby+8bBqMi5Ntm+8IFeHzjRMHbgjwu31Ugm7yxNs+nLXT0nVjd3jPFM0pEb4bLChI+C9EynM0jS2O210845J85QZ1WEoHJ6WtLyXSBTIIwV5SHZoPJQ1uu1JDBlSQhRG4Qjm/WCrmlYr9Z86tNP8+qrr7C7t8fx0REPHtzHOkdVlVRVwWblmc0n/NiP/RhvvXWT23dus2k2PW3EOUsK0quwWq9Yrdd0bYuxoj99erLEEClKRwyWoMGCwTKpJ4Tg6bpWymdRnCxETUbEM6IbGAABAABJREFU2Fy+dInVYqWlVHHU9XTC6eqUJ59+ips3bw6bJ0Wqqub5557n9u07PHp0yPHJCbPplJPTU2bzLZ599lm+/Adf4fOf+y3+6Z/6SUHLQyD4gLFFnzUfHh6xv7fLzs6UL/zO53j37j2mk5q6hL/9X/9Nnv7QU7z4iRe5desW7757j/v37nLrnbexVug+1kqDerPpaJuGsnTURSnP2CgNxRrmsxnee2nQTjqNMkSigU6HPZFRvChNiZK2qFKGQTikGvC3rVTWgg/9PhRVLEkMkiYdxhiZho404fa84JT6Zk9jbB8ww5B8iFNXKoWTMm3ShnjjjM59sT2ymNFLQSMQdQtn1dfKe2cJXLkIDdJBJftywCjBWky+R/I0PpGf1Z4WV5VSYVAKVtOs2d29gPeBl195meVyw872nKeefpKtrTmHBw/58Z/4M3z1a3/Ig/t3WS1OCFGaGbuu5a2bb8pnqJKISH/KvWR1GauUSRRhy4lhz/t0FoxUXqyxvURw5ukK8jPMY0H3c04o+oZumwNlDcRUpSQPLcrBYK4O9KGaUe63Boo5iI5JxBTGqHfeB+NXBlbGg9j6n1Ow5Exbk15NUkU3oyif6Z1cTo7G1trknIw00nyPQapjOabIQfH4OscY/JAIZXM47Hn0E8+kJdlBnXMcBrTHZkiAsndKhl7GFQTMEV5zwjn5WtfJoD8J+LUR2hgwg5pJ0zSauAvg4DuvQEBeJ9MnGXmODZoa5OMiZ1SSuPFzEW7zMNV8vJaikiYc9hQHjE7oTmKLxXfofWcnrXs5V2D6ORvWEGNOWIzuN638jJouTQ7A831k2waScFhRsAkxSJg/PP5xNtAnwuf/PLv9sj3xkDyiv5Qbuw3BR2yhgE8PiKR+v473SkbPxS/LmhRFqTQM7aNw2hCerMAw/X4bJSv6DHON0eh/w6bO4IPrA5pcfYzBi3CJsX0lZjizQl21thCBiKBVJGPUpuTGdP09A5ZEYQW8Cs2azXqJdTWvfOvrpKZl/8plLl2/xnR7i0Sk6RKTqiQk2TeVLbThO9N5PDEm1k0rVT8UiNXnELzHVxUmBgpVysJYOp+YbG1T15U+C6G0HRwekXzH5WuPQQxUk1oq3OQ+GlVqM+ATnJ4u2dnblZknwes9GxlCONsCTVLlLDlcIVITcjYGsY26qntA2DmnsZ8kF1nZKdN8pLE84JT6boxhNpXztloK5Xm2tU1WtjJAWVQa4ApaP6knrFYrNk3D9s5u39eRK78pogPv8v6RmW4pCiWzcNXQqAzD7xihSSaNKYgiPS0A9JgWJH8Wtuz9teTIBmuFlh9jkEG/jPwMItZhjNTkQkhs1i3zoqIuaxanp2pUne7j3CMxAhuS9HIKBbdgf/8ydV3RtQ2P2nf7M7S9tc3p4nQA+02OZ2KfWKVse/K7m9F5y/+R7y0Rw2BTzlfAs1/L/Va9SVFMJJ23NX/E6wMnGqWWxp0TVFeawYWHW5TSKZ8Drjz6XQIPcfbGiC55DriIqW/6zmUKKavLQZXQQRIcW5SSyceASRZXqNxhzBKEQ9DpnGT4IUbapu0DyxA91sg1BytzJ6IRCtTrr79KCB0nJycyodKAwRF8R0gBZ0qsloaXq5VSc6TMOZ1MCV2gnk3omlaawowO/3GikNB1ch1R1Q5y8iULLwnctJpjDPjQSYUgCjqXHVxCexCMNJUHTQxiVg5I2X7qpjAw35LhRSkJ5WEymfSNh+vNirv3bvNrv/qPSVj2L1zmyrXr7Ozu0/nAzZs3eevtm3zixY9TFo66NjgbIHVgDZ//3G/yzjtPcP/+29y69Q537txicXoiEpRGKC2FM8TY6awRCXg3TctquZF9YtUpa4NhnqydcsXAaPBgh2Ashxi65c8cAIl/5fkWroQUFDFTOgIqtdwjulpiLaQh0Ps8mTgH/EJfyEY5YxjWuh6ptBaJ8g0km/rgOYaIc4WqB+n16f3kIDf3hKF7mJiUr40oKuWgKSaSFZ0Z5/Lgq+HOc3XRIM7ZWEs1ncj+S6IUdnJyRF3P+PrX/5DT04YXP/ZJnnrqGR5/4nESieXJQ4yJEBtpGm82XLxwkRg877z9FjffepO6coTY9TKYZ0qthj5JkHhBDLussfwvhRwwWIyNUkXQ4LcoCtabDc6WOdQZgsOUkxe9555ZlN6zP8bNvaSBdtkPy8vBugZWmSrXB+txUGcZHrDutZ6ylX/GDO8Tkjarv7elPKPhfeCm5753ckbO+pmgrO+S1dJ8yAc8u8Rx4MbofUb/1MAt9d/L6O6IdtPf69mkavwm+SesGdBheXZGn4f0iqQkE+itUWnSJJXwaDVIUZ0gyRkjFkcMQfjt2kcTvUqWx4E+FpRKlhuc9UTrGc5ZBbLn+oRilJGZUdKYE0z9uRj7DgT9/VGlPsuzWsgDZvuzCj2qmfRa5d86BRvb+56U986w3AwrIwGbSFhKEGejpahrEoGmWY8WQxMvM+pEGt3/uTh9+ILcgM6x8YjbD/36pTSukOg5UqS63yujIMZaRwyyjs453KTo7ZrpN+G44paXaQjqcrDbr51RYMXk1IP+jKRzv+mcJSKKdCSl00l8LLMs9EPzjpPVsKMga6ScqKfCaexXWqF73nn7dcKmYb05YdOcMtnaIrmCrd1LTKsZ0cjcnlKTtKBIubNOlNPkKZJMVDl+A1FsOBGCT5RFwfbuviyPbymcYVqV8rvW4ZPEP0U94bH5NgaoZ1Oss5RKRU867BIj1eKAYe/SZS5cuoLro2V5hj4GLl97DGOdzBbR6rIhqyxJQr5ZN6QQCV2Hqyqy2In0RJp+NczobG02DcfHJ9R1Sa2/03UiSZ+VHNfrNbP5FtYa2qYlxYBTUYi6nrJaN7iy7GnAWRo7QwAGyINYs4/tB+JaaVLOA09lY0jSrnMGFeAdkqdM0ZVb0kqsDvzLfYXWFaJGutlQF1N88Mzmc4KP2oti2NnaZbE8oWtbEonNpsWaFXVdYxOcHh/rUYyiVtXvZHobOZvNJakxjsl0hnOW1XKpTfMy1K8sCq3IaHVa7zPb9T6uUbti8hqBChENLXjyABWgyWc8DecsG5TeDw+moffvf5LXB040Ci2l2cLhNEAUbnbopUQn5XS4zN7oS5ZnkqylzYFGhNhJpaLtPMvFatj4xqhEmTS+VJOSGD0hJUwMGJ0CK9J2Om08CZUjBNMHDjFGqrLum5k36w3T2RRXOpyivS+99FXKyrJanbDZLAhBFD5WK8kaI5Gm3fArv/orfYUkc3qJMgcihgAx0TUNCajKEmuMSiKqckjjB1UO3WGd3geKild1je0KNps11iQm9YTj0xMePnqkBlWeXfRBVJNS4rXXXj+jgmOMpWlavvb1l3jxxRd54YUbPHp0wGKxYO/CPtWk5vU336CeVFgL/+V/8TcAw4sf/wSf+tSneeLGDU4WS37n85/j4YMHLE7us7W1xYWLF7i4/zHu3rnD1176KlWVePToDr/1G2/QtA2ha3oFiETSpLJgtVrTNo1IUiY4OT4RqoXOdpD5DoszlTD5npyMvBcyom1A+KpGEKo4CkJjjEQNZnOiJs4ngiIhKUWpYvTr40Tej+z41flHmYBqrJZgrYQjIQgtxCj/1QosRtDBddK8LQOEojLYUUfbN4oG7dXpg1KpqMBQ0chXYgGTRDo2WkPhpPG80N4Jr4ls8mowrfSJ9IGtZJ907Ya3b75BTDdxbsoPff/3E7o19+++w8npMS995ct86cu/z2RSUE8KYoDdvS02myWPHi5wDqKJRI0oZarryGrp+XYqhSlBh/RmgFQeoiLAw0RSQUYZVT2wElhHretmZ5apPykljBrIjKxZU/RGMPeA2YwSax+TyzYh5Gqh7ocQsc6Rp6bm5zZUHiQUFCpGIg9QskYGXqWkalgxUVSONgzzWcYJjBkWg3HjcTbiYyqM2Pw0lKtjIpf7YxorcfWZy8hS5ypXDiLToLc+Crj7PKPPN3JYeTbl6GPV3OSu6Gm+H6/VZgvqYC2l0+pzSpQqcZu0SpssYIXmGKPpUVOSqPcE7/tkO6WhfyX3YkhAO/49vScTkRVK8ll67c4JCIUZ3lPWX2NTH6WNIRqlj2Tklr56mXIUq88ihqhrYgbdeTJmnxNOoWxJgq0qbMZob1Dqg2j502CKSoKlJHZrOt3G2kjTdCSCLoTYvBQDeapy0s/uNfLVzuhXZbi33m0InrZrFBVW8QJbqt1S2qKV33dOgtHeIhr9HSPN7fKx2lvE2f1lycYnjjbTkCowSgTlaOf3Nnm7yzqG0A+WkzNhMLYQwYkk4ip5UGB++0KBRmKgVHXLDFrlRBWrSUo+H3roDdluSWWynpWsFoccHT2gi4F6a5sPffgjlNM5exevUdZTUvIoUA5JbH7en2VVYhBluzzoslJ03VLgQ2K6tct8a6v3hc6glSzbn/+s6BVjxJWFgLfWyfMpxLUZK5WZGD1VWeJMgfXS7BtToula2m7J0x96jjY0+CB0rq5rIYgSVlkIq+Lo6AiMYbNaUTmHNrj0a2j1EVubyDhx0zSchMCFi/v4EAgxUU8mTGczGdK3aWg3G2bzOV3nWa832JSoqpIUDdZJAF9WFQ8ePhTboXFUTugEWVe7acA4KF2BzVVF0FlMjOw45JkYcu1GADA0acGoIILY/oiAVDLDpKAqa7Z39lhu7jPf3me1WXP52uN0nefw4BBr4fKV63DfcXJ80it3LU+X+KblwoULTKqSg/VDBNg0IyBA1jimpHGTZdU0nByf0HUtp8eyDil4pvM5m9WqjylzdY+UBIzH9DZufN7kWeT9P0oc1AZa52TuR0yQBhs2GEg1FXpOMigz7gH5IK8PnGg0TaOGVRbDKEISY2C9WkugXEmjaz/QD6FX1XWNbzva9aa/SJIMNjHaAOesVCOytFd2xBajylOqUtJpM3DTSICO09kZeSy8GtkcTIbMs5XPkQY4QfhzE3oKgvjmZvX8HmJsdVG1BJ+lyWJKeG0CreuaTiUYnRPku20apW05QkiKdGgwrUgZRsrjIJWV3Lwm6k6J2WzGo8MDZjOZ+yHKFSIN2TUNRV1TuqLPNsdIbNd17O3tcenSJRaLBW++9YDX3nxdBgS2mYrWYU2kripeffklXvr6l4V/7yxgefrpp/mH//AXhYtqSm48foPr166RYktZAqljUllxbGWFKNF0GKR5mhjxjTQixyBBXulKrJVANSgfMgdMWcEo0+TqohJ97xDEoRhYr1aklFRKGXz0IlGLAdXWtrkkmjN8TUQFHPdYV+BDK3tYe2OiJjIJTegwpBgwaMOrSrOkiPCdA1BYqqoEk5vTkzb9lRATvgvZnwvdKQjdLsWzAajkMT1m0zvrZDKWowYiBtom0TYNGHOmEbaniOme9zFqwJV7QxLGiNLbZnXKP/iffon1ZsN6s5GSfGWpSnk+m2aNIfHWzTd58/XXZM/VFa6AlIRmYkd7LWmwZ9KYz55nJqjx06DC5gTSOl0r258v4QWnPsHsDWIOTOhrI32gPbRwm+FZ6zOJaofQ33YYwZsjw3v2KH1/N5ixHZF30jU6OxgOziYIw/yVoVfju/V2nO+nSPkisyMwg7G3fSMFo+syOb/WfT5cbV6TsynDdwehhmCMIfgb/ZLsvTR++zPN9BLE5snb42pkYjqdai9aotPzbTj3GiGv/X96+bnaJQNch3sanJw6ScuZJN2Y1Pdd0ZvbwZb3zyPJ2XA5YRyW4cz6nP0j9YkDSZIUqWoqzzmNd5RQIiWQlqhMEiNVVtK+jmqyxXS6RVnW5OF4llZ51BKICwYjdAfjTAY0yclr/2xN/9Gyllpp6dYNKS6YzXVspRMlMTO+6STJWohRR1uo/YwK7AQFGchg3tmBukY3h9xjDnxSNsPyr0yF7KNByFz/TJ3V2rII0ml8gHHaVJ9ZErpTcwLar85wLvPPRCIhGkkCrCLCuo7yfOSaCufIM0tSksnllUsU1hLbNd/8ypeIPvHn/rk/z3RacbLYsFo3mmwklusN29tbnJycsDSJ4FuIAZskGcx9I81mI7vNiGStcXIfPniZ+9B5yqKQ4X82s+elKlEUTnj+yWBN6tWTMAIGVVVFaUtSI+pKzsicIVcUQpdJhulsTllXdM2G9WLB8cEh0Qe2tucsT0+ZzabYlDApEmNH9F5jNIf3rT6/2Mc0k7rmySeeoCgKbr3zFgC7u7vM53OtTBTs7u3SNC0P7t9jUlaEznN8fIpxlid2dti0Imqyu7tL6RzNZsPpySld53n88ScIIdB2HSkP07O2T/xDkL7Otm2xhYDIJiWVCzaDehkCvAgNVXqEffDY0g4VyqT9X11DaD27Fy4hGV2JTw2th53dC2zvXqBppJKzf/EKMRgWp8f42IgNSBJ3fuS5F/j8/Qd6raH3h/KHVOOOjw9JppCqkbGEtiOOGuOLouDk5IR6UtO10qfhnBMhlJTGR34UB2bQJfurfH+M7jX0Z8f0xnJk/Iw5857OFarIF/5EycYHnqNRX9zHGAkkZCAJGvANOr5Z15eMrOhx77pO5nslmagNo2ZxIA+Gz3WdfPHj9xZuuqDRYqBFEaHX/NaH7azr3xug65q+FB61IjOZTHDOcf/dd6Wp+pwuvXNODmEvPWp75M5ZMXqFlvy6rmN7e5vNZtPPZshB3+J0QebLOZ2u2qvpIPKwPgpaFRkoHNIwLj0lkdQPmTrDszNCB2rblvl8TqMSe2l0D03T4NuW7V2ZI5DLxVm9qu1a6XcZoScya6Kk1RkZQedU+E4CsMI5QuhIPhCywUmxV9USxHeYatk1vg8wrVafvO+Gg4boeBuMypCKwUwYvO96eo7QxCSRiz5QqDiAtfJvGALAvN5OkWoJfqMqeBQiwehs358RQlQqs/RMOCfT1UPscFYH+kWhGhhrtRfEUU8q6mlBWYnDbjtJAIpqQlIaoAT+kaZRaUYriWd+DRS6s1hETtrznowxyNwKRe/GyThGKmLn5zuI/GQ+U8JZda4GU+C7TDOSAMLqsM08YTfPd3GqFmKdBTcaTKec1xCDShwLc3Xck3WmKjD6uwNtwg19oz+giZNS10LokeOeIsFQ2cqBihEeJ8Y4pW2K5LNwuQrK6TY7+5ep6ymFMXTtmntv34ToyfN8jE343l7Gs9ete1TWqjizvyTQzsmHVJHa0Ok5OBtOv99zOLO+vROIOX7tFX4clpxVpJzMyDYg9AHX2QSIHNQgPUO6287ss36/nUF9+6P53peCzv2MD2dxpYIvGkyKtPTQtyH2RjTyfYyiOpZST5kYJ5RSkcxCAfJMc5IhNiAPukrD8897whpyk32+lzG1byy3mYGwbFNlT4oHkMZYbYYu8vqE/n0zspf6BVIqZVbFAql0hwDGYSnxKkcsiQZY49i+dJnpdC7c+i4KTJybh6MMSJ06z+1bUn3umqXYW2tE2SvTJXM+moOEcy+DDi+zBWApioqt7T02TSImp/eRlbDO7qNAfq4ZDjL9bJO8vmNfKxXDwQf1PRH5ulLCpOH70oNkxY87aYiVGED6L6wx+NAh5A7Z1CEESQZSoiydNtTKuQgx9kDkGVqiEeQ65P4sJ1USo6ITY2DBGkMIHXVR9rOi0D43WziSccRkCJ3YpAuPPcHjT32IK9ceo5rMZV65cdx/dJ/ppMZZsYsWiH4Qwhh6PI3KI0ea9YaydL16p7OjREn7X1vfUZalxDpGKjMxRpJJtFFozWUtQ48r4yjyuhUl3ncUGB4ePMDWjltv3eTo4QMshrqqmBQFk0nFg0cPpAepbdnZ3uaJp55ia3eHaHSOD5HQdpASx8fH3Lp1i9Jabty4IUBgEJGHw8MDlqslW1tbbO9s90CstZbSOg4ePeTg4JGAiW2Dnc7Y3d1la2uLcfUZpN/26OiIq9ce63tQUkr4zuN1KOama0SJSenmuUJUGsutt24q7Uj7csqSZIRtEpPHVSX7Fy5wdHSCb1tyFdAZx8Wr1zhdrrGuYNO27F+4iHWO+XzOkzdu8Idf+jJJpbgdsFme4ptGbKK1bM2mNOs1bbvu925/zhCFtd29fbAFe/sXCDFyfHTE6eEhhIayHHrMrBvi4q5tqep6CPZt3u9jX9PjIaNjqAlCHANTSSqqCjPlqnCOVLLfKksZLJjPRowRv2rfY3fOvz5wRSOXrcs8XVWHl7jaUhUlWMN6vdTZBblPw2nZc8gUYeDeFUVBF4IOURF6FmYIoqQRTwd7+Y7AkEhEpKJgR4Ndxq88syM7iSxHm4BTHQpV5NkfUQY0pZQb9yKL01MZXlPX/fV67+ni2YF/0+mUhw8fMpvNqHQYTdd1QtcqHIUV1Ll0pU4BTdInEmOvwFOWDmIuCRpMqVSelLPv7HgV1dCkJxurR48eyfVMJYHKA+uqqmA6ramqoldRkTg1l8gizWZFiirlqgY6VBUYQ9M2uFKQOJMEQdu0GvAbi29kKE9WGhFUKFKXJW0r6GVdTUczEzI3MsvISoCouSkhRFpt/i4KR13N+2DAFpCsBPzOFb2TT1iSHRSpTBoHLqLKZYxOWNW5BFVVSdkZ4YoK7zg3RJo+kM39Ijm4N6Bc+URIHW0KBO8oCqE+hRSxrqBtlvSoPiJtGdoOgjSs9wf33PkaB4HB+z7iS4oqj185mc3UmxQifoQZDHK/cuGy9zVAiqIWFUYSdikozSQmvG/7HhWxO0FmX3ThzDWkHBRq427s7cR7sYseUTESwAjgAOcD35S0gfhc0JSpMn3ZHAbCaYyQB/Ih+ypqeJJiIHQNsa7AlQgxVasrThElUFUTPRWj82btWUTn7DUPlZfhe6kPht8vqP+jXu/33BzZSzCoZeW9n5GsP+ZjhvcdHNz515lEd+QIzzgtB4ow9c2vphdGkOee7Wx2RmI3BTRpvcdb2ysYjj9vHByOkwNrh0p5KuRmY4zSQB5HP98H2j3Mf+aVAaBefz9XulI6U53TpzF6qLlaEPqgJyeYo9PWJwgh/zsPzPMRTMn23j5bW7sUZUXrPZtNi9fsVprhYWd3j0uXr3Dp4kWcTSxO7nHn7VfZbKQ30hQFKYS+iuCcG9QZv9tLxrArtdJhi4rZZML+3pytrV1IwzRv6f8bho+2wUsjra6P0c8ESBE63+I7AUBSHHpvRFTk/J4abEVKIkkfldbImfWTLpeUElU5wYdOQMaQfWWZ35B6Wo9I5/nLqafGigqVKOaEGBRMs8jgt1LUHI3pG5RjGJLU+XyeyWS98lupSHkXIpP5nGgKQnI8PDzhztuvc/2JJ3HVjE0b2CyWtKsVMXixdSn0Abh10qMRFOwQrE6e2XqxpCpKOt8CSiUMUvn3vmU6ndKlThQbExQaD3UxsPaeNsuXhih9UzoAeTqbyQiC9Qah4hlcOeH6jaeYVSWxbTg5PODqlUvcePI6q9WSu7fvsFwuufXOTbZP9yRmaUXZM+rg4xgjk1ImpM9nMyZ1LQwXY7h27Wq/Jvfv36csS+Z7ezoqoWRS11y6cJEnn36K49NT3n3wkKIouPPWW9TzOTu7u2zN5r09uXTpEu+++6C3CXmkwq133qEoCp56+mmSSTS+PTMzxzlHaBpcUWrjuwCfxlmis2ArAolr1x7jU5/6DMYYbr75Frdu3wFjOT5d0jStAAUxsjXfpqxrDh494rdf+22KquLi/i6bVcPe3g4pXubo0QOOHz4ghcjpYomIpxT4EPseZxA/X1QTfNdibODendt0Gu+SOpG9VfAux1DZPxV5WLKes7GIythHDRlGJFOn3sdEauU1Jxl9meOMPc52/0wy/wFeH7iiUe3t9tQiGeghyGJRFlgDjaLPSaG2pLdnc3CZLOv1mphCP3DGqFqDcPZRmbd0ZoP0DzKedQ6QMIUOZdGvGQb+d27oDaoIlZOFTdOIIhDiuD/1vd/LV7/yVcpKp32r/rEgVTJQLXlPWUkzdVGInOt6LYcpSzROp9Oe+mOMkfdICWdLdbil5opyrVnad5zlDwicBOzW0feEjGHGHADk9xGN6tEgOWOG0pqVwVNW/04aZkGgVQRDbsQMUqp2DkyUiotvsYUjIolGjIHoA6UtBe3344qLyvaFQCTRtl3vGLIqTPBBSrJGkJuyLuk6SQplortTS2C1/DgEE1Yb2UvnCNFjSkdMQp1KIdB22mBm7QgVRfaK0mq890I380HL1FM5vL2/1mAc4czGTEFSSED2oKCsIQaR642elDymtJiiFB6lPu8xKgNiWGQoVEac6dET8bUZuxvmg4xVjowRzmYfFJ9TVerVLFRjve8jMRKGYwotG9texc06cXQpBfLQM5n+zZkgN6NIObCTRzug0TnpcdZqsKLXZBgqhggS2XWdNvMFna3hmEynQjnzvqe0SYI30CjHZyALKwhqL2fcZkK3sQQctqyZb+8z3d5mWk/YrE5499Y7hK7BjoIhm7RylUKPWhu99lxlE8UQuad8fqxx/RCqPGCxr/q8T7Lx/gmLoOhjIEahKbl3dS7JR107BW5G696zq7TyIbsVUr8lzlZD8+u91K7xv9LZypQBXKbWhH5KsIAHOtcoDs2KXhFcrKMqS1pVrklR6HBZTEQqGf7MdeREPT+PfA2SXEPXqgIfisqrPz2fJMLQvJ+TgXTOSRp9bpKm5IoGOrV9aC4fQAcBNMSHFUInjqOA2VpMWbO7u8+knrJcbAghMJ/N2d/bZ2d7m7KQZ0KKNJuG4+MjDg8POT2VplJjEtF0QB5u6QUZNxIIJNDqssj79uKUiuSO1zMl+oqtMQXGlsQuygC2gCTgCqwYZ3tgwvtGaCij4MSQ6Y/S9CxHVJtsc1ygvRwmf7ju8HFDvE32bLBiBh+XleEMThAQO7LJuXqWoCiLETl05CvSiLpoch9N0l4Qg4nSP5PpaANsO9AwjS0gKBU2KxbGSEhKvY0BTImb73Ltyad58kPPsb13EVvOmM92eHRwqHtG/YfJtEI9Azk4DNpzo2yQZrVBJoBD227wXsDJ0lm6biOVgqNDDFL9M8jwVGMLyvmMJkaZPVII/ZogSUHQs2e0TCpxQYeJkcoYCpu4/dabPHb9CtWkpGs3HB8eslpK76wM9xParrVWlTWl+V2StMBsviWVbU0ERKVQVihPkT88esTe/j4m0b/X7v4em7bl/v0HXL1+DaeTx09PFqxWa2bTKZcvX+Z0uWCxWLKzu9MLgHjfcXx4xMWLFzldLlivVuzs7VHW0m8SQ6DA8O6tdyirGisoEPP5DAycrpZUdc26aSnrGiIyAT6JpHxRVFy8coX77z5ktd6A97iyxNUTiqqiLCVhKp3l5OiE9XLBM88+zWaz4u033gCVooUIvtN4VasT1vRqi0U9YXt7m5iketOqDRja65LOTwt9TJBtnTW5129sy0cAkRUq5LiCznt+kh7AQsvh54Gm3C8X+nMsNq87WfPHvf5Ek8Gdcxpci/ygxdBsBoedRlNxeyMSpLeh1AnPGcAYnPVwzsdDlDL6lJ11pvv0DtwaXGHpdHqrfjA5XrTa8+F9YrPZMJ/PyXSa/GSrSuhRQrmQ63GFw0SL96GvWpBSPz3a2pKynJDLtSL1a/tyZ77/fB8ppb7nICcvOQHIv3s2IDmLCLsRojQOXjJFIfcG5A1o1LBmvn4fvJiBey0OXpoQU4p0rVybocA6cVbOloLGJUv0SOJkBfmXWQkJcIiYRsKagoSh2XjarhPajivxXWQ+nzOfz5lMJoLEBKjqmiuXr/CtV17GmoILFy9y4dIl6smMtmlYrVdcv35dZisYCF3Hyckxt2/f4t27d1kuT/CrFfVsIvMoYpQEw+QG0tjvA2NUVtD7fs4Dile1bVC5RAnWnHHC2TTmrCQuQnuzRYnK64vx1OqRcU6C91aGI6Ug8yZ6OdVc/jemp0CO17kPBoddIGfiHNIrSffZwWGaA2nQn38Gkg4hSlilRknEYbFEI4ms8GwTEHUycBL6QYj9heVhS4khOM5ysIwMUb6MvtzfB18DdQXoe42SGgNXln1Vre0aqebE80bzPOo8fCelfO+SoPcwhzZY5l/NdspaGbQ0NP8P72VzEpWTOgYDLonbSKo7f0yfkNBXGsfn9fzrfAJy5k7PPM9M6ewjoeHvZqi0xIxQ9csxBHg59Hu/z39/jGn8nNN79pk4LklkbbI9cAJZ5lV6ieR5SzJb2oK27fp9EE0iBlGny9WA8f2PqU+5AnH2e5bzr9xHMr6nGLMvyl5h2EeGkf+J6ez+pc/XyT03GQjIsuwmyQCx2AqaX01nzLd3cGVFMJbpfIvLl68yn85YnS45PjlhtVzw4N073Lsl8xJskMpijDILqfOdVGFVJZECqXar7UhIRTqDa7nqOA6W8+qNE0Y9jXJGkAb4iKVAm2DjUBEmJwBBbMU4KRNgQdvidb/1U4QZQLT+K5kHrv9v8/4xcg3WKtVMv2Zsnm+QqVGVzAkweb0iTdv0QVrwTTYvw9qZnGzn9Uu4sqAsK1HFzIIsiZ7jn2KiC14mQCOsgqQBaU93Vm59UVqaZkmyjmpW40pomhUPHtzjZLni8vUnIEQ2y9P+TMQk1KaUpK8VAl0UwYropcrjrCF5D9Fz8PA+k7pkvTpltTyhbVZE35Jih60r2vVa1iZEqnrCfL7LdL5Nd3oM1YQ2BgrraDdrou6pthW7OqmmojrlhYI2qQoqZwjNhq7b8M47b2GLROxEkj7onJpgdG2Cp9PzGAPYoqSaTEjO4ayVBAztt4yh7+HoTEdK4qPXyxWGoSczajxHDMynU2KM1GXFpJ7QteK3b7/zDska5rM5zsmcKussbSM2clJPaJqG3WvXpTK0XtO0G1JKBGMoykqBKokBBcQOJO9JRUEKkWaz4crla8y3tqnrCUYH75WlMFUuX77MyekCWxQUZdmDiW3b0UUZGjuZzViullgDe/v7HD18qAXRCC6rMmbfnvoYMGp1a7Na4nNM0TfdW1IahJLy2c92cphx8f5AUlaX6+3BuYQj4zT5lRVB30/qPZ0xNGc/6496feBEwxqpFiRFtElJ0K0UCIGeTnVmyBk6EC1Gog2UZQFe8RjD6EHF3pCQb6eXgVUkStVrgk6ctcb12enQlDg0p+RyE6CVibaX4C1V63syqTk6POxHw+dkRqhAJUdHR5RFpRMx5YEGLwZnUk1Yr5c4M8imSpCerzcHrVrCUz68IByOsRPvFZf0IBhSL4s6ThQyCmJ04fNAq/cLRsuikN4D3Ubj9ypL+R7J0Ky9lPCV6la4AqvN1WUpjYqbdoPv1mAM9bRmOp+xPZvz6MFDQUxzQImhqGt2L15m1Wy49tgTnCwXlFXF1tYW0+kUG2Cz2HDtylXuP3rIZL7PY489zsVLl5nNtsAYDo+PqaY7XLn2JCkGysIRfUdVz9g0nt2dCyzXJxwdvouPHcfHR3S+6zP7GIQ7mBWwQkhsbe+ys7XD6WLJ8cERJMPVK4+xXC5pmk3f3wIRKT7bPoA3itoQUo9mxTRooBsdThejIIemcD3ybHLdQqk5trB9UJxfZ8JdlbU1/TlQqVZdR6uqFe8532kIuNV767prQKzQtlDPJPyU/hNFuvJMjB7+TEPQ3X+AflQaLiDvt3xOe4oUw8+acz/rQxBjJj8wNOGO9nAyRhu2z9yiAinaIJ7/A7KWeE+dsaZHSXvER6+vp4eAII0jNMj0qLDaFN0EKUtpj6gaRqMaSeJ06Ywlq3yMn8F3q3B8t9cZ25hyUJnIAxIxOS0dosz3VE9AnuMf8ZFnaV9DEpzfIdskSUWTNLUah1Wuvqh1yc9FpRXGTGlCQI3hw1BJocFG90FqGpKrfF1jIQ+h7Mge7p+nKmDJm+nuGDldcvLR28dRVUcvKFc+SQOinhON/LO9U08o4OAxyTGdzriwd1HAKFdgrKNpWk4Xa5rjBffXHZVzdF0rja7NhrbZKAdck34FdnIPmyvkOion9JncsyOovoB5CdnvWCMy2KMHnO+sP7P6cPu9a7LCDOT+rAwaGE1QTZLqQ1VVEnSb4fsmZrEEepPQJ7ejzx6fZ/nakPDnx51Bl15JLQbiKAjySoFBkxBnLZNJTQhRfFhPG9Pzq7bTqipV0ntMSfw2KfUzYWJK2CDPIqrUqzFR+/pUGMDZgTpZWAUZAFtRTGdMtneot3aZbm8xmVZM5xNCaFl0nqbbYPSMBLUvUsmQ6kYXPQ6pihs9L8E3rE6OODx6gEkdzeqUtlnhuwY0MQ/WgPe61pZ2s6ZdNzSbDftXRbrWWUPbNEwLR7KJtvEkG9jb36IsJvhOm6cx1GWJSYHDk2OC96wWRxSlQct0+nzE7wVUvNFkmhx6liUYT6htdVJpyH17kEg65LUsCgnwUyKETvs5hXYcgufg0UOpcuzu6rWJKZ/NJiQMm/WKdrOiqGqMdfiuJXQtpMh0OsE5Q9M0tM2GrpWhw97koDn1gXumnScN9iVJtUpjlCnnxkrlTqTvPU3bcOnSJYwOchS7ZLnx+BO8/tprtM2GCxf2dfA0TKcTjkiQEwRjyeMH5EjrSbHyHFerBW3XKiCjEJGR5xmCnIvBz0YFVceAkVGhg3yGhiM3Thry+RqDTUlPke3P8vBzZwCzEcPiT/L64AP7jAQphIGrOn5lvmVu3ssNoq7nlkVcVar8m6r8nEf2RkoSAxKl2ZzeYFYucdnBmbFc5nsfaOaU5mbZjFQ4zcDX61Vfvs+8v6IolG4ljd/dSI2gaRq6VtSGUsiN6llmL9NhMheevknN2VFCpbSupA3yQ1KU+iA0ij5r/+zfb3H7aaicRb4BLasqRd9IQzLkKos0IF69ehVDoUPxDOtNy3q1ISGqFJOJcKNXzUOsrTVh2OX61WsyeO/+AVcuX+3ljVebDW0IzHd2uLKzy5Vr17h17x5lWTLb2sK5Ar9umZkpi43n9Zu3+NCHP8yla08wnc6JMdF2HauNZ1JVPDo8pWs3bM2n0kyXLJevXGN7vkVMDTffepWbN1/Tyc70AUU2ZLJm4gBdUVFOZth1x9b2Hm0bePa5j3Lv3l3effcOq7XMT+nnYOgMC+dcP8086LTeDBgnYLa9RQyettXmL+O0wdCAkWnqTmeq5Kn1732p6elj+Rw0nXXW4iCzITGMJ0z3E3f19+RYCYUhK8Xl5m+RhgRjMrqSkyI1QAhAMFxbvo6zCEc2VvnM5v/OoipnA1k5lFa43+Q1k++NqYdyrMyZ389JT4/gpHyvuR8jDfGOJgg5gMs/HuMoqNLP6mdpjD9rfPXnEKGB7kGflAz02Pe+x/h5jZ/DkHgMqiHn17sPqFN+tqPnaLIpHqobvfP4LmIg55Od91Y20vlHfuauMoUm98mZOHzQ2OHl6+7RQ/1O9gs9YmyG/XxmWZNQnnL1SCqTjty4a61TpDkN7ki3YE4kZJXf+zxN/k4+C7r2/VMx9Oj76OZIyHykyhVYHEVZUlYVVV3T+Ui7aVgtlqxPF3hFYkXbPqrolCQVztEHMXnwn7VOq9QFGKlYt+2Ktt2c4ZtjtBk/RZF1Hu6s/5u4orP3bXpqUgJjNbaJKpaV+l7K/OwSMJtOhSZhJcg2+ozt+HznqIlhEJwe3rPnBPHvuRna5v6JEOm6lq7tpIE+B0CkobdP9/xkMmFvb5/VakVZVb2PO5PIk8A4iRm0uta0DW3bDXObst3Q340qZ1yWBdWkJvgoKpHk+CIHhXIPxbRmurUDhcyLiMnTdRuKbgNriysmBIImplohQSrmogsQMVbEWfIMJql8eBaLY9brY/zqlOA3pCgqjiY31odA7gMzRuaZrFfis5546hlCstRFgfEtqWsJXUNqVxA2lHaCiS0mieztdDpjUorylNGo1BhUVpieSWYTGLI6kaqDhqCghFLibKLznTQuM8iTx2xpdRK7y7ZYk5Bk5JxnZsbi9ERjs0yTlHW/cOGC9qNmtUhP221oNmvKwpFSpG021GYi/ss6necBofNkEDvTsdu2lX7iTEcyMn9qcXoKZjlQwCYzyqrGWRl6e/XKVZKBznu8+rpJLVQz3zVYm6irAu872nYjDy8EoVgmhJqYotoXjXm15UCmm5shkc8/Q14bM5zhbPNHNPH8C4MlGMURnAU33x/w6kmIkDijLDW2DYwqyv9/r2j0yj3G9Ghk7EvkWcJPdJGlAVBmTGRkJaMWthCKCSGIlKoa9UxzyqovAz0hkdH7YsQRT2loirY293IIPzxr8udKge86ppMpxgrVS6Y2m75sFUKenln1ak2np6c9xamqKtpWVIMy575pGurC9UGPgpuqgiFGvFU6k3MymEpXaVi8LBbQB0Jyr6FvYjZ9k7pc47C4Mu3a9s+qbdv+2cQYaduWsiz7wKrXh0fmQ4SQeO65j3D98SdZLNbEZLhz513eeOMN1us11x57kuXyFFJiMt1memlOWVZM6prrj91gtVgQo+WZDz3L1StXWK3X3Ll3j7v377NuGj7x7HM8ODzAR6hchS1qyehtYrY14Vvf/CbVZM7la49jipqN9odERCGjKCccHh/RbdZ9VcNa2N7ZwTct9bSiLCqWJyudz+L6oYwBOcy+i7iywlrLyfEpBwfHFGXNC89/jNPTJc98+AWidRydnrBuNhijQyFH4b4tHPV0ChjWqw2+04F1Tioe2zu7qijRSuXDSGVvOp3TdQ0GoehNZ1OsNTx6+EB7UQbJuaF+of+fBvoJI6feO8m8V0y/pfTPs6VM+XlVtgiR3Jyey9ne+/xD5AniIlNKv48yVaXv3RgFEGeraOPo9LxRpDdgw72ePeNO+6Hy7MYsudS/qz4zkw1xGoeGhjyJPGdZRhM3MP1wxSEot318lFTyMicxY4P8fn+eTRbyuwz3Oe4je7//xme9TzhGt9j/2ygNLDF6cn1Up02wZtgvfXI5Wvw07I8+5hvvp/dxEhkFG9vZIa/JCcH7U8Kizj3os3AgRZFG9lGoGpu4UdECpaWlM9vkTIA8livPDyYPHJUJ1JbVYtnfi1zzcJ/y5yiZ6hf9vY5XEok0PLccfJuhUcmQqKqK7a1tLJbj41PeeOMNvV/bP2yDhN2FtVr1VJBJKxbOWVE7VLu8WG1ISaYlTyYzqbxbS1U51mvDYnmqYNRwLk2vXnN+Ld8b4Od1k2AWrCtEPcqYgTaaK7C6P2xK7Ozs0XoviYlScclBjaFPLPJQzqyGZp19n7OC0uA6fPBUpUxy9iFiVksRpohhZMN05KHL1DpRCrpy9Sr3HzzAOWmEzUIy5/dk9rExBeLS4uNK3icn7NheKMQgalfFZMLOzr70+vUgxtAjlNkU5WTCZD5juWlZnZ4SF0uwB5jiLk8+9Sy7F68KUBVktgvG9IMIQxrof8FL0GxiFGS+2bBen7JZHpM2C4yTGRwobUYArNRTeqX3RG168GxWS4wrqGxN8g3v3n6H9eIECMTYcPjwLlBTuIIQDE89+TQTJ1WBrfmMxbJjNp/TbpaazET9PIn/nLUKrupUbSDPrpFBwyJAE3SvCms49xGogGCK/RkvygIbEz4G6qoiJukLDSFweHgIGGazOfP5THyDMVy8eJG6rokhcXJ6wglahfIdx0dHPP7EE5RlocpcYjNPjo57xcq8N2QwtCT4olKlggNJWQgZzEuB7fkUo0li26zxvQIobFYbvv6Vr7A8PsY5aDYrmtqyXi05Pj6QRCPK28kQ39xPl9RmRpzIi5EV9HK4n0GVvg9xbAvNAD6PwSK5/sG+5T2f4gis4KwfyK8xmD1mBp0HsPs5RSYDnH/864OrTkWvk2Hog6T+oq1spBAjq/VSqgHOqTaxPuUgkxSNs7iixGD76cmkSFXU/XyAXDbPVKbpdMrx8fF7HH5KBu9VtUnRpoGeNMzOSClxfHQEwGw+p6qqvuFme3u7bxZfrVZyPxickcAnWpWZ9YFko2ja63V4rxO+UR+WG57jIK+a1CAkEzVLhiyHGPoGyLxYqV9wKfEaCZZVUtbaITjLzyGvQVa8ypJjZVlqGc5J/4CkxsSoMyisY912nC5WJFNiXMnla4/jqjkPHj7kyvUb/OZv/jrXrl7hT/3In2E6n/PWW2/z6quvcnKy5DOf/hTJOG7dvcvDR484OT3h+PQU4xxPPPUUMUZeffU1Pvz8CxwcHmFdw97eBWws+dpXv8bFixd56qmnSMaSnEgciooN2NKxs7fNk7uP0SxPcU6GTd2/d5cvffFzvHPzpggBEHn86lWacsLi9ITGK65mEhQZFcsTcaUhbTbfYb6zx/beBdqUhPKgJU2jzzw3KRuVBJ7N5hgsp6crQbmcUV6t4/j4WPS6XSU9GcaALXni8RvcvPk6KUVWmw1d9Ozu7lLUE5pm3Tv3swGiBDopJp2AGkfI4MCFxuSDrs4/CXaUHdp5lFo+y+BbUbIS26C0iR6ZTFr1kpcoUmmIkjKve9hzZ6sYhjxjoleRsWaEAqYzTbZZh08CEyFO5bMauo7ZdIpvQ49Y5kCaoAbU6HXou4lkdBxi/nwlscOGKMpv+pliU0pp4g4DBUGuZzDQPR/2nDEe64bnM0/fGaaUyXPAwbhMfb6akN8o6X/koE1wQQ3C5e/Z2eS+I3nMhugTKXhCoC9t93ZJn5P8vDvz+eevLe+DdP77OrHZlY5kNWCMoQ8+s70OIWB0DxkMISVsAavlCqwluqiCZ5qMIHQriUVG2RA5r5R7s6YgxSxuIA+sbWUmU69K1zdIBqEyOnpqaVEUQpMIQkPLTeKZKibnbZRAGaQabTxCY5TnT4L1csF6sdQ+LYN1ldxHpu1Yo3RaofcWRYGxsNlsmExFpVDAJ5lps1gsqFyiLCdsz/aYTueQoJ6ULJsjVpuFiqcYhuAhDVWBnD31fjnvzNHWdZYYjQa9IgghghQyMNM54ahngMF7D9awvXOR09WS4OWzXKGzb3JPZhqoyllpcvwa24p+n8SAU99urWFqVX3SB9ZN29PH8myAbIWCBu3bO3scnS6wOhlbEp2hx3LsGzM1r4vQBaHUEqMaNFmvpOfLFgXVfJfZ7kXKtsH7TqX0Yy98YKmkqbaqqLe2qbYMMVmsKwkhcnKyYGuqfgArsna5SR8jYKNVIeXgMcmSQkdoG0K7wUbPydFD0mYJLkL0kFQ5U1FmYuoBSlm/HJBG7tx+m8dvPElV1tx5+w18s6ZwIlQiVbQIsRNWwWyHgohJnrKwhEJCQQnoLSl5pX3rxOwkwHIyKnBilMtPktkmGu9kyphRzpNUygIBSViS+qqEzmrRqqfVmWjr1ZIEzOdzYUD4jnfeeZu2bdnf39dkQWjLW1tzqqrk3Xff5fbtWzz+5A1SCjy4/4CdnR225nOa9aYf2JwPRW6Mz4bGkPA+gPEINVO/ZR1r71mdHHPhylWiD5gUiKEVzxcji9Nj2s2G/f0LtE3D4vSY09NHEtgHGVqKTcTUYZzEpdl2G2NwNp/hwbdhcoqUKfQaF2afq78bR/bgjOEk36r2PqXBD59/jYU2vjugRr+Hc6w6VOXf85bv+/rAicb+pQt0XYfvBDWuipJSaVI+tCzWK2oGnfmM9Oef2TQrqrImJEPTCGKQpfNCiJJI5PsZPajZbMZysezlZXMpPv+32Wz6oF4Gxvne8fRN4tBXQ0qtuIwpLM5YcPS9JdaI8Z1MJsQIq9VqaPbWQLB/T6VGFYVoEGfqVEDmYeR1sIXpAySR3T27QpLJDs42c8HHiG/m32V+YUZq+yAtZHWJ1DuLsrC0QeRCe2QmSMMyBlofMTbx7W9+k9l8h4989EVe+Pgn+dLvfZE//7/652mahq3dXVKCDz/3PB/92Mdom4bl6QlN13Lnzh2KQgxFWRQUVcXi5ITV4pTjwwO2plO25tucnCx57Rvf5vjdd/nxn/wpstRwUVc8ePgAYy3b29sUhePk9IhuvWJ5Muedt2/y6OF9lqcn+K6lqgqe/9hHOD054eG793nr9TcxRUFRV9TTLaqy4vT0GGsse3t7vPDRFzg6PpYmLlcwmYlkblnWvPzyy7z68rdZL46xKRLwhK7BlSVFXYF1tJuW22/dyhsSW1bEruPxJ29w785d9vb2cMZycnxMsz6W/Vs4dnb2mE63WK2XSLXU8PDBgUqqSuJYqHGPfcKhUsajYG+0Q87sFb2cc/tIce9zAVsPcGbDY60G3MMe896MmmZzAqH/r9dz3qiM0ZHeSDEE6TlQN9bi1NHoacAVBV6Vp0ArdMh0WouB8eyCmFVt9LeN9AkkpWT2RlATBXqDaXTKcUGrDlrG1ogQQtSuVnPm2Q5OXYbmDd/NVZ3xc8/9CMOdDUY7qUHL/sHZQUP9fNJxPtBPZGTLqD1yGkuOkjcNOPt1G4P/I0cxIFUSsJ1Jls45FElc8ydzJtnqvOxZaySJiF7kxYcAXZ20/ttiexWslER+OY32y/kkx3B2P+dryvZ1aO4WfnQMsafx9LQ7OyBzuTp9virSU5E0kc7qhn2SQeppTuestP5/kiAyaeLpPa6eUVSqUKT7f3d3r/dBTRsoqynbO/v9/BAJkis2zSPqako9mTGZznp/ZENBs2kIYQAkjEDs/drkvXI+URtXdFLQAMFaDE4FUXRie5RqpxtVjyaTKYvVhtnWLifLlnpS9kqEMmDO5ENwhjrHyPa8H9oqfZ4VZY/myjrMt7ZpmpblcklRWLzawEyXBmFMuKJgOt/COXmHejIhZpup+8epj+ty8GssVdWyKTYELxQjZxxYREEKIzM8ioqEA1sSU0tR1kglQZB340R4pnAVEUtEqteFK3hw/z53bt2irKZcuXaD/ceusO4arMtzgSTYK6wlJK9Iv5WEwUfwAbzHtxtKawgWSUTwGCRYjTHbA31ZwES15Zb5fMKNJ5/CY3jw7j18aCF2kCQ4TkYGZpaF44WPfJjkLdPJhOmkxsymHKTAZrOiC54YWgxxEFTRPSaSMQocYwU6SlH6L6JXM2FwtsD1anQK/BkApR4Hta1ZM0yFFUDjuCQCPiKmktja2mJ3d5eTkxM2mw2XL19mPp1TlRVWE99PfvLTNL7j7t27bG1tUVUVp6enHDx8NLKtal/S4N+MkVkZVocahhSlcVvTXEPAFBZnIrY0HB7cl0noqxXNeoOrhOXx6N5teVallWekw6zHvjqf1BzoZpt5xrqcxbXO+fIP1uM3Bi4TSC+H2rr3s6/SxhBFTY7BZ4wV/IZfy57hT/b6wIlGDMIV7OVjU+yD+mQMhav6LCt/XXimDTEmtnb2aJumH66WX9579vZ2+inHTdPIEBW9ydANvO1JVfcOXLJLmE9nrNdrVutlj5KkBF6HsA2ypkJjOj0+BdDSdElRFKzbjQbhtg8iclITushmve5VnQrrcBog5qefKxeimiHNwSbp/I/sTAecsEcY6QMAzSqzNKkZNMt9pjv5s/KXRSG9AAmo9Nn1s0k6kRrGSvAoPyufm5uHurYVitTjU8pyDs5yul7xzVdf5uVvfYu4XDDfnvHkjRt0MXB4KPKLXduyu73N3s4M5wxVVXD92mUMcHB4yOL0kN3tLd5+8zXmdcXrL7/CtWuPc+vm25RlzT/9z/00BwcHrJoNe/v7+BS5du0Kq9WKB/fvsV6vef7ZDzGvK77y5S/z6rdf5vu+/zMcHx2yWJzw/T/wffzGb/wGD+7d48aHnuejH32R3e1tUgzcu3eXl772VZ5+9gX29nbZ2dnh97/wOZ77yAtcvXqd1994k6OjE55++hku7O/y+5//HM16BaEjEbAmUbpCmjBDgXERouHpZ57l+vXHaJqOt99+m4ODA26/fYu6qkghMt/ZZnt7l4uXW5yTmTIvv/oKXdeQMOo4tRmxD/qdTA6HPrgBoQoYY2RGxXuyjfPJ6f+PvT97liXLzjux39p7u3tEnOFOeXOorBGVVUABBYAAARGU+EC0sdnW6pbJTP+Q/gY96V2PMhmfJLFFWZusrUWRlDASQKFQqKwhMyunO58hItx9D3pYa2/3ODermDCZnppRuLg3zxDhvn3vNXzrW99a1Hiqek9FvVsgh+CKtASgvk8RpxQz1qXRBUOszmUJ8EsdoUCTzKVSaxbDcxJELdANa+NUh7UpOGNVk9pAXBzT4dhoCi1psARC6RunBvu1V1nOmnNOOfT7o32rmKqGe82ANipK7Q2p57H9SL2XNYK0Wjr0dOeK0Jsz8VS1EevPutN/dYpI1fdar9nryHD9ia7riMWUmXQDNEfa+pxL7XGAtSpXDQbvVmmWe+GEnuecytiKF5wodSXFZM46kPNszd713pbPLvY5vvbmsIAobf+cJF46a0BEkU5ynYExr36mWFV8ZYNFn1/OxWYwlNZL1+ZlFKyauDyTdt8t2Vil2hWZPN0N9S4AODs/ox822sTpIPieYdgaeABX1xNnZw+4uHyDaZ6MA+/oioP+FWE34HcdsjHwKM90fa+gnKHD6/OwPDNZXcsXvxoVw/476y5t4hUqgKGhSClQxkhKRSVT+8GGm0FBp1g3sQoRfANF6rlZAqLFBlg6VBY6hwCu07kGXdeZQEkkzqbuFBzTcWq9LLXNfbvdstlsmKPKqXvuJPCqwqJAiu3x0XvtM6jCAAglzTRCoiv40LPb7Oj7jWYGOUHxZJdIJSut23VMEW0MDxtEdK7G+cUDvv3ePR49fIMsHSU7JCvweH2l6lMXFxekGLViL0KcZjox4CNlJOv8rXMDY7VAKwtwlGusoPQyGwdEyRERpaD/9Cfvc3M8aqUgzbhcewG8sSx0btQHP/+I+ThpVc45sAnxJzNJnCB4xIF3gqSE88I0xopALOejVF8lJlij9k3twilbAwCv7+ksWffOkZICzt671tfrrVHkMB15/vI5m+0WHxyffvoJwav/mGOkUPjLv/yLNhst+MD1KlDWOM7OqqiPdWh1rlZjsT0XcLhee/vUjmRigZvrK2JKxJzohkHBHcmkODGbuqEKtWgcYc7tRDzkrq+6CzZLAzZk9TU5OU+/7Hfr77/++mK7sH6/asVqYqk5Yf29RVhBY4AaJ//Dko0vn2gY2p+LltIpSkkRQ9vaG4aA91rWnOdZUUWB/V458N4HvF+QqVrWXg9SasOgRBUEhmHQRGOzafMn6u8fj0emaWrocKV/NC36lZNOrWSrtKWbm5H9fq+DXFr2Le1+Qe16lcGtmV5wldeq1zwMQ5PsbOvEHSe6Cn6W1+IkctZ1bW2MQptzMFsvyRrNrG8phUb5qmU2TQQLfeiVHpJTa2yvXNqu83zwwQf8/KPPydJxvT+y2Z7j+4F/9Pu/z+effkzOmc8++xQRHXIYYyR0npevnvOjv/srzs53fOXdt5mOe+I8471wtt1wdf2S7e6cNx89JJfC+z/+Ee+89RW+/vVvsuk7Hj18yNk08vzlS7a7HZILr65eQs48fviQH/3wh/z8/ff5/d/9XX7nt3+bn7z/PtdXV5Q48//41/83/ul/8cdc39wS8STn+dkvPuH25hpy5td/63cIDn7y/o853P6IcS58+OEn/MZvfo8//uM/5s/+7M/4+U9+yne//R5d6JikJnnLM/KoYX7zzTcZNmdcXd3w6Sd/ZQ38ke9977f40Y/+lmmKXF3dcjzO7HY7Hr/5Nr/xvd/kcDzw0Ucf0fcDUJjnmXkabW9YsuilNcI2tMOQ37ovaqDeaEJ30IiTfVB7JL4gcNVq2SkyUhXd6medNtDfCfDta2Ia4Otzche57Pt+QbjttTRv6/ukODL7+YQX7qDNyZhznaGhQatbnZUTRKYsqdEqG2gJQ8Ws1XHVIZ42tDIvyH796eVMWtJ3x5jWHGC9vHfSjmWtKiBj1FFZXf9rfNs7L7EETIM7u7o7yFb97zmvpF9ZBMfugGXt95ypF33herZfWH3PosK6PjrzyNkA0NKqATFGPNImnLfGYHtGXkyQwr2+h9eVjXXSW1G1arudfVb93ZwzoQutmqF9Rm6ZOD7bw8o6tyCvnkOj3OS7T2+dZdUEd3nmtapQCgrICuADZ+fndJ3Nx3GOmBKbzQ4QFeRwHgkdYdhSnNKpxvlIBMJmIGwHXN+RnSYCw7DBe012NTnLCizUD7aKQg2eXn+tE766tlqty7GQRZFkHRSr6LTgULn/iHRBE5Iu2D60m68N1W0xmrWyp06bh1UdlCDtjOmsGhVeySmSSiZPE13f89bbb5NLwoswzSNOvNJYi9KDdudnfPrZZ6Rc6GzWwbqaUWnTjtNA6OL8gm2/aTbYuToQ1Qb0FijOM5j8+liKzcfJgPab3hwPHMeZMGzZXV7SDTsEFSToNx0xZMYkdGFgGmdja8A8jvo0thsNbUUTX08hzxMlTRqclgJl5uJ8RygPuN2/ZDrsrcLtWmyQRZsf1LpZ71wuHG5vOb//mDE7Lndn+jzTRImznXuPBBUcePXiBT4MFJesKpwQoyc7r/shl1ot1n1Sss7O2p2fI150zgjVnrWDYf4Ho0KtIpxSQLLSJlEbV1Ju1equM0UvXJvN47IOlU0pcXF5yTiOODTZLElpeF0XcF77aM/OzhARlZud5yUWMoCj9jrU87EGbkWEVFZ9DL5tbHqv6oxOIPgqq+zoNwrw5nmk7+q6VXWzRcZWGnBUPcgdGq0sJ6i0n20LRxaxtIhTUKQdwzUgdccKVBtgB/Wkcr38VPPNYjayJkgiXmmX7Xq/6Pf/068vL29bnF2M8obrxq/Up5S13yLNCec7U2/qkCLWgR/BtLyrFKE3SdXj/tCcA0Xl9pyokpPvgz5klobnRaNeKxUlFXOuZVGeQfm4Hk+c9bMdNKQ4uIAfFP0vOSvL2hxnHWInRctgznmdO1B5zwkr0Ws53+GQLAxbna9xPB7QgYHggsk4yrIJGrKzrO7yyMVKXCb7ttluyakYAqvZZUrziZMXvHJIRRsSk+mza3IEFEXtUkn2DBwhaE/HZtOzObvHu1+/z2Z7Tt9vCF3HMHhur684P9/w5LPPVG0lBFKcGI+3BO+42u/57JNPyGlugUC/2dB1Hfv9nhT3vPPO13jx7BW77RYo/PBvfwjiePT4TR49esz+cEtKifv37/PixTN+9MMf8s1vfIPf+e3fZeh7fvbkKV9556vc/949+kFVwTa7c7aXD8gSuLnd83h3xjtOuHl1xc9++hPe+7VvkYvj9//x/wzvHS9ePmeeI8f9gfd+7T1+kn7Mn/3Jn+q+sOnWgg1Ni7klqbvdBd/6te8iruPjjz/l/R+/zxwjH/7sA+KYcF3AhY4pJqZX10yx8PT5C7z3nJ2d8fWvf50PfvpTDre30GRP9WDnedY+E+eUz5mVhpKtL0MMOV8Cxjt0qoZ+1P9eB8qrYNT+VERCGhUhQ1wjLq17DzWEefV2Ffv74v6gE7R9dTZXBJxlf9vPt/4LMJR/mUjc9z1THnXqcY1X5DSektX7raP95kbsfqu9qLanZHu+J4ZySe7uBr7r5m2y0b9EKOsPXT5Q363kBmism+mWoEiQrEFbDcvXFKaqplfxplqEyJxS0qrjqRWtuk9q7CnGkc6czqJYLnldYftliFmh7UNk4XCrhSRZwuZFqas13JT6/ZS0Cm5zXLKJWlSKaRPTsM+oAb7UINa2UClAKi1+1oZYIY6R0CtH3vmloi1YM3cWdKR5fb56T1Kk2cvqoEtFbipAtc4uVnuuJSFl+WLXdW3oq/MeyYnQd+QM8zjz1lfe1R61rldOO+CHDRITx8NBbe5uR7/ZABArXRChSt0pwLegxRqAry2DnCTfpmOoIYqriaOWMfTWTCmKAsWG7YrgOqHYnJ15PhKCzaBwrq3vspfuGiIQPNr/UGgDLG0dxTuC1yqv2Dym4+HA1e2Bm+sb8jzjgrMBjmZv6uf4juJUZlXEfF6TPdY77rtFhVGb5oWrV1e8ev6CFGezrUUVh2qiAeQibM8OvPvuVzkcb1tMOM8zBUcXNiA9RTw310e+9rUtKaNS6H1H14vOjZJArMM/c2J3trH11kpctupYSRMlL39EIpttx81YuD3sOR5G65sRKE7jL0012v5UmqaK68xjxvstf/Q//yckCXz44QcEAUpmniM+dLzz1XdxJfG3f/0XHK5eMR/2Zte1f6WkDOL1fZ2jOI8L2jMjRWdbaILedg2Lb6BJEzcFxFJW9tTsiGRT42LZIzkjop+jqrpatQnBW6+sfk7oPEFMpS0IroQG3BzHA0O/YbPZsN3qMMyUEykp4J3yAkA3f2q22RmAXGNIWV13NoWo9ZwyyYVStJ9DK6WqVulBpaEbUFXdbzVsJ15rea3tTMGesf1UttNc13YFxFSbtab+yup77QvSLEn7d4Gl19HAJAUd7jjaaoubLbLPy/lOteZXv7686pRRnip1StBGPp04aMGAE0LXgThLPlKjA3VdzzgeoCKVaNUulayGV2TlmK1hS1RpolKpalVh+eOslOtaCb+ube2jqE3ANcCpwVdd7FrJoC5+KYZy1ZKlbhJn8zJKHdNeKgqupduUEoNRu5QXrEbMSWUinoZcSyC2eq6rwM2JNpJtho0FGfrLOS+SvSe0i9Xe9c4r1xA5OezeaVlSp7pqJeSdr/4aL17d8uZbX+H+wwdqaJxjNwQ6B0PvefXiGTHO7LY7QvDcXL1iMwzEeWR/a+VHaw4tNjX2waPHBN/x9Nkz3n7nbXa7rVaeutCSnNvrGz757BNSTrzx+BFd6Li8vCR4z/nZBS+fP6PrBt58820u799TlRTvmU3BJWZNzIZhIE4TV9fXvLq6pu8Hvv3edxg2OwqZ84tLrl694u9//D7b7Zbzy0uev3jO4zff5MmnnzAdovGqna2xOq133/06b775NqkIMQlFAtvNho8+/DlD1lkQPnTEw5FpGpliIj59iu86Ls539H3P5b17HKeR43E0Q6WNqpvzc273NzbASc9OyYnTgG8xGKXcMU93AsO7r7rP1cadGraSdcrrupkSMcWK9qMa5S0fcRqErvswTq45Lj+zDCE8bRJV0ZLcKjq5ZCQLsSiQVIdtplya5v9JMM6pIaz/qenK+huFYpSEGrg75wjeNRpNLZ/n1Rqtg/5luWV5CHfW5LTH4zQRE0va1iXwyoVdP9PTR7Tc8yrdoKJOOFuD6kDEndg2/aPXW4PyE4lCWapousd+lcOwoFvEQI6Cigi4lgyoIo4lIy36Lq0qVfvegEUcpK7e2nHaf0r7n95b2ydpud5S53kETwgdl5c7Doe9qcYtMroq9JBPktH2WetqRjto9Xm02vJdo73EBUYJq/zmEDqO48R42HN2ca4zDbwjjzPH/ZF0mfEhKGhkMxq870hTUmpsFkRsWnqKpIg2wpti47JZsgFPliCWk025XDfrwKTc+f81o6v/ndvaiqlBea/SrYUAUgOxu7vDrT/6tb2jSWk5+ZFa6cKAxVy0f+A4jpATkoTKCzbvC8WUJ7sOMSUvqdTjspDDysoWOVFfOcfIzeGWHCPOgt6cE8VoSDqgT5u3fReIOavEbQhIEEhYQ7j2jB5eXrMkQfozBaWixlzoSlXZjPS9swbuo15jUlVDx4z3mcNxz/WLpxyvX+JIjPPI/nAgp0pm0zUWiwdUJjYjUhNO1z7bdVvO7r9Jdj08udK4IyWmNOJcx+bybXyZ2Vy8weH2QJERJFGHObYJ6GIJTHC4LuCDx5FxwS8AyMqvyPp82P6q8h93aXsN3Cg0BdMqeuG9SmbXYbE18XcGyHjR5neSUUFZEjooLUYM3mvfaHE4V6nnVXhHD4jUDVKAOm6gVltPbKSh+411XFhmWagxcOY0jYBWI3pqEl7a2WIx7ZxW/dv6rX1OURslYPNXaiLSbuNk3VsFWVbnvx2RYvdV/Zr5vGpDqEdyBXq3GEJBc33fdVLz/4dEoyJnzVEWza5rBaEU6HxH1w/MMZLirJSoBF1vQ/JwbVPAIgVZlZSqnvV6Oq8zZ60GiaZu451ns9lye7sHV4f7rUgW5rUa8l/K8nWUw9sQwrpsrjq7U6pKLb3VWRRilZiF26eTv701nDeDbQ9UHaa0YMFWtGWLp5QFvXdvqkON0mW/6J3Dua41gJ6iS5akWNPquiSoFSiPok0CWZjizKNHj9gfZvqgKiiI0HWB/XggzTNPXz3n6tULbm9u2G227M527G+vCffu8+D+Pbz33N7eauBaYIoJnwrb3RkPHjzi6mbkra+8w2Z7xjjOKnU5Z6ZpxDlPjDOH44Hb2w2PHj3gnXfeIc0Tt7c3PH3+XKeF73bEAofjkVQK3XZjAaiiDc+ePOH506dcvXjO2W5LTIn3vvMeP/7R3/Ps2VP6PhBTZH+ciCWz256zOT/j4f1H3B72xDiSpxrk16niwv2HD+k2W6b9yGZ3zq995yH379/nan/DxaMH5Kgo1eH2Vjm3m4E4jrx89QrnHE+fPkO85/ziEuf2pBiZ5xEnTh3WcU+O1kRn5WlXaR93zt9daskXBYd37Zb+3On3xMyeng1ZApVV0tqMrIEbWkmza1gFtPnk5/XrwYeWQLe0oBr2VTBXz1hp12L2wBUb0uQoXm3C646s3klZnSk5CSZrLJNy0pK77wBzptYHI8vFUM32KR1tOVN3fEANVVeXtPwe0Ozi3arG8lxWxn71Wqopdc1cu86G7q7MSHP69VZstgSWNIqIKbql5drKFzi5mshVI7mKr2tCUZOsSsOpfW1kU5MSVx9oA23a5xlCX1h6h1qCWIr97hKQaHXLqFPVLlL7RERlUan9aoE+dOxzIcfcEo2qflPtdql2eb2e9fneabZthQ1Ugac927L8Xe0sNszRh450GLm+OXJ2+QDEg/M43/HqxUsu7t3n3oOHeBfa4E4nSldyBIQAxWtPSoE5QdcPTPNx5Td0vZZqRb3e02RjnVTlVRVEkNUsHmyPFNtneuDrmQQIfhEh0YDe/JZbr+VqF8nC9camKNQJxwsoVpqCTiEhJDB1I+9dS1Crz2xJMoUgSoWsMeI6YdLzHg3wKgTj++OWgFXas9LemYQ1ctpMojFm8J0JyyjlqEggl4kYdTZHtpkP1dcjjlwEE+7SdcnJQJOiyYEoTSgxk6aJm+tXSJq5vX3Fq+efc/vimfZbdEEntZuSFIih2h6HVhL1WSlroWgKAHh8v+V2ghw8fvfIeqgihRl84HrUOGxz8ZD82aeLKtYK4FJA0qtwQAhI8No3iCYBviWJy36rdrGCNlqC1cpZfcpIrYSVpvSF85o8mLOpE7Ddqt+wqHqHNmsnbeav/XW1appF+/6ccxZzLhT5Op6gsj90TENpz6kelpoAtVkr1q+rEiVyAuZoPOdW1RhjtWAqgOswrwFUrq1ZW6cveEm1javzXc/jygTbep+YhXZmFs+7/pZ+ZlMtvXNwRW9ied9m65a1qbdT44M7HItf+frSiUYw3erKEdMEoNJ5VF/37OxC1RmmW8jQh4EoNrgmJjZhYCylJRsidSiLs5H1mWEzNOdckbJgiyNAyYmYC37w3Lu45ObqljrsaE178GJTNyuFyDmdcOlc03oPPjDPUwvI14mKCFbNqBx0zVdFpA31q1SIqmiF0yauZAiUlpb0YTijPa0lybR8b8a9VDqGBQvmIMdxbM31gMkMBsaxDqdT7eo1d1lE6HAkMn0/aOMcunuSNZUPmw3iHW88eMhX3vk6GcfN4cjxOBJD4Mlnn/HhBz/h+ZPPCA6dGRInrl4cKSWTppH33nuPm+sbpmnC+QAuICFwfu8+1zd7fLflj/7Z/4KPP/6EHnBd4NMPPuSzTz7nu9/5Dr/9O7/N47cfchyP2m8zHrm6vuJst2EaJw7jkbfO3lFutQi+78lZ55OM48jDizNCGPjRX/+cF8+e8fDBA958802ePXnCvbMzQvC8eP6Cw3Tkrbff5Nd/8zc5O9/yd3/398ylcPbgPsP5GXIVyFHa0D8JgRIjnz97wu7yEc53DFuP+MCT58+JBX79179LjBPTPBOnSBcCl+dn7G9u+PM/+xPeeONNPvrwQ5w4zs/PuH/vHre3tzgH03HP/uYWyVr+ztbIq9VAM9Ti7hzjmrwuX62za9pPNGO+JCbVCS9VznWPxQq9qOjuSTB9JxEutP4B/Z1a4l0Cy4xvPH2ocfFpH0GNl5dkXtHJFCNUtbi7aFn9D+vrUFqG/c9Q0y+yeznrGdqe9UsVBkuumk0pbYFeS/pxbU1rZULMYdafanF++7opyggE55klNdtTWChn68D/LnWpuVFbc0xBy+LalmGo81glILnaluXqxJBDaUnC2tHVN6tepv7OshdaUuNeT0ZrxanNMuI0IV73Vbjg2/drNRhr0AUdxlcoLUAo5ug63xFNB79OGs85UpIOxdudnfH5Z59rUFIbGr1n2GjTpsO13r/VZmK92q0aVBOt1frVZ9SSjBrctsetVDznPM73+DAgolSbnDNdP2jQ1vrsipamqUGIBpOuOHzxEAXLbdjtzkhXM0kSWj0o5CwL6alJYEs7WAt0Rps1qXvecUrLk7a3amJXpM7Ewq69b35JL70qETmlsctClTwJONGG8yVJXNasVqQ0qCzkOFHyTHDg0MF1tVG/BT0IlMh4uEFy1GdqIESdh+FQqpMLPSnOBNdpZcEapl3QRKNQB+hqkJ3M3mbvuDke2d27T4qZTz/5vAm8hH5LkZnnz58TUyE4IYomHUUAF1QUJwR6B9c3t/Re2+yFhJdCyZE4Hrl59Yqf/vhHxMMNeKWoucFRYlA9K6/Ts/G2wQzY1XVwxv9fbIHaFiH5juwHbqPj8s2vmyodCEpButlfM4TC2b03yGL+mkguSuVTwRJVCiU4pOsoQROMIvo3dUgxiw2vvqb2h1EBmOqPnLTkohTB2ZbXPL5WJ0QTbudwvs6OEBIQU5Wd1Z3ovdnF6nfW+1yEaCI81V5UMEIrHtJ6gpt7tERTnGgf4kpsRBPzsgK4qxS7gr7FCWK9yiUpla8CedTkLdsNN5sCgrtT54dWNjlxxYsNp4KCdsbaDdRXS2QqKNCO66rnuA4opUnhL1WMsnymJXpqY+6mNGuA78u9vnxFYzUdVzvxtdybTP2hlMKjBw949MYbfPjBB3zw4YfEMjEMAyVnYp7pOs/QBXJeBvoEH9gfjqoigFK0sqELusF0EZyo5rciYslQJME5DbjmebbJqt4crsILPgRwTg1CuxcLUGLBuY7KH6wbw4nDySKBu3ZS9VBVek3JkRQVdem7nixF+0pWTe0V+ag4VFWmApDQ2YNXA1+z7SpZu1QoTB3BOTrfAeMKhdA/9XdqY7wTz3icm5Z7ySbv5wOFzPXLV0zjngJ88NHHfPrZE+Z55uxsxzge+frXvkKeD5Q58ujhfUpOPH36lJTgD/7gD/jbv/kBh8OB25s9l/fvc3n/ARnY39zyz//4j3j//ffZX1/xN3/xF1xcXvLed77L7/2j7zN/L5LmyNMnH7fg5+bmmuvra25urvnLP/0Jf/SHf8Rvfu+7XFzcY5ompuMEzrHpenYX5/ybf/PvuNj0/N5vf5/f+d53yVEpMp9++in/8S//kv/Pv/u3/Mt/+S/4wz/8PZ48fUIqmXHck/PEt9/7JsMw8MEHH3A43CgP0/TNC6Zg4jx/89d/w+X9N7i8eEgpmVfPX/Lnf/5n/Df/7X/FBx/8nK4PfPizn/L48Zu89cYj5nHk3uU5jx8/Yjv0lJyY0sSzZwdKyZzttnzvN36D//iXf86DBw/4+OMDKVlfkMA8a7O9mRHbq7R9Z/9anckawK9+dhVYsG7KrAETC2JCrUiy0BDW6HWxN237t050FjNnJ1mA/kzKs/2uGUa7wBr0KDIqLQCts1OKFNKsqkVpmmjBnokkOAMHkOpe1q9s2Nb6amQxqDmprLAptxQLqOr9LgHg+l5qYHVan3kNiapJA4vgUrNBpfZRaUWh84EpmWhEAx3uvt3qOpqzMHnLRUB/8VkirTe4PYWyfEsE4jQvATR3nt1679R/nKwFGpyJOan6HOwXvDiygU0hBKUP5GyzaHLjAaeUTEyAZuOUY77+pKX6q2CTigs8fvyIV1c3LZkthTb7yHvPbrfT7dJbs3nOFv87uqCBw3EcVTLTBs+2PKE6bosF9AIs6HC6L2sCJ82Jq73NkhVt9p6yKaQ+kocEO0e48OROA+E8Z+gjuZ/JQ0JsHgwU5jHCmaNsC2yhbBWIkx5ingmXHcRCmTXedAglOwiWVNZbqQn7+jnbPnCm3rN8XQOk9jMCOodHg1pXII0TcxjJQzQmgQMLAit1Dr8kJCXXOS9FfbarlNqaiGjVSqmzgduba7quI3RBewU2M5telfh8UVWzGGe95pwRCcRu5K9+8mdcXNzj4dmbOOeY5tHU/Qo+eGaZwQ28PLykmwJ+8hwPVzjJ9NZDk5ICZ3gVEphTJtHhtz3FFaY404WBbtNbFQNEPJuNqjq+fPnSZgvN1j9p/UCxEOeJyRX++j/8e9L1S+hM1anYzB7xhKAAYxgCKU3ar0emD0Hvc0qEYEptKMW07r8KHiVqfw4U58mh43Y/Iq6nJGFOgHgDB6xCGnpCH4hTjxRlNzinVTRvn1EE+m2vA2m9J6KxjTfhkFzKnXNbg9B1QnlqUyr1plrSZGczF8hzRHD0Pui7yCIulCpt3SnV23uVNK+9SdR/e0cQsXiuSiJj4kK5vWfXdWy3OxUFmWfmaW6zzIolRc4S/wq01ER3ud/SlPMagOI7E/t1RkdSWmRdDpHQErBmcyTjTtaOpvRUml/QxMeZz63rU7253HEeFQRZ/i4nCZieVahkfh1cq6DdYjbUTmgV2ihiFL02KRRXGRH8g15SflkN585rd+8hlbMtIjaLoOM7335PZVXFNZrTeDy2IP14POK94LugwA+OZ0+f8fTpU2JOVBnWNlTJLJ8Gfdro7IPgJLTAJJfEZjPw+PFjPv7440abqgOk6mZLST1wtsVaz9Wo2sLK39VF9D4gCCF09P3Ay5cvuTw75+bmhs739Tfr0uGKI6WZRw/e4NPPP+Gdr32FROb5ixeUosmPs1+p1yUiFmToqyYFFVGtAdV8GJnHibe/8i5XV1dEq5Jstzu2mx2ff/5JS7baYMBVhu+dyqyKCKH3OF/aBsulME6Recr84T/5p7z11tv85Gc/0+FzTpjniS6oDrUU4bgfcaXQdx1931Fy4eXLl+Sskzz7vufe/QeEriOnzMXFPXLO/PjHP1bN67Nz3TM5M6fEPCmicP9Sv357e8OLFy+4vrrCifDOu+9yfn5B7QVIVsG4ubnh6uoKgAcPHhDHkTRpRWqeI6MpfGzOdi14F8EGF4olosI0TUqncY75cLTeCEMvauMw4ILejzilQJRcIEawQVlSy/zN4Ki5KUAfOr7//e/z9ttvczgc1DmJcDgcGIaehw8f8h/+/b9nnCatXrMksvo67exp6K7JwkLlshZ16ra/62wV7F4qb7OUohS/UqtjFZlagmzl39NQe+doz2AxdLS1WqPzQAso6uerTywn+x9DTruubwY/mfR0KQXJ1anW311+v3quJTg041ed3Ppn7PP7Ycu9x2/RDVu6YcvheEuQwovPP2G8vdHhlfbUFmOcVxWBJSFpd2ZgQ1md27ZO5pWqDXLOHKQAuRDzjDOHpPzi5f4E4yHb+lV5xTXlpNqglv6U0uyKIohR36/aEvGsTfyJuRdpwX/73qpiVj+vukNHaQq/TkTPRYb5DhDzRfvBBQ1qaiWkAgwt2VzJq+ZUK8KOYuAKgDinyjLOcX17Y+hqaJU1/q8j/ItT+fT//Pqf9sv9rzf4/8FbP4xRtGncAT1HonNFsuvohjPeeusrvPX2Ozx/dsX+5qASyqLT1Mdx5NXNNb//h3/Ize2Rn/793/PqxSsInSZYuUA8Qlj1kZgZE+8px5F+NxDHPZ3P5DiR40htAI4xQin44HBSe4sUpBQJSrV1BSmTJfKe4gYYzrh44xv8s//yf8Xnz27YT4njPLHZbDk7uyAmONxe8/ajC+abZ/z5//jfk8drStwz7l8iErn/8D4EbGaKXlGi9r1o8NyJoPNqI83yiizn2C126W5oqWuvq+6KW9B5cW2Oi68AUVmS2AUi1upNMlXCOuhTrOKj/8XydFfXUKL6x+1Wp3z3QWec1JhhnEZzIdUeL9cMS9xbr6lSQKn2TLdTizXVN2hRak0hxSpqzuJP9dGLauvd605FezrrvZ8G+L+cgtVeFTQ8+bliSZRryZR+Liu0pf6+7l9r79fnu0qaAKbb6VdfA/+AioZU1QrEBrRBjBMff/wRaZ4Zuh5njdcO5UZ2wSOlkMZI7pRXexxnrq5viCk2GbxkgSfQZOFyhWcNIamOVUR11b05rZOHWHT4TuPSyUJ7kAzehSVSAq0UiqpP9H1gnqMhkh3Bd8TjxKOvP+bZk2cMlxti1MCgTuDu+x7JheM0EkvGhUApyaodwmazo8RkVBBTVCiFUhz4WsLuqI14OWfmaDSa0JNS4fPPn6reeq9TSW+u99zeHBiGM03mclJlFRYaljb6iu2nzDFGfIDQqbJD8B6/69kz8cMf/C1//R//Chw6b4PCOB2V9jZnpjmRZ82+p+NxeQbO0XWdKjqkxH6/1/sW6y9JKnn5iw9+3hCKikY6p6okTz7W0UfB+l18yYDjs48/5NO2Btka6DTQ6O1kjFcviKPq0eNUJ733IMHjSiROo+0B439TGKeD0tAUDiCVAqWqiS2Dn0CpJjlFm1oKxYYe+SEwx6iympOi9972XDa+w9CrgMFf/Omf4ILuuRNN77QEpBpcY6outJ6EUrSBttoWMVRynhNBnE639qWhiUgmOEGlR5Odj9wMpAZuwdRF6xyMkxPOUjRQ41nLxc7VZFypWzVAvMvQvkv/0WcuTRBCv0Bbj2JUTBEtp2dLTDT90Wtq8T6LaWsmTip/dvVDK5sAgu86znZnTCm3uTZ+6HGbATePSM46I8gvCVernpiB1rV/nY++WjpLLvzKeajTcs5rckUBD9th2yqkpSz9G6qKaMj/neTy5GNqgrdac1voVSJSv6T7u8qD6sv0nsyfvOao7vy3tP/VpKOuiyZ15Qs+94vWpl2PfcQCsK8JBM72nVV3Lcm//+ABThw3+xsd0Gp7WrpAiRC6jvjn1/Be5pc/pP/8+p/iK/8fj/C/9eT/vWOOpQEx0ejUWnGM5DKBV0WwD8cDz599DsUxDDuC67S/LmVwnrfffpMYE6HXaelQIEVcUeDJSSbFGd9tUA+sgXvJAt3Ad77zXX70w78iG118CfQWikxFkiuibvUMnHNsB0/fDzink+mLH4huUGGePPOVt97k1c2Bm9sb5hQ5XL9knBPT4YB/fIHre5wI292Obb+jxDOQRJaJRCKL0opcTf6xuCVlzaWaP1tF5PW1mqy9tpgVZV/s1vITaxAnsdiT2gbiqvCEE52bkpcBm2o7pSUaqw9jbQw2255piu338mou2cXFBWfljJv9DSlpj4ey6TQ5hapitoAY9TmtvmB/GWegJR/59He8VehX9y537KPgmmKbrBbMVYBrdX/r1b9ry+9WrVffad87TSsW5a32i6t1FQM+ZdWf82VfXzrRmOdRA2vLZsmZwTu2XacNTAU68VZ4cdVVEryqA3USgKjlqlLwXa99ExRTvTEOsWh5rsAqcLaSli2GCFAceQKSIzhnbFBrqDOJNOc8m2HgOI2IwxqRI4dxJOXE+faMt9/5On3f8eknn+DKpEFg0mTm/v1HXL26oes3rdELkaYcElOi7zpuD7cgwse/+BShNo+rdC4FpYWJ2BAy2wC5JhY2Jb1T5LE2rUcnhG5HnBMxFfIEIp6CUgqIBR8Gnc5r6GlNpFLJVJpZcDBH7avIEXIq5DyDE3o/MI9avcgU8qz0DFc68lSYxpngNxAsYElRexh0EArzNOt2y4ZK1A5Fo9j0fd842IqI6ukreSZ4nZLqnBCnEQFClRLNeeHWYskC+kE6/6C00r8XDdyzBe45ZuKcyDkqba4UQI2EVrSETd9bU3ZFQ6y0T0G8qttUAyBI49ur0lVBnNc9GTpyKoaeC6V4CjarIWdrShTjuEI94LloQhBMLtKL8pkLmc4ZNdD2Ec63M5GtKjEfo2qeW3LpxWvgh9fiSkykzhBmtJlTiwmqZqbrHqCVWWnJcUVJSi4rdSRDrlofwyp5+YLk4uTVUJIVUlOyJu3pTpN0KQ1lqVWb197uxJgKCzddDTMt6Vgcdp2fMQy9KZgkkxReBmNmsXR/ZWfM0PDLzKoVi2gVm+Zs2g2sb00DA3c6cXWpRppSkhjius6w7n5uTcXs8LXqSvtUaRdXzHGXypdfySBXe7Ncc7Vx9il1LYv2pznrU6s/VHMMMRRsmUC+QgLr9VoSWYyeQzp1dlXNr6VTospMOSb2twcFn1CQRvsExQIBofOBtINyCgz+59d/fsEGsiuIauKS5hWVOevUeUt/oYxIKEj2lDTRdVsFr8gUZxXxrsd5SHlCnOftr34FcY5nnz6hOK2NamHY+iryqv8HIM389P33ybPOt5KSm39L9m+lFUUDl8X6ZmpCEhu44p0HEiXNNl9w5HK341//X/47piJIv9EKwBwtWck8+fmP+K/+5R9bU7etQyl4l+n6TqlSZQHhdGVsPk6WphZYgbLTQNXsnFi/6couVZNYg2stRphtVYx4lVjZE2n9eGZfi1uqJ82XmKmrGRmndrmCRYfpqLGPDTcNzrdBj6+uXzIMA9vtpoHIKSWlv6dKCRSNv9ZBfrvxXL9E6yuqu8qeYRXmkOJMHKGcqEyWtR02M12Ty3VCc7diTHuOd77HHQ8ka0DHHt+dn6s/sVSIlnfI9h6OcgIc/krfv3p96UTD2wCWqqbixdF5r5tRlIKUpaqllPaknavzL1TlaJxmHcKifBF9CC60rFXnQdBoP21hWDa0Nvxkrm5uSVllW0ux6dlZqxIla8kp52MLnEqeVE+5aCJxPI58+slnBO847A8mSVeIU2Q66s8eDjqcJcbYsnJ9UIYmA1OM2veQtSLTdzqoTSh0oW/N4m3asW3SGnCknLUBqlTNfyE4rwpLfUcoOrim0U/QZE85llpBqH0eajyLJRqZEuuEYKX6OO8AlQPWkpgnp9rMGZWO44xGk4WUY5vuWcunGnwXnPEoXA06WFAZbY5KQO3HsWctKgcX46xiH1JnSRi67TXRqFzwnDI5WmBmga7SqXQ/aFJaT43efynFuKhTq5oVk9+kZOaoGu3eeVKO7bpqgitOFG2yxuSKaNdEsySdGivGW8b2rhPa/aU463pYs2CdzVIyuK6DAjlG8qw9Sc5lBEtQKJoY2F7HOQiB4gLHOXH58CHee8bDSOc8UiDGmeADD994hO87JKh62JPPP+P582f2bGqvgyU8tecCRePXVJYqqbluXFaFjcWorf98UZm8VhnvmqJCrcSUxTHZZ1Wp6Pr6ovdeXhXOeM2srq4DYkqUklUPfsbuIZNJJDPmtRe+JlVuxWm/SwNofVOy/E51vF+4DlbhyJnFiVVaG+ac6t625lqynHz+6/e9yse+4HuwnEdfzwClNf235yp3nYWs/nbL+yCtcbgmL+s1/mX+Zqm4LM63qZxR7WhNhkr1zM1/+hAYhg2Hw6GtRat2WxCRJVHWK/HvHPK/C80vCTrkq8qkI1YxtwqsEu5rFIQpKmG/nxbf41b9PAYW1D3ePNQadUzw4I036LqOq1dXjNMR9YliPYNZJ7tH+wzxOghNHHma1SeMR8ywNL177wzRMSnfZS/o2iiwUU6Ci4ahNtusa5vQs1H3qLhKiawqO3YmXF2qDMUAM5YzUvuT6jrp5c1NArjuphYbtThXVrt5td9LpW5m8y2lBXLU4E0UOGsZ7zqq/T8Ua6Ze72xT4Kpg2WrtGvc9TuA7vEDvlMWe00xOQheCgmkCFOX/D5uBzXajeQXmR402TtH11ISgVpWFw+0t0lSZsqpjeeFwmBXscg7LVtp1ix00QavXKqQljcoipZBKZJ5GvvHer+E3Z+BDs/EaVEc6kvUdZWuiVylx5xQk8yK2VwzUK3F11AWyvPYs7qLylebaZoJ9QSDcAKECWUoDeFoMYf/VbCwaJ8nqZ1jewoLuU+t18i8RVRqb9cy5mggZi0Ip/t4YDBaLOgU6GjBk/cAtgWr7TQGYNXBSt2GpTeDtMup3F9+6Bp8aWFMTPROFeW19V2vwhdTYOz7ri1yo3PnaiQ0vd/7Rnle9HwUFv2Se8Q9INKSjZB205UTAq6bEfj9iFt8GCtGQYL144/xPmSlF5lQorpYSTwdQYZt8nS1XZ6L/NAeUIZaiSYTpSKs2drEGIv3pplwFS6Bfn3hR7e5pnPBIUybQxpdqNBxznJVbvFJc0b+zTYIVxId2QJ2ExsHWBiqnSk8iUJb2H1h4jxhnTyg4r3msUjCUitOFTpWjRFZBmbdA3+HBKgALL75KD6c4W4ZfSDmSk/I9UylIjOADIlouVdRfm9Yq/5GSbdBfNRZq4HJWVFyPaQ1GLInCjEyGis631wq9VzOuDqvO0fQ4faZFm9m7YUPYBVPN0eDYOQ2ideJzZH/YI+LYbrd45/ns8885v7hg0/d0w6CGRRzj8chnn37KOI54Ed796tf4+JNfME8jIqcGIgEX5+d4HzgcjkzzRNf1vPHmm6Q54kJn1CJd82mauN3fktMMJbHbnSlNy0mTVx6nCZEAqfDozTcJiDq2POOIOEnE44H/5l/+l+xfveRP/+RPuDoeIThyF9hHfUZvvPM2c4wMY6RzASlCipHgA+f37hG6Dm+Dll6+uKLRXCgWBOifVXy8JAxZnbtJq9ej0v6xdiprI1ODq5PEpKAOrdyxRqugQGp8UWoAL0b7W6NhdwP4leVedhwnb1qgOvcUE74L9H1HjB7nlhJ+aajd8s6OhbJlx0mDmuoAW4K13Pt6Heo119+Xdsu5Jfj1Z2X1szpgb5UA3E3RVrHU8loc1+kSrwKVk+usNoyTB1jWS1qqLV7bPE7+ffczgEaDW9vsuhYnP1uHd7VkdL3Z6j2pfSwUttsNB5uSvNoV2uQv7nUb85Eg/8rbw9NV7C4G4j6RolV21kGCJZ7aAC5WAbRk3NbAibNlWSegNZFxSwBf6vkpuOIpjzzFOdxth5t0YKrz1t+XI8WBRwcOlqKKiOICWPM3R69yzPa4VEgERUMLJodpC1e0Fx4nZFd0plF7WZMn9bmiiptOm4Jz1t4A1V4RTGN65Y+xZ7YkLXrfNdmqv1cTASAugFFdtXpFesTXwhQL6luTWVfXGLRZl9V713tLafnsuonFQY6vJRpl/f2a5KyOmBft6/SsUqgKiGQUNMqZ0JkimikjadN1ZwPvlL6d69yGXLT46B2GAtrFmKSvaEW17z3H494OQKZO1gb9HJdrXKUA5sk6O93nc5o5xiPvfONdnr/ak0QI9nziPJPmiUdvPlIww1m/Q6mVEjXYWvVWVSetYuSWrGsS7ZuXF6lJkAXMUjtN2oJbQH4CA1D70WpVYw1CnLzk1ALWGLfGT/VVa1J1EKCstgL13mpSFaR9o5gow5wi3qRxoTSlqhrHitGm1A542owQs1nKvFmCbmFNVdXPWDdu130vsszCqT2KLdHI2c7vyp+0e1tiMWAlJ01bSzHHdUKDao5nyRvWGVMqi1+863vqc9TaQH0Cp/f1q15fOtHowgBFdaopRUt1qTBNkwYTUi+kZjqL7nDORRuISqY4j3gLmN2S/S5qBkvEV2ryUl8CFT3SSdfK46cZoFPqRN10tUqggZAufqXReCd4s0jBh2XzWANnG9y0ojiog0x0Qfn6TW4tO0rxpArXOKfKXCk1ZAeWTVOKKmXkpMo7NZBDIJYEOROtP6E68YxSsAAdLCiFJNLuUZwnON/kJjOiSG5FMSgU5/QwIbig0z5zSVQ9gzox04deZQSjJhpN0aEU5vHINCdiTgyd6lRLhXtSghD0sCSjI1XZTacNqzFHarYeQtcOZimm2iMaoG+2Ozbbrc1ngGzzSnbbgdvba1Kc6LYbNpstF+fnOvTJO7bDhjceP9bmadQYzNOEiOPly5dcvXrF+eU93Oefkxm1JKgL3dCM+/fvc35xyZPPn/D8+XP6vufdd9/VwNl50/bWXpTr62umeWJGKUHb3Y7D4RbnHLvtlgLML17Q9T3H/chuu+ONR2/gyYz7K+Lxhk0nxOM1//W/+Oe8+uRTPvjh3zIfD/g+wHbD4eqGUjL3Hj7gdn/k/F7Ao/0wedZZKSlp7xTO4T3EWQOhXCLZRHlqAn8a1NVg0BIRKte2Nr3RqGZrVGYdMN5FUCr6U4PIBa1ZHdP2PuvgPS9qgIU7Jg8aeXdtQ5teajWE+lt1iNNuMxCCJ3ReZVDNsVYaQEs0ihUTqrnRq0Ha6VC/Xr+2Ps/r13LWl0C7yl6v10GvQa93uYYTL7nYC07XuEUa0tz2ErC/djVlWaNV4+QSaS0OWP9rnYQUQzc5+drdj6hJ4xJ4ri6R5R70/xvHO1M9/sldqS2roiPKg89VU9957WlC0eI5njYj6nZYnHGlspVq29Y/a/SNbuiWSkb9PbdUnrXqSjsTsMyB0the5cuXc1DwXcfh9pp9lWkpVj1wgjMRgpRnehv0qpz9YgmFotZ02v+VcqLrtTo+TxMpJwVlzO43IKGCUVQiyvLIi52ZVDDflJT2jACBgvqcFrOnZCpTlpgIiARLvL2ti07oLrZoeud1+KlWfKVKDuti2hqu9x128KqdcUswVW2TJRpFhGxcm2KKFWu56bsJtH7uagaCGA89pRVrQt9PcLgiBPEKpsWkMyqymG1NOBukl61an40h4X0gzhPZKzBYaaGlaM3UmYBIjLMO8c0VWiutF6DuxZyTDtc1+1CFI9qKiT6/oh3FOmiuFEpKzGmk3+w4Tjc22VuTnsN+z3zc8/DBlk3owavoQipF6Vs1iczo3hS9nkrryqWeWJtNbom1O0kGanX41B/UuOm0Z0DQ2SV1i65sBjV/kvZ7hWa2mj+qT31d3bi7pRZrkwnOqUR4KZrAGk1VY4rB+mlr6GaJhrO5ccLCbsg1qbHW9lIr4FYhcdL2YEX9xWhS1CSjrlZZMUDs35USpTLAr/uW1/zNKeK3cqtrQM3ef+VP27q1mWzlZL1f/9z6M6u+oi/8yddfXzrR6IetSlLO2mgbU2zNvyIql+pq44w9SDAqlO8AhxeVBMyWEdUp47mWY6mohmugpLG2G/9ZbWVtZtTmLlVq0G8uRmxleFAt7FSiNWTrt13tuhdROs04mrEsEBVZ9Z2qmuQUVWWlLXEgJp0Y7Z1K7zp0AE2tfsSS6fqNjawvptfNSokiq8HIxZqg0E3s0LKodLhemKPR07Bah1e5TDXfGYWmtHck9AOh67XvIme64Om6wKbvtHHNa/Y8DFvqZNoqXelE6IKWD8dp5Hx7Row2kMaav/uuo+TM50+e8urFC65vb/nKV95lu9ua0pMaX+88t/tbVdUqmKykzRLIkWcvnxO6nsPxyPnZOcOw0eFqR+0F2p3tqIo59XmtqTo5z/zN3/w1zhXeevstHr/5mJQSP/vgZ/zRP/kjPvrgQ3JOXN0c+PgXv2AcRx6/8Zhvvfdtxv2B/9e//bf81V//lTWT2yGkJpFmdEV4eP8+0zhxfX1NnGdub2/Zbc847Pd4CewPe2JKOo/Fe7bdjjgdrU+jMM8j/uxME4/9kW7YMs6Zjz76iN1my/luw2G/5+rZEx5enrHx8K/+1f+JnfO8vLplToXOB7a7M84SHNMteZrY9gPOqGLznJj2B9Kc6JxnjjNzTpyfn+m6OQeG3ujwsqpmtGznJQD7JYaj3AkuyypoXJ25GiQvaHVpz6796h10p75fTYxPA+2VKWsYhNz5Tg3Uy8pIVqetczR2lxeLsywLla/9npOm6tFSFnPwd5ah0Z4WlOn03/r+efGMq/tU21adkl1jWYbZtSsvUEUi/lOmXMxxt8RwWS4QqaJo9jUxpaxTzq5dJLQzRktaauBc6u//ktdpsrm2vyexBWJBcSZbVndygbQUrmj1MnThZP186NhsNuy2G9I88+Ll+AXbdkkSah+MiE0iXl2ncw58YbfbIV6DvJy0RyyRjOZWxQ+W2R4aiGhluVXFVjRJpe4We6rZ7IFWNFJEZziUYvOfMj74JpMafCEm7TEchg2lqOTq9mzHdrPh6uVLTTBSxrmunU2lWWoFxb5ozsQ2SWZFEQvgEiUbACYWZZZVk2+c7ToFvCf0Hb4PSw/dHG0vx/YMq99eP38N2KwiLZhangbeKsSB9d0slfNiz8ZJpahakoGQqBTjgpegJ6TUuVIKAay3g/cO33UN/Kgy8UsvlVV5jIblxSFZGQAl6TMWvHH2dU/M84gPG0uE1H7oZndtP7TE2K5Ie7IcaTyyIPmKlqvkvz4HpRDbkFSWc7yYLBu0V8+UgCPTB894/Rwnhe98/U2cD6ScTX3zETnOxGlk//IJhQkvOo9E80FLlClQASnnQRzFZRvIK2QDMCuNsJ77+vc6yaj2rdkHu5dWyTjZLzVZXl6pmPqfSKvwVjvb4IK1D+O1L7V/1Bk+CASvcrnJgM+hH6zSnJWKFyMgTT47hE7FV1xHSYnUbKO0PV6ZM0oDaxu/Hb06eHnF0dX7vQPYrP1m9XXrSjQn/7JbXPnWdTJ36nNPE40GWq3Xr12LsK7ILN/LVkhcfPOXfX3pROPqcKS5pwpvrB6toJMxsxmpalh81WpeIRllhW6r8xE6160yrFXlIGP89vViOrWZWWkZKdqirgIa5aNLk9nVKZu5OYrcmooLc1FeZK66wSZOLl3PPEWYZz3crZZZlECainLnpaPve4LvTBu8wztHorDdbZoU8Ha3Y7PZNA34Steqzyyl2IKYYeiYpplhq+pPItIG93VdTx3UpJMulfutDZK1cuK090Nqs1cNoJasuZjR1qdC618p4nj/5z/hW9/4JmBT0KcIx4h3I+Nx5E/+7C/43e//Nrcvrilhw5iE6agOPwRVPLq6OXJxUWVqzcGnRI4R329wXc/1yxvOH+yYC9ze7kkpcnn/AcdxQkjgrFJiAQqUlnTmnJjGI50TXjx7yjRN/M73v8+Pfvi3/ORHf88bb73Ft771Lb79rW8yzTM6OXRS/fsgquEd6uT1xVh0XUeZIs+fP+fe5X3Oz85449EjPvv0M37wl/+Rze6cMPQ8vP+QcZo0KPCe8/MzRApX88jZZosvGe+25ClydXwJKXG4uaFDePPtt/jx3/+INI90LrNxhSfTgeP1nl98/AtVsgodUz9wc3VLvj6QS0cA/u7P/yNDGAxZEWN+ZCybIKHcVp8eIWmm886QGpPANennhqZU2Vk9nQQvZJGqKrqgTklRbd/4zYtDFwvaU1qCBfvGEuisXvUM6rtI+1qqiFCBVoGzDVo56vW86C/XSFagTr03i6RuPDHnmZgTr65uyUXXA9+D75CsKJZW0cqd90MD4RY86plr80RYkK/F2aaGuFUHlK3nqMoYtvyr1CsVINnzsMPoWo62WjS+8LUkepzQZRThtrWottcc4Ov5wvIsTqhFRRHPxUqsbezrTrKhtCdrQgNXqp2GhWpb1hezRFPqF0xwIeeM8wHvAp3vGboNm+GMWfbInaSp2N14aj+XztiJOZLLMgwSEXzv6TrPcdwrCFaMbltgTfnz3pPyAkDo91TeXMSUGPuBLBbAiGPoB65f3ahKnNTgSHDOqrM4BZGMD6/CEJDihO8cU4yMxxHfaTB4ffOCcex5cO8eh/3I/npPipbsiFbTS/aQvYGADoaBsNkiXUeOkXIcqRSeMvS2UDUx0WvBWAt4O28pIb4nBxVwObvYkGJiGm/Y9gFyIs5H68nIxDgrt9/8XAiB0HVtdo6UwriP9kwNDS7FzpeegzRHht0Z1MR8pZKXqQCADs4T9EzmTKPXHWRaPbvAMGwBWp9OC1iNiuu8JxhoOY3al9l1vZpVyYhXClU8zPS7gZI7chqZZ12voXfMB0tqY7J1LPhOE8iUjhoHBE8KGnBWezxN2RKO1dmxRnU1Pn5lZwvFeyR4vBcNoJ3gUiaNt/z5//h/p+s22sxt9zenTGy08sLlbqAcbgnBEVxHcOgMI6+xT8wFT030lBpeK4QO1yq+xQCDOisFTvso2qvaCzH6qZ3/Goss2YCcGL1iv7PYyMXm1KShwh937Vmpwb79bAg9JakyozJMUNWwonFJv+mWUjZLNV5QNobU+7X+Rh8CrlRK1XL/daZcS59W91eBDsB6UmtyXu3l6trNkuai1q0O0aw/0HyirCh21d5WVOfOa03n1VVRfybOv/azd1/61muSfP7Vv3Dn9eUH9iFt84qBHq4I3gUrneokgIqYmgexYVsFSVYlJ7emaFVXKFau/YKdUj/P12F9FSXUuRvddqPqSaFvdIQQFqez2WzY9L0F5x0XFxfsdlv6Xn9+Oo5Mccb33uZ8eKUehUAInTqoJGw2Gw77sc3lKJYs1fJxK31JNQ4arKY8t4pLQ09a0FUoUZOcbPzLbL0TJRfGg80huRkXDqJoEHCYR2rzUasSiFZbclGVLjEN/RgnVX/ynjTPlJy0/B5nJGgi2KZNO2HOiXmM3HvwBnMBKdkSkMLhsGeaRna7c7qu4y/+4s/5vT/4A2KOpLI6RJY2X9y7UCWdoo5hmiZNDNSKcXO9552332GaJuI0E7zn4nzHdDgSvGv2owoQNC5jnJnGW37rN36d4Ao/+cn7vHjxgt1ux67v+K3f+HW++61vMc8z0zRxHI/M45Gbm1vef/mSl8+eQSn8zj/+x/z4xz/msL8xI+BtyI+WEvfXN/zgr//aeNMq19z1HTlH5kPkg+cvGDYbMwhqLGLJPHx4n7OzLcebK01CDF3sfaDzcLO/hTjT+YLH0TmPdwVy5PxsQxE4QlOnUjUTlEp3nLk4PyfPI140+JVSWuk2lWxKb4npcAPBE2p/S1IHmIFi/T8VlVo733USUP+7IRqrEu/pcX29XF73bEUtqwO5WwlQTvDyvs45U/s4fZ1y/WvSIRaEeIRFk1zLvNJQJR8CWtkcGlCitinghpX8shl9L5UXr9daObTYR65L3vWVrfJZh5vBMngzOK06rnvG6pudUAzyKW/9/7eXrP6SZk/Xz+ZXvkpReiY0/vN/6rUi7Nx5qzt7pqz4x9pye3rlVRwk5zZbIOdEqNWM3bmC7jGz251z7fY1JW17KKaE6wJeHLEBXfYyhLEU7Z3KojCuehdv13OKCOo/VG47FQWZwNF14bSJ04L2w+GgwSC0JvQC7Vpc5zQo9Sw+IWdtQC9Be+CKMhvqBPZDSsz5yIP7jxhfzrjtBbuze5yf32e7PScMG8BzHCdycnSbgd/+3e/z+K232Gw3ONHJybe3t202kc57MtpLTuSSmKaJi7Nzzs62hBC0UbbzSNCKtHdCPB742U9/zEcf/oynTz7lePWCOB3xmw1gM32kEEshzYJMS8/kpu8Zx1EDNTtz4pUdoUlHIlvSnFOkJMAJQeH7pdejyZQqCuu9J9/ZS87pWirIEnAuEw2AdEaX1hlChdANwDK/ptHCUkJ8ousHxvHAsNtAiWw3A96dk2Lk5uraZmIU8BmKJ6UJIeO7nsEHxv2tBlAWbFMy85xIaV5fsSY4xpTI2apAllxNcyQErfQ460KXmOiB7bZj6HtyiaSYLG73ZPH4fiClmd4HXuyv8Lkg2SHOMwwDc4qkCtBY3lkpd5XCM6XY/GOtAjdfsbJvLSZiOUanvqGcmLfX+/BW71G+wPLIL/+9+v0F1JB2zd6qFCUX84cWq8XUAK4aA+SkQatzQeeSgTWM900coVa3qqQ5bZbW0n+3mN/FqtR4A0pTI1yvkSYFQkyl+ZDqX9f0qi8ythXAWtvc5YzcRepO13t5jy+y9ovPUhv5ZTyCvr58M/hmBzEqWl20n6LvOjabgbPdju3ZDucdXQiGDgS6rkPwbIYtvXSEvieijdG12c55ryXgLpDmaPxTQ+uzTs/VspOnmNJDzopq+xAYp5E4R2q5v5huPGjwNY8j8zzpwRRHLIXxaMovMbI/3tJtugVxlDpsK1gQ5nl1ewAJxh2VhmqtS/7jeFAObacObIzaA6I00kA09ZIaVKWsZeeUI0HCKXph97A0hFaUlhYg1e+035GaAUNxouuVlbZ2HGe8T6ouETp0aKhTji/aVFgzc4oa8XsXF9SJ6d7B0yefE7zj8cMH5JT5jfe+yeX9e0ZNOdD1A6HTNm9nak2qtqWIgPcd3g2Qz7SfQODnH32iA/dKoROQNDPdjMRpouSZlDKHw5Gb21ud6hsjOn+zQJ7pfMDbsMcHuzNEhM9/9gGf/ewDMqX1tyDSeimcc/z293+LH/zgB7x4+gRXlF5WD7E25xdT4nANsQZa2bEP2ouyudiZITf0CA1Svv3tb7MNnueffw4xWZCp/U0a8Cbeenyfl88/08ZQVw2hzsdIWqJTNTCvymJSijr5IRHjUZMaVyw4EpLAPM+ELhhVJtP1Duk6phwpMbVCgbbrFHPstESzrBq3t9utocHVsRSaA2TpdRLRaxS3GHNd8ppM6LlqfQopNU5ofRVKm8xakTRFxw3WrxNTV4a6Pqdi16VWfmnUFaFV93Ka6ULHcS68enVNHxzzWJCigVBKka5TrnmOSqtIVUXEiTqhlcJPQ4xWiUYp1XEtSWE17i4E5jlxcXHBfr9fcY2zKY7oeajVzRgTJRWcQNfr1+ZppjRqi93gutfjC5KThtqWeg5YpCnvvPqwzPTAEuOyQvVKQxXN9ljmWJ3a8rVVmvQFiUyj7JXlPdr92DpiZzELJviQUaWgoFXqOPHy5XMATTJePm1qWgDDZsPFG2/w7Nkzco4U58i1edP6q0If2Gw2jMcjIfTEEhsymXP9OcG5ru3drlO/5pzu1bpezmkjsabiGW98+oj2OKjdKoaROcQVpekYDdZJUT52nVqOps0pZVwOFAngevzmnPP7j3n89td58Mbb/PP/za/z5rtfI0Y4HCYLWBO3twdubrQ/7Hh7Q/IDnz95bvupYzNs2Gw2eKcCL1dXVyZcoeh/KIGwVbGLaYpaOe2dKaMJhY4pJlIZeOOrv86Dd75tKloFSIzjnp/85Mf89P0fkW6vgYxz0HnonSPGIzlnht4xzUkpYzXB7zrGaYbgOVjvjXfWnFtUwMWJ0pv0mjv9IzaYN2tT/fqVUmaas1HgCqBJUzsntmsFz2xB5mFMOBmpFZU6bLRwQ3r2FPfRR2YIlBqcFd1DcOQ0GfhRmo0QlGquqooJ4gzU5MLp79eLKWaT2wBV16a7FxLTcSbW3lCTw+18R3CB66tbrvK10bGSDbcrFPHMZsO89zqwLqva0jgemdJMP2ygc/S+U8qQU7uu0+WUzj7OEcQ4+mVFUatnNi92c/09TSTdAmIlC8xFWrUT80uwAGB3abaNPm3/XWz9lmcpbQ3X4Fewz7Z80kyW+eUCEoJWbkvBi8cF35J76r1mrZCneW73GYKCkw8ePODVq5fM04wLQp1TdTKbq1XlhFqNyQX60Otctk1PqjL8ImprVj24dS2q1H1VbhSzR3bbp/XdohXAUsoynPVOMrP4tlOwcA0Iqs93pBbv/CoS7euvL51o/NZv/6N24Yqg2oAqgd3ZmcqsGSKim8GCheLww4YUC4dxVEdXM10E55S772dDvjO2gaWV2lKprZhLA5TSTZOqV4QFbVwa4LQCU5yjuNqgbUO7LOjHCb4bFNFps/xM2ciL8helpvWR4tWQ6GZ2hjyV5UHUfgk0EMolK1JNwYshmVnvt3Ney3fOI8DcZBQLWGO2r2U3aWBGu0YFdqwMiBpenFLKdOZHxjvHlBM5zTjpQJSv2vc9UjwhCMFrQ3yclBI1Ho8cD3vmcSJZsO+9cPPyBYf9LR//VKlaSg1bsvN66GU1KyCERWLSea/XWFRNxPkO1+8YvFLBPv30E148fUIfBMmR3g5FzBlfEhuPcY/BkSBrM3vJmUDROSt14AXZ+heS2RRBcqFzivClWbXIj/t9czL18FRjsDZoqzZdLSFbor1+lYoWOME7G4roPSXqsEMq7SbOdGRSGnE2GKkOXMQ5ppS1XCpagcpxakE1QDCFnGmeqVPISwEfOt549IBXr650zS3w7bpVc2WxcrUzZ1AT87wgR8UM9DppqFSplPQ9K+/duVODqs5vqQ5UO1ATtuU9l6bb+hJDKuvn332tDWAzRJWMIigSil8ZzEwpkSIeodeqWQr81//L/5YHlxf8D//9v+H9H/2AkhJdF5iSUuvErrVRnmydRJzSTaoRdosCXLtfZ23iRY1yrfBpcpX51re+xd/+4AdE69WCpUFVNRZKc17FWUJYlGOtmusOCaGJNZSTSvAXm3118G20rO2BZX/XV839NA9Z9de0dxbL98ov/SxQqutdZrZUCDqbfTb7pR+W2mfk9mGy6OKLTu+VLiDibR9FYkzstueM48i73/omn4S/I1ngNs8zN/u9BYdmg4oYTz8jwdFvBg7jARcc4zxaEF3pO6f32ZLJXEiiyfgCNNVkTmljbpUICkslQ5FzS05yJnSd3bcCGSnPeNch0jPNE5GOlIV+e8kchd3lY97+xnd495vf5eLBW4xR+PD5zI8++aEpIwo761sJ4hg2Azknrq+e8/d/8UOm/SsoqqzlivYNlKRskRSTglPW2yHZmsKd+nppoISp7PlAXSG6nt3lJW+8+SZvvvUWDx8+4OziPmdnD/n2e99jf33FuL/l2ZPP+fzTj7l98YLiOvAQ5yNeeltbRYEjhZS1P7FYP0BJ4JKpP6UEudBJQlXPJ5Cl50LBy9OwJoSezXC27GuR1h/anpPZPCnroHWJSevviXcNFNT3c+SEqnzZb/TDgEjGPB21JyvnTG9CLd3FBtearWtyXcEevU7vNYGqRl7t8gyStWpjjdquiruIV0n/kvElYCGmnXdTeLSAm6zURY+n320QJ0SK+e9AbViuYE5BqxfinQXcCyCwTgCWhIyWNFP0c6vYT/WTre92Zdf/k1XW+ixWf4vZlPb9fPp+a/nYGiC33qCVX1lUqs3vO1neS+r9LL0bteKaUtI+wN2OmBNznFWwR5b7qTM7FnaGKo5GvUhC37d+wDoOYZ5ngg2mXvtVZyD8XXZBVRC76z+DOJKYf8pLH01bH/t7GSS7fK89U6AKI9W67z8k0/jyzeD9hhA6M5R2gV4zbT8MTNNRD01VociaGDjnOMwzgg47q5w7+y7YEDtMvlVvSKPqsjp86yqR+gEtr9bDkIxCsvxebk5DXGmbPpfUVJs0MFXEOXiVS23BkQ+ELjRdZSehoa7FHlaco1JVxOMHIQStpntTZtrv9+zHI9M0sd/fMk1jS3JSSmANSOAIw8DlvftsNhul5kwjOeU2eTunTJ1OmWIkx4T3npiS8cudJXEOH3q252e88eZbbILjyYtXnJ+f41yPJIj7Ix/8/GcMwdEFHRiXU1IOfhtYo3zmlLI6zxQZ8qT8W1MbidYA7fzCjSdVjmlGUtBgzDjqUIVtdYjj5lyFbb2DPE+Mh1vlTDvIKznfXqAEqFJEDqgyrRFDwcWecRHaFGvnjc9byE4/O84TL148R8zwK2CzosUYSisrlFaoAZ/tG2col6wMp6DIg4AYT7WSQ+rwNS9CKgmRjKfw8ME9uq6n6waCD/RdR5wiTmCcDkzzZOhEIcXINI3WyN+Tiip+JZR7W7IiII8fvcHHH32mPU+xQMakl7Gkb+Uc8uJAqRz6euCrwSmLwVF6pBlfp1J/tTyusbNrhs813qe0oF2XzoKZVZBeX/q1TMzZnFJtUFyApZrUV6WmpfVblh9qVkKTdrJWsvKcuX//IQ/u3eP88j5dPxDH2PivJ0nD6tk2J+VkaebDkiIKVa1AHZrdo4gF1nZfIkxT5PLyHle3N8QUqYi+rldN1s1xmAKN9w7xgZlMibk5dxoaVVpAvhhHe2ZrkAJoCOQK6KmBzIlEpOXsxYY4OqlzRtwy/2B5aqd/r5R8lAWcIcsdZS0Lfmrzqf6iHTRpZzeEjkTRQLoL5JyZpmOzv3ugpERM0wnVT0Ul9rpODpXa9vrAuhAIvdl6v1kqJiwgDgY8aLCktrxKG7+OqLYMqq29yqHqgEMJOmsqV0Ulr1o6TpLRBa0SjdP+Cucpoad0W6Tv+fb3f58Hj76CGy7x23v4zSUHBm6nieOcSVlBjSGAS3tefvYpzz/7lPjqBUWE/fVLrl89paSjzsLyWunOMZJSaWqKzoeGIlMHsza/kFoCaNHqkof5wM2znutPf8bnZxdsdme4fmA4v+D+wzfYnV1yee8tLh9+lcdf+S6H/S2vXj7l+uWn3Fw/x7uCI2uVQtm+1gCcdRK3GLBX0OTH+PJeLPGtCWtNYG0LTXze9oPzHV23WSHgmCTpaheXDE77SWszeN3WFlVoWulqjGLvUWp1y+ZXkQn9OrBd+ktL20PQdb5J2usBNFU3u8aS0blkyKp1LEMZKCWSWuN8XmSB21l3tn+VmlNETBI5k1y1/YtIsYiA18oqQJG0NDTbO+UGBRSlGdqrrP7njE5TGsXcHosBguug3jUrsLK3rOYytOW/E82ubE/zPadu5OTVEhc5NVxl/cdAG+dtSxhLYPmset7tbFOsN7IYEKsJcdcNJApd1+PLEq+pAIEa1sXGKO0zmy2rQFy+43taIrFOwHJuvdKtQoTZ7lMn2Na7zaerz3v1/VJ0Bl6jxDVlSbXjOa98FBXK/xWL/gWvL51okFWPXrN5Z+UuRdCnOak8dMl4JxbkW4O1IT2ZjOv8qnyJHWIr/aTa6+Bsk5oV0RNtFJNVI42hyiVn5jmiFCDdOilF5nlimibm40TBEh/RLHGeZzO2ivZ7cdrcUw2tBUo+ePu6V/1kO8hagsvEWRvagvfKH/XBFAo0cxyPB8bjnnka2e9vmeepui/dVLNes4in22yQ+ci0GSg5EedZnagN+Kol/WyUr2S0oFyK0nFEtGojqrAh8RL/xgPED4yHWy52WwKFAJQ08/lHP+di15uhV6TelVNOpMYLNuwM6ASGLhjNSoP7PvgWXNSDL0AS8F7M1JkRxKamCjY4SRMtqehs1qQtiKJqqmLo2uCfau6rFK1WlnV/LfapHmhzXPV/ljwUqQc6Mww9MVaxADPOLRAH1fqrgYUedoeilnoMa9XLPtvWUANclvcy1EockExTvhSGviOETmVXvfYGlVTou4BIpAs2BLCoZK23KHA39GQpTGnWO3eOXIQ4Ze5d3OOT8jlShBgzwcq/pRRzbJwERPW6qcaqqcAsRqp6ZEGday7qTJJkHMtARCdOaTrNUC6l8ioR2lDEVRBf42ZsPyvyGuwTl4CgkQWF1df0/1eHUTO7U9tc7LMWxMb5gAsBJpPsltcZp6elY12bZLaw7rVKNVo3Qds3OVk+ET7/9DPeeOMNxmkiNRW75Vqdc2RsGJrXMEBpZOBq71lZBoVS7xd7YLI8J/uB9uzrwt1VE6nrq2+l9JRSf0e5m5WsyOmi1n1uG7T+zR2niDRGW0V8oSzrXXlk1luja+XAeTJKeZpzwflObTwo1QZwwRO6wJzmkyCi6wI76w+LOdq5z4CnN/W9nBN91wOFIGFpCjZFrorYplwaCljXsy56DdXWAUi7PXFGyVJFIVVmwiqh1oRpX0kJxG8pLoDvGbbnfOXr32Z38Yivf/s32e4eMOXA7VS4PSameSIlTfSDF8bbG64PV8TDC25fPeP5089IVy/0nGZFwLH6s1hVWRUbtcqj91KDeoBMcRkpipwXiXVLk2sxDjuP2VEOe/aHV+xfPsH5ARm27O4/4tWrG84vH/L47XfZnd/j4Ttv0nU9N1cvef75L7h6+TmH2ytur19S0mgVdnCig+y6YnKi1EbZYnZcWsBe2pXV41Fa0tx2oEjrxVhXNFr0CIBHgg628+Jas3a7bxa6aD3c3kC0oo/R5KsTKQs620XqxrezrPehAxodrsVy2XpzliQ2oyBasbt1tivrXl7EZu2/i/X0YUwQahKg59KJkEj2M9XWsMhAl9yEYbRhW+l81eemBh5YzLa2jWbrimjTcquG1uS0HvvV84Blfeur7r4vou988WtJIr4o7H3tdw38UXu38n0tGYHiVmMWVten8y9VNazUhFCD3pZoJKu26ZDGgHOFnJyOhW02xFa02vGy+DxlRVi/JFgvyWmyJNBYQWL3WGM27RFcqlg1SakAVjHp7PXalFxFCGqPpu2hQtuv+h5WjRW+cK3/U68vnWgIKtGXckGcDUuzxZ6M5+4cquISlROecmaKM5thy5R0G89zbGpIznoUvPVpVJ5m3Yj1j3I3Leg31JOsA/HSHBnHUfmatsljiozjkcPhwM31Td1DgCYaMc7EqAF7jlGdlrNwtQZhzf/ZqHqWgLleXco2Xdu44F1QtSlBDVlwDiEhZCTObNxiyOkcJbiG/uZSmG5eMl5rhqm0SOWNBjGj7rV06/pVudmCpixqaHJR9FTiRCeFKUZNlJzDiyN4NXCSEp1T7MOTl8FPjQaudCfVRC/WdGz9KzWgNDoSNTlp2bcFpbk05KINACqKsHihyf5R6vsr19mV2JKHZEkQ9X3QxKgai5wT2TsteZdmeqgHpz4LilYufN8Tup6UM9vtltvbW6CY9jxWtVrKwTXhdU4IThsVXdH31oqGXVlFarKzWRXL9F+x81Ofvign0HqSogUqGe8D8zyz6Qd80IqdnhMaQjrNR8bRkZ3SpxBHN2zo+p4UJ+2hsmR/nEa6ODQjk6GCVC34rV7ilHqoThVoxucudSnnTInRaA56X1VGtBqrtTNa/7s041hP5ul7L4HuF9uiUoMNh12bUKH2FpA0J6d/snFf257JlQ9fTIlIz/q6KW/dIH9yHzWSL0uwUw1xRaaqjG39nojj2ZMn/Nq3v82Tp080MfM18Ffn4M0+ZOvdcFLL7dkGMKoyX4rRqppr6pRdE3VNl2usFyqizvI1lLAGTLlQZck186kJilVoVs+2BRH2DNrzrXvG1soj+pmuUk7rZ64cfYFTZR3Xqoy9qcIB9IOYop3SUvs+MAwD+8OeyT1vv9/1A/cePSROE4fxiJTCFEdCZ/0VRnHNzc2o4UilNgXnNtcpQ0tsdV+uBnVZda72Nek21H0ZTGp8Phytsm60vqIBpXPeehVt6OtwxvbyAduLB5zff4Pv/e4fcPnwHY4zPHl+wzgemFMhxkJOmc450njD7YtPePrZh1w/+Zi4f4ljpusdwzYwT0fynCh5Jueo/Y11/Z3H+0AfNNHQYENnPtS5DFKqIFUVmijEqKinKyvKn/VIOe+0+b7v6bzj5fNnPHl+zX7MvPF25sGjx/TbS954+xvce/A2h5uXPHvyCZ99/AE3r56S4pEStZ/QldQof2qX616sgbANa8xqJ3M9++VuK7ieyznO1KRbhySK0sXsE8rqXAveBJAMccbae6XSKTXuKSLWz6PXNEVTIJqz9Z3U86s2v1Ipx+OoPP7VZxajMtWZDQUhO2quj5HWjJpXqDNx9KiVxiDRs+fJ6/2IqCBhzqpYpZ+oe9FssCt1j9d1rv1wxYLL00Gj1HPe/i5UO16pSi3hqEwRe4BSDxNLMFyfbbX9iuyvn6K8/q9i/WNGIavmybUMbrneBqBW213fSxYfdxdsav+25kxHUVAZtZcqs7y89zTNCjIXaUkJJjBTooLGFTBuKyY0BpD22/h2/9X8rqxuW2+xniWwpLFUGWPd7yezTKQtV7vnttjVf5JbP1qlUOlzLITgl+cptKb5f8jrSyca+9srtrszspTWqFtKsAVwSMps+0CKkeP1FbfX14zHA89fvtSBbM7x6ZPPVUFE0IqB04au4E0iL81Abui2Pg2TI/ROqUwrKS6Pw0toPZFVc7nxL8EaQrNOyKQQEFUG8IIMHblk5cE5S8mr6RGrIEgNoJbkoxRrVM++BSQpJTqnSUUNCkmZvvNKERCdBFqpMDElU+zSW/SoGkgtnSk/VjmXdc6WhXwtRgw+EJNy0cUCaWcVgBxVjjgDZxf3QTqmqIG/d1p5kayov7fAUmozm6gjFrQcnEs2FR4hp1rm9EavUHpHO6J2rR7fNqMzFLWKq9TOiXmaoCxKXfWZtennJq+XqZm1NdOTlMTjhZKKoei1vLdGbBVlj5WehzCOB0sQtVm9wko1QCoVdc+14Q3qBHvn6yRzk8Rd7KMFiPZORfdgFTUQ+2aVziwZgu8J0plThyyJQsK7QpFIKY7ai5YLePEMQ8cYJ8zVIz60sql3SjOSIMQ0kl1gHme2nKtAA/pGhUJDLos5KBHEB6VI2PPL1YnZ8CFdP2cIe2r9Se0Z1/4Zt0J3qPzhlarTClVcVo/2b+eCnr21gcxFqVz1WtszXgW8hZWWfU0UbT+SDWHMzPOR589GjsdbSokUq8AUt76O0+SoXnNTmKs9YQZ4tG2fMykJlZdd0b5ahq+c8zr0SSfMe70+scnUFlDlnBVdE0fXGxqb9OuqFAfJJdIYT675JMmwZ9z2qb2/rNxWcQ7nPCnOuCwL9UmWxnrq3I9Vj406HLf0tRh/P3RBZ0KIU3TYKKi9yZsug63UYuRkFRQ74w1xdgrwhOCZ5tH6f/SB1rM4zkeKL8w5nvi9cRp59uIFYglWH4INig0UNJkQF8gWOCRTCqt2vWQNVpWiiYIvosFiqWorogG2tITMevCkkASK056SrNwtXdtStCkiWwDiPH57we7skhi2vPvt3+Bb3/1NNvceMRbPR69mrm8OjIeRnCIeFc3oiaTrGz776Kc8/fHfULIpG0kiOOjEaJp4xCViKlax1AptcUqHa9LM9RHbM7BhIDZfoSAYDSQliivkmEjzBN7TdbavnOlOlhmXJ6bpwLA5gwiH/TWH2xvOzy85Hg+EboNs7nG2ueD80ds8fudrfPqLn/Hphz/l5tUTfPCkfKSQLMkrFKy5Oc06kLQkHUxrYiMpJQVCU1yo0fY6jEfGq1eWOOT2rCoqrHu52IwpYeM7OhcApcYkQ/tr+0ZnCUqxie3OOZXZDbqQMWacC21mS07aZyJO93wYMNRbz14Lwtdzd8jMeVIaEypiJaU23J9EjK2KII12aGfebJAUQSK4rFWDVom1QNNJ9R+1MmuvdgBW9KhVsnEKDi020vu+2T708RmFurRE3bCIJQHAQEWpCeDS99lsDjVWWdNui+oNysqlrIGPlQ2/e63LyyreFj9mk3ler4czUCWmeZWM6fLklBmGwUCKpYfDrf2U+YRaVVfHkJvaosZxiRCsT4Z6LpfeyRqjINLo2NhucN5b39fQnkOMkdka12v9tO0VEZPd9uQqHlQ/R5Slka1pLqWM4PV6m0+toN6Xe33pROPvfvA3/NZv/w6+68kWfCjqpg/uxbOn/L9/8NfkeWLoPEPQqod3osPFfMfjB/cMIVqSgRhnRcWLDjcrJStagir/IIVsxkNElrIWQjEUuz3OVfBHC7M1uxbj2DtXhwGaFKZkVYlIq+y6BjgpkYpy76c6oJAaeOkq+66WZDP379/n8uJC+z2Azz79mBJnxvHIttOkrDa9DTZ0L+Wkjb85cTwcKcBm2CCs0FCrRjQKjyUzMUajlXUW6GYzhpbAdZ4SoYhjTkZzEZ0SHacZ2XpcqdSpbHBC7XURBNUpxymlp04n1w2bF+dsClP16zUOWUxBDW4MIcmKRt0eD2BGru97+l6bNad5ZghLc98qZmplYbBD6BbEdG0jS9GSZoxJB/SIigMIiiiJCH3fNUpVRRLulnN9XfFSyCaJ6FmCsTo5V42bo6TCeDhytt3oHnPFJO9oSmIFVQlJswa/GnupQwkuI8yaxJvxLAViLogkDvuRvBU224E+BKXWzYl93DOPI3Gc6DYDFEdkxgdP8B2imevCwa/npRoyG4mqKi6y9CbZedF+ncrhrFbdqo2WSOSyNEkCrYJQn8fq4dhanwb39b1PETH0vK1+pk2ol1oktkC/fkap1UA0kTR03Af41//d/5kSI/urF8R5InSqAlZMKrjugbWjqAp1pX7uchuUdZLsPSUWQtc1Y68In9LAnBN+8YuP2W53zPPM9c212SSxACVR52lUPyKilVHnPI56TbopdPBZvfuKWIklF5XfS5OmLckCTcEaRwOh7+j6Dffu3dNTKpoctM+p8EbRRtQaoJS8TDqvVSwFL52BO8vvFWDKYnYlneyF3CqoiqA2Wm1JxJhJWRV2QnAcb29xNlA0xplUZnxQiubpsXUgHSJKK40pMQzniAhdr9TWaZxJ1vdyHCdLRKsPUXpENOficQpqUJriiysoUtuog/r9ZPerQUciFxv0NmfKrMpyMgyEzRn9ZsvEwD/6vX/G2998j253ySEKT64mbscjN7cqzz14ON/0MB24ffGE5x9/yLP3/xZ6x9lFoPeBTQg6qyNFJpPbDMExzubzioFllNYzJyJ0nYoopFyHCuaTgFcDEK3exxjJ0WhqXuVV276IDnEZL8KwdXRDULKWKDUxl2i5qyZicwHfDTDD7sGbvHd5n2986z3G/TVDV+h7T44z+/GGadxzPNxwdf2CTz/+iE8/+hmkid3lucYDtmdCEPp+QBy8XO2GzaZjc29nKG+tNjhTFlRKtHgInbMqvdcet6SVkClFYikUKUzTqDbdEMJSCjFnbQivQanTin+OrsUTYr0RGbVDWJ0k2+RwDKAq5qOUbhih9mIIK9DAtfirgiw5pSUIzMl6EwFx+FJlcAvkaPFXaLa/NsIXS+oAE8OxoFZsvGIpKscsCzCnZ/i0hpSMBr9WbFzOVv2jZ34NPtU+2l9Gl3LOWeMyi2OEE5usVYbT3/uipCM3W1+rOqVm23pducZDxeJF/V5nKlOtYl1m5jmpz0Sr2eM8aVxjgjAhBPq+V7sQZ0uKo85gAWKBvu9wbiDG6STBcqt7LVSGiKySZGmxVvstA2J61+toA5SKlwwATClZBW0d70iL46q4QN8NTNPU6Lu6dtmeU26M2S/z+tKJRgA2XpUgkuHqJWfmnNl0PffuPUBw7DY7Omvw0gy+8OLFM7qtTnoWrHGqJHKK5DmSvbRBN533UEzDWGM0ReFFv17vuGDd8o2OhGaLFoaKZe5YWaigPQXVOOhj0cyyonGxJKZpJqakCjtF5dBy0fkIBVWwCH1vA3P0T61vPnt5xefPtNG4954UJ+6d7QidNjUW66sQy+7F6QyFOWuzsupc65qSdcgf1oCTk809kIqEaIles+FJn4fJ82Yyx/FonDpPKpnea8AY59nkBSN938G8pwoztmAZMyooiuWKU7UJZ4hqpch4kKCrP6UqRehbokHVIOc0EAxmIL1jCV4peIG+6xCbNKtGULPx1olRCmGFvkkuOK+JWLYSiz1enBc675hjJBdUTcM7jvPI4DvSpJrixdUai75SO3yAsBjMoglTM2ti6FDtBS36fK6vb7m8PAdRf1SpXvrAoBDp+w1gVYisqkJIohBNQSyh86K9obtBG2SHns4HSEI/DJSINaL1hC4Qp0KgZ0yzVsTqfJWcG7cd7EyFjs76RCqyVifKw5Io6B6bW6/FCa3sTnLmfK16rKoXbblqgqbXtM4Ma1B8tyzfKBO23rJyXrUPWv+UZhvWP4852M4LUwbfCcdpprgMXh2KA+I4KU2yW8rE6xI0J84v1x194sREBAI29wHEea3ITRHfdxTg048/4be+/1uE4Nkf9lq1MCU9HfZXz16hNuRP4nAhKGLta+prS+hXlwMNpTxdB7RSUhtr7ZyHENgMOza7M8YpN0qbxFjvDqcwLTmb1ZfSlDtzbb4wZ+hEFFWO+c6z/6KEcrm44upzqmV8/boEz7bbmCw17M7P7eOMiinZqIKFz/wTa5BV6tTl/ccEqSpzM9GAmVwyaYJUlBba9T0X4awFHJVaF+NMTLoOPgSjXXm77gUoa4h00fMwR6XmDoMCAWlOSBZwnlgA31H8wPNXN/zuH/0zvvHd32IuHYex8Pxl5DBG9vuJ/f7I0A083J4h8y3T00/57Gc/4vknP6Pr4fE7l+Q0mgxuYipRVYScw3UdcT7YfopKt7GKme6BJRHVJnUFjXyoAXKm2FR0yepX0zxRUjyx6y4tPHNcQHww5oBSx6Yp4/sB8Y4pztwe9oTtOT2FyKyN796GgLoOt71H359xPB558vKaD3/+MYVEF5SWvOnf4r3vfYXf/Z1/yuHmKU+ffsKrl5+R47g6i/JaouG8EPoqSlGs76SQmEm12T9GbvazUrKzs4q8VrhSse4gbZTQapCtQ6WA1xi12PvnkiEt/nodDlb6aC4LmNK49KXgcLhsVEecgmFL5zvgyMUGDOunKkBQai9OaT+p1GQdWOmcw/nOkonaQ1Lq/1Wnre+YsNkZmhwls8NBFDyuqkvNTprPyNbD6+T1JKPve4ZhoOs6DuOB2YRlNPh9nfJGtUdIEx5Z3rPo+t+xLd7iilYxpcoan9JgT/1SraoulbDSfJEBgBZPTmlSVgfqy1NMDFudpeW912HMQRkebR5HzkzWoyWgfZldh+s8t/sbXNaZO6Hv7H6LVZ9X7AxrsHx9jWwpZHmiryUe7T6tF9RrhckhJ/68MowqPX6eI1/9yld59uwZZ+cX7G/3i3+2P69dzy95fflm8CmR5wnvgwXgWsbLuTDlkfO+UxnCoM469J5+05MRwu5cZTtzoQ/dkoGaQy05IzmxHyekJDpn5e6crOFGN4k3p1aRCU1EV42gskyNVpRplSGbMkxNMvRnKipvw1pWGbZzStVyftBSs/VRiFMkMDdnrw9I5yNko5QkJGfSrBrqTsTQR0U1KzVojkn1mk+Cq6VCsCCijmBUsxrwpqwtmmbylfJglaaclccN2hNTcibFRO61x4ME/WbDPM/4+gxKttJr3ZVQt6szxYpiqmGlaLOkeNcal0L9bNt6VaVCARjfGqOxhAvfsb85MHS9St92PdJ1zHGmw1FlLxExjXr9zJIKc85Uydeq7FDEEgBDS3LMLFxD/fwUI56AFE12Nv2gjiFXVSxDTez5OIsvm4GrEVY7v2b8BS1PmzTguL+1IF0R2kpucWINyZLBC96LyYoacoI2FHoJq0qOBfpR+wrmeWYwmc4YY3P0KRZizAzYQKJ54jvf+Q5nF/d4/vyFUZpSQ6zwHWIDKgvCNM1GvVuoT3XviSVbwffMZWyJZinSjFl1PN57VcNaVTPq+i2l9Sq3Sqsi1DMruagkdT2r9byuKo1rNEo/3rXItfqSUjBt+6xIb1almgBsNx1p8oyTInSp5Cqpbs+povrLQKo5qQNVo+zovOAsyY4xNv5tmVNLcKr8bLcZiLmq6uWmMJVyWj4jaulcwQs92TnLQldq59Qojt7r2S2mDBQXNKu+5LV/LAlTMduhiY7SSzQIycSUmyJK8EYByoZI114jqXYXMAU2nCO4oDbNPlifoWv7AEOGa8BVE09v8q/6uKUBlqVkdudnuifj3JpvS0lM80ya9q0CVl85wTQWZkkkMsH35DxrZU9EfYYlRyUXeqf8qEZrsCBl8fOnSXH9t16/b2c150I/bBg2KIc/Z/p+i4hjiplpTpQycP/RO3z/n/0Ow+VDXo6e6/2B21udg1GySo7eP79g8IGXzz7j84/e5/DpB+R4S9d39CEzHQ8ErxZW5TCrD1RAJR+L+mNRVUAREylxwhwjc1Q1nDlaoitKHcnFkXIhzQVibI382jDQUaRqFekqqKgHIIEiA9nvKO4MFy4YQuD6MHM7TrjNzEXSyux+HJGu47jXQYFexARBCq54JJyxudzwzd+4T5yPQMLlmTzvOVw94+lnn3O4esLtzXOkTBYVpwYM+Ds0yJwicR4ptZnb6IO6DVPbq50PFFeQSKMheUugHdoLoD0+Sek6ObZ4Ixf97DqcN4SAD7VikBogUwNSqZL95l9qX0GJK7tJ7TusSZQNsRSbxWXnWGDp5bO1kGLftUQGU13EfKV4Dd7VoVslax3YWiyibu/1vq41VaraY++9SudTh6ZK8wld1+k+zZlpHLW/LEMpNibB7Ib3Xn9fTDAnvp4g1Lk6TQHKznGRVbDvNA6KKersFWoTNy0uXJ/sskq4BEvyRCuzwlodz+KLrPTy7dk53/z6N3n+7KXOo5lnXFaRj+qbnVMK+hwnpcIavdT7jt32nG9965s8f/6CV9cv2Wy0pzLF2IZfK5NHFTTb/dsVidnittfNKC9glFh4YdROu41ULIHMWcFa54hRk9GYFurzLz75VBOmXCnQyz7+h7y+/MA+J1y9esm9vkO8yqSWrA3BKapBd+rdleaR1NhmH8jZkQiEEGzytaIDyWRIn714wte/8hYvX16BZJ3+ScZJamoPuoiyNC3XBS5LFkrdSO3bC42joJSemqC0gITS0IdkOvnLxlNUsSKnmEHMaSW9YZKXOUGdf0EpxHnWcmPKS8OkJVXZUDHs+67SNkxKUCduZkUznCjdye6vkhKg1mkKmbU0cP0jSiGfEq4IIehwn1SiqY1of4hHqVRaBsumaGHJHKUFRRTXmiOViqhc5VSgM855kWL0Xs2Utdlf1b0apaI2GSWr8Igwp0gJ2uQebSJ6MHWUYoibNNpPacmUihLoH0FWfT1a5ahIazbZ26pgIujUeKQQ86zNZKvgh1Sbyyzp9B48xt3W51eVSSiioi7N+c5M85GYZmajInSdDnuk1OAKxumW47wnOO07UY66Awbm5Aii04zr9FcphoChNIYiinzFErW5NHQUb3S04Li4vOT69oqrmxtubw9qrLqOZI5Q5Sw9uTilrhgSOc5TXTY9BTk1ZEntQGjIe21zx/pkcNKmmK73Y117QcAVG1ZZDaElWeucokij+ZguIwYPQtH9VPsCijUq1+dVn2GpRqAIZE+K2k8RQqeShEVp2TEXamtHTlFPl3Fpv/XNX+OrX/0a//bf/j8h16bkbDZEZ11UzrHvejXO3jxLtUVS9Ex5TYxc73l585IpTnSbCiYkilFSClq18T7gXWGKxeZ3oHtQRCuJgjavo5ODcUZ9s2bEGixrgSAbTSI1u6f9fImUJpDMbtczTdZ7Zw22KWa6sCGlI5Uu50xMApSm4EVwwasox3RktBkwLnRN27+dpWSBVueV1kk9ojbEqFQk1hLTDM51Sn10tvdacAHDkMAq3wdxDY90ztP124ZwK43J03BeqUpx+jlVDQbrXSipqhq6dh2VZlIBGG3gxJQV1d4uCkliMVthToXjNHF2cY9f+9bXuPf4bcLuHnk44+Uerva3HI4TKSrtqPeBIQi+zDz95GM+ff/v2J5vefub32DXe0Qi+9uXPPvsF4zHI533lHEiV9pT1un0cRzJ2dH3HcOmQ3wF0rBqqe71acx0AVzQYG+37dg8PMP7QNcFul7pFzln0hSJkybVL1+94urqlQ6eGwJhe0a3O2PYnvPW219ns73k7OIBw9kldNojg/PgVObeRfVvqi8ldaPqYzDsLLuMHzZISeQolDwrM+LK0Q9brq8KJRZ8nSeBMxrdHSpPTMzjrLNpDBikNfJb0GTVnYyeNyzErPuyhlaFTPCBUjJnZxd0XUdOqgRWQYkuWEK7yk/FfGqd41Xpn87EZqpTLzZYNleaY8F61GoV2c5MWfWilqpEV7SBvljvqsUbJetebvdX9O6yVdhrfIV9Zi5lmYEF7cw5841FIIsCaz4EmpC5E7zzSw9dzk2if54mA0UsDtOD2nx5KZkyRVWBLI7QV2l8muJTVVQSpE31bolevUaXmKdIHS6pNDGzQRb/KbhWGvipyo7FYk2r/qPnuWKLyZ5ZVWp0TvfsHDMf/eJjYlKATJyzPi8a0yFbH2vX91CcKpaOWjGNMfLjv/+pUbDhuJ8sTjVfKNW+FGXFFI05LBNqCVLoQhsJIKVSUO1+WIGCLfZcEiuHJ2YQbN4cS84pTtlEVdbeVRvagC++1OtLJxpd8BwOt5zFB4aOFnXeBUIpdN7VrgL9Xlb0MGa0XIwnFa/yqkWbrMaScJ0QNjuy65hzZgjeHq45TsltcVqZsQX9mGzh6xn33ZTrJGOtSUhNMupLTzBgnPwUIRY9VFY1oDmTakEW+kRpsqd6/duu18FzpbS1qcZ+QV5LA2uXJEqvV6ldtZFWTKFAk42COqbG6Sz1d4qh9IbKJEV4hr5DKOQ0UXLSCoJYYpQq98ISLbE/tl5V7m7ZVHr6M6K0n7qZKUqDsIxf6nyPlbqFHjzjyDpHSYnsdGBNNwwcbm/0vuyJOkscapbuTa1FnT3t2a8ze7uThv4uTkwPS0qJ3m+YU2zJyCrz1IAkL83lWrmrDYS2HqhT9yzNfDrRHaY4a7m9FGt+NVnnlPBBk+xYEi6IJg22IQqijyJrIibOk7No4l4NrAjjNLPZbpRXKI5EYUqZcZzJZWKKia997R2ur6+53d8wzYnNbsv5xYXxNFUNrtgzrQIEBZtQDDYs0tQ/MBRdjFp30ghuLvgOIiYrI2gHqiX6rdHc1lPEWg4zi9ORatD0mUjQZvWqxFWd7vqlDtPaeA25bj9UarkYJGdTPZMlQUYTyhwTeOXyn59f8ODBQy4u7vHi6dPaF2n3YI7EkEwxp4kh+86QLyoiWqoKGTx7/oSLy0sePLzPk88/Z6GiaTKbcqYkDYbVHNVekWxCHIvOuTijNVLA3r+CLMvCeANErClQFLwowDRPXF2/YrvZacXLSZtkr2ikPvNKHxK/pq6Z27eKhgvexCJqRSgoWFLq8Na6PnLn+qTtmfXXmp2upla8RqE1IbEkvB3Mk98NbfsoD15/rpQacDcNOCo2qMdQk6mKsOtechbIrDdbrax7S1ScvbedyRQpKZJKYZqE6SZSnu85ulv6qSMH2M+Zw6w0jKHr2PQdvRNKnJj2NxyunnCxC7z51kPu3ztn6D1SEsf9JbfXr3jxbA/F+hZdMKlycLJFdhet2ksw30Ehp0KSRJIIUYHAMgsyZ8Rn5g5ijrgh8PjyEZuLM87OztntzhhCjxStHt3sb9gfD9YgLkjXI77DuY6L8wd4v6EbtnTDhiTCXHQ+Thaz4dHOeJU7QlZH1fyRq6yE0mhGKhAQ6DcbzjY79jcHDUarfcqc+vR6ThMGeEg7T9Unqf90rcIqLD1KFZjUpMBpgOs9JcF4jMRZEf24kpvPZlsr4FKpt+onlJmgvkirrllisxMAkmtfqfkiu27nxQDE2ALJbDeSSwbn9XhksXza66rWmUMefDE1qbK8rwblllw5FaXR4Ww1ril6hqEJu9Qhs9muu2AhW9aYTddvVSEp9iyLCbwI7cxI0Sbjoe8pG4izUudLXmKbuiW8nWsx5aPWi6aGmZKM+pzUH2iisZqTVcC1BM72QBU4KbrGVCq0nRfNS3tLbk73DhFu49hsmPqFUn9glawYCFsybUxC1qG305zxxRlzgwWoq/Gq5pn2rNexiiUMIuSkf2rQJvbZBYyaagyg3JbBQNxTdcSqtKbJZTZWANaflxshQj9eWJvsX/X68j0anec4HsxoK4oec7LARFqjl4KOGSmeLnSMc8YFhyuhLVJKibkAQSlIw/Zcp1lX1aeCbcAlMG8B+upnTrOJwt2vLF9QY14TgfUPVYMAsEQ/pT2Ikotyay1DKe3wcZKYrCkgDk3WO3EMYdBd9fqVvfZqSUq9cEPN1jpnUgNvauO6vPbWFoKogaNANvlak8ErWRELSWpAVBrWmgDtAtR4VHWiZb3rfVe+dt2cNS6s6ytl2chOKsJ7ymnXYDWBBLq+o+t79pYoVYlF3zJymlFM1QCLOvUqr9j2ST1vS5zagqFa5u26jnmO9h4anNa9WxfRTEVLuKTJ6GmSozMlqquq1R4N+KY5sd2e4X3Hph+MjpXwAcZprwZJIOoYd6WExcSc0fkOrmijZtFE0zmn/SuuZ4oRmRUpj5aIjPPEOE6a6MyR4zhyHEfmqAhO1w+cn18QkzbZcjy0qpXFWepUTf3ChJ7MyVifST0jLTBYBV+yCh5FT9CaB1tsG2dzZhUpbNDNavcWC9zE+da/kGtVo0ijG9Y+oqVMvCTMYllBkdpHk4xCYlSAWmFpiGZGQmjexwlcvXrFRx9+oN+zuxBrhjut/IEz3Xzl1q7oButEyjKH/X7Pw4cP2O52PPn0sxZQaKVPAZZs1V5En32xwDYVLXXXwKqqk7QqitPEWhv6gyo9VXTS0DhxOpDUe22EzbmQUDTOh4CIIxSdIVFprj50Nhh0ecatJ7YUfBCtRFtiVNe3rJI9V+ycCi1AgsUG36WQ1jks64nyq3ihrdvrvk5WP6v7u/nkuh/rc2cBstqFWsWjSKaO3sxV+tICpBpkDZtzypxJ2Qa2OZUh9oMYnRTOcKQiHFNgfnmgmwPSRYrr8WGg63q2fccmaCIxzzPz4Qama+6dB867TMhH5n1iGo+Mx1vSNJKtn9A5sb4utYmu0iJTJueZmAq+H3Cho/Oei80O79Q3ldBpxSxrdTqhDdIMA9v7jxi2W/rzczZn52yGLcFpf9UmTYawWgBjzz7XNsriyUU4VtBFbP8bSOlMOEKTz9Jshj6jCDnjSiTnGSkZb5SgkmZ6L7hUOB8GjjdCjBh72Gb8rClAWBJCULqSALn2kNWNRHMWUlYIeA3GQX2kashTokB2TEeddFGDNN0a2nSbK1IuzgJVWYm6uHavFbCpYEcRMVpVaD6zRhUtuijeEHij+dWKcfE63yipjXW5nkEDQ8ThhXbvkqUBOlLBuKyzoFJM7aznYqh2zrgQFuBQBBFD2u+st3NLklCKgjrFrpvimrJbi/W8Q0owWzdr8r4Sn6kxJUUFfMgLAJutdCD1aayDaaovqk9Kr60aoYKuQzZblW3vIhq/qD3WBLHkapPqGlbDggbleZnO3YJ966WVkoylUn2Egtc6r82WvoZgpaV4FjNVm1XPVrGPXXxsyTOC6HymwtKeoMg0Wu2ywdTeWAAFcJ4+BKXiNnaA/i+LMn3q3ylHFbbIChbWKtKXeX3pRMN54TAetPzohRLV6VG0hB7ThIiqCWENln3ocPOEWPmrFC3zx5jJTui6gWjUJ+WqO1LSxivNxWvTed02sA7FgeWAwLLoq9svhjZ650mprAKU0njZFa1eqhT1euuGyooknKypNYHZf2WW4DmXjGT0octGs8JWrbDjsA7CcqENIlobH0MBdGJm1qSgZpGr+Ex5o/WyapChdCkopKilS2+opuRC33WUebIgS52pbmJzACdoIdgYaarjhhWKYAa1lostTDAqSaVBLIkDTphLpdAoLciLo6vyl41fmsjVKIsYt9ucIihNxHfa8L5GXywxE+9ar4AXRWNyUTrSdrdjmid7pvXgidmo0hDgmFX9TOk1Ns056+EPvldlnGLvbZSxVDKHceb+gzcJoWO33bIderwTchm5PdwwzpHDca7RPNM4cXs4kovSoHQycqLrB6XRFMEFR6aj2+6IObO/mRr6kVNmrNPUQ8cHH/0CoE0dT7mwP+iUeqwcW2WnMTm9lDTISXFSiqPt+/XZyJgjt2SznRehOYVaTVp6LKQ1B2rjZO3lqZvYGv4FRbuL4EPH7uycfrMlpcSLZ0+aA9DrscS+Jq4ro9yeYUUvTVlOXE9ptXiLLZa4WfuarFk2xYlffPRzPvzgZ+SUEal0iqzXW04tTbUPTkzfvKKqYsUcJwSbVK9OU6UFg1v1YkmtiuR6JI27vQTjp/ZPAwXvPXXAoYjXYME7hmFDPwz4blDaqVvR9xp1Q1WZanbuVjSOsEICtXengj56hivmWcxmUIEP1rZzZeeoU4wtAOJXvAonv7u+5+VHFuDn9V+vRnLx0nL3a+2DDMQwX5MoVinqVNrUErhG0PHau7cJG954/C7TVBinpKp23hOGjs12w/luB5LxriPmzO3+yDhHigtMMbPpN2y2Z3Qm7uFyVnGUeaZME26+ZToeebp/gUjhcDxyfXXF7e01Kc54AR+89RR1+E7pajilQBQpOL+jDx2b8wv67RnbszPefPwWZ2dn3L/3gCyanKRSmObINEd86BHvtaeEggs9I3CYEyXp0FkdhAhU2lI921Q1tDqQUsimWpMLSqMVR+99a/+o57FGUiXNkCMSZ3yp0jMJT2KMRzZByMfItg90LjDnkZSLURmN6nqyYzw6r0Sfdyko3bkUlhlNUGoTc3FWPZV2DyWi9HDxxjDSwBgqiKDvqWpuNn+lLHGI5Opj63wKWan6GbsiaRO5F2eD4aySk3JTLFRA11dc3XAfDVgcjpx0npiuq+3ZQusXyy3+YN36vIptNJiukqhi61KMNlQpvqUGu/WcLngCTnTAn9K21Fb6uj8K4NRHZns6AhAz18e9hRZLguFc9W+18lSBoXblmjTZz32RzWjUyDXwURNLcUbxDISuR3tDsjWnJ8gq6EEWOr85scHGuWhxTy6yWhfb8IjKJmOVF9G4pE6Vx4CymKImsS02VNp65x3i9bPWszHqz1W6XppnU4Gz510TyhzNIeocsM539H2vVEmzZduhx3cdfdfhQ6ALPV2winDWCif2d0pRwcoUdSZeSq+t9xe9vnSikdLM/vpGDyCZnGNrhspo45ki21pirA89eFVcigXiOGrXe9cTvCMmPXSd77ThcorkodPTVBRR12w7r8F2e8RL43HdcndfLTjKtZS3bMaFh7ckGhWdqyVM6sHOOpzwpC5hgVZF3dqByJmSlCagfMPUnJy0LPS1K13+WbOIFsN9sbNdKgN2MaffVfURRIN55yr4r6VaU7SaTekLK7Fqic7KxbkACTF0BzNoy9wkvc5MRVmX/67T1HPGAhcLPkyTvN5ecB1dCG2Ao7dAaOj6pWTX1DZs7YyaoS0SimfHUghiWbwSp0lFh0aG0BFLZE6xoekueLbbLU9fvtIgEhrdzLlAlbZznQkSlKxNaSXjeqcc/64z/X3lxKZ64IsajTgnhmGgDvWa55ljnLi5fcX+eE3KkcNxZOgCwXnE0OV+GJQ+hTDFTOgdMcHVzS3z/BJxjt/7R79HCJ6/f/99rm6uuTy/4MHDS37xiw/ZbrdcXl5yc/WK28OeXFQJJ40T4zgyxpm+3+C80xI51aBXznKmOK/9RdaroKhlIeW5IcGVBoDR7Nq+tUrFkmSc7vDmQBqztwaptplFHdvDx2/wta9/i3v3HvDq1RV/+uIVyAzeEacj3kkD8Vsh0j5FHX9W+1GyCkz0gYJOWI85klDKB95B1n0yT5Ndo6MLnlKEOI9QtAfFZa0iqdiDJdVrfnNDGRf+9JqrvYhSwO3NDTln+r5nnCb6EDgej4TQo3NErAFRjG9rCXIpogo0FlBtt+f0/YbNZmt2Y2lYl6o4ZmIIwS+VoFwKKUMQD+hkeed05kw94bkUvA9thoUivbIEL9TqjVV2XjPHhWowGhFDWFDUu2at/qoFLl+cGKxtXq2wvv5OpSUPUKW52jvVt7UrU5nkbMGdEDNEU4rKriPbOvquR5zKAb/91lf4yrvf4I1H71LoQNTPqT2MTNORXBKH/YHD4QAxMciGrgih6/G+s+svSEk6Y6gUZlGlvzhNxDjz5Gc/oeZ2mOKYpEjY7Lh48IBHb77JbnfB5f0H3H/wkLOLCxWkmKL23BQBF4hmR73RWVNMvDzqsNBsfYiIQ0JHzKKDbE3YYdrvVd52jozTiPb2ZB2yWxT51sJjITjH2fmOzTCw2XZI6DgcR/b7A9MUcS6w3e1MBcnju04rXUV73nKOlHm0ACnjRf2V5BlHwpFVjXEz0Enk8uKCnBPjNDW0Oa/3YdswZt8aaCnNJ1d6ns7GUuDDO9/mYNQ4IqwGmildx6/EZ8DqQZAWcYyckyYQdhmZ2n+p06Cswa+dhlyKqaed9p6KJfcav6rVrn/XZEN3uFdGrflqnVEldL5vcc9CJa5J1ipLqPNwpKdVu6n2BNJcKWHObIDZ+WJVXO9IswFyWHW1FLDuUu0j0vOtQIc+h5TrMEShyiZTgVaj2uGqJLHaj0YNdJXRsKhfrRvs9ZmV9kzEkiBBlbDOz8/Z7Lbcf/iAYRh49uwZz58/5/b2loz2Zmy3W/q+b1K1w7Bhu9kyDBvtwbT+ozU4XYf5hdrkbtdUp4vP88Tt7Z7j/sDNzQ3jeLQGcO3p2Gx7zs53eK9iQDV5uJtwUJQCO08z4zi2/pVs/bEVfTth7yBWedJTlebEOM5NxIZmOy0ZcoEqnLAG58SfVg9/2evL92iIIx5HSBFXN4vxFbFg3flQP56CME0R/MBhnLVUP2yI00w8TqpY1DkyGsDlPBNCT52yXcShzbH1wBWWISWl/TnxbWsCWQ3szZDO86ybW4yiUJSiU/P2YiFXW15XWlDtvDkuu45WcUCsFKPfqc3klNIaotvDXRms5e9q5FbUoHrmiw6iUUbaKf99ccK0z640Ei1kanoyTVMtUDDNk8ns6XW4EMiokpFS3gypZUnqtJHIEoNSSQTL2rrQaYNnseYwQ60TMOfCzTix7Te21onQDJ5e1GazaVSu3XZLHiZubw70l2fkrHrmmswtRjjnDMEoS94hJWufQ6zoh+2QooZ3mhVBCz6oRDLgA+wuLnE3t/gQdJaBVYKqaggC8zwjqJxuMAnOEpPRB7RipVUObZaaU8YjjNOR4ArPXz7R4KwUxvHA7e0Nc5yIeWS322jZOasCVvAev06lfU+aE8cxgnNk5/GDqlGVbmAG/LDDjzNXt3uubm9IuSDTRL664t7FJTErRazre5NsTviok4BdCLBgilR/UZuv1d1Wx2jX5HqEShFc6ER2KlpQ6UWbVrPt++rEctFEscqoOnHWvKgHNaGUtELhOE68ur6muI7jOOFDR5oi4PH9BifVadZUKdsZqrahBrZiE7hhmkfEOeY4czgemeeR2rWXkibIghr0eZ6tR+M+Tz/7XIeA2VI5p+obqvSmjjlZlUuqsg2GOtk5ryarlELoe15eXzHGmUeP3+TDDz5QqkwI4HT+UBBNiH0X2v4PIdB1PV1QVMr7jpQKx+Oo9AbnCV1QNE4PiCoQFV3dmO30tqpoIed67YLUngpZeOXzPNP3O23yt/6Dam/arJNqhmpitXrJChQpdc+skN6Tn737u27ZO2uwof1b4cET52dvv+pus5+r9NA7ScbiPyIxQSGQpSfi2N8mdpf3+PXf+D5f/fo3ubi8D+KZYwI8MRWeHhJzjByO14zTyDyPzGki5UTfDaqfX3qyZGTY0DlVb8nzTKkT6tPIlJL2dMwTczwifeDNr36TX/vOd5t6jQ+erutxIRCLzm4I/YDYTIur5Ll6NYJEbcZ3Ow10uoAv2pg7xcg8H+l9YH99ze3tranKRGrlWGU5tdrsbf5TpXq2pbeNrdVoyGlmnCdu5pEnn0yIV8GN3fkFvhvUlxeHDz2zKwzDoMGxqTRSjLlgiknVT8WcKDmSYsSlSN8NpIOqaV3vD2RLDOeoc0OcC8Q83d1ZwBcwF5YdA9DU1NZV4hM5bwvcvbehjbbZ6nlx6Nwm8gJ+qCzr0qcoCJ3rmlrT+hKdMS/WtNC2zVHQrfa41apHTQRqo3UFVVV2v9JVIU7z8lGvndHllU1xTpXMlnWqCo7BYqe6jndjGlW2WiiXddAjZVGo0rhXvUvj2tVqqAHCTYGnJh5R+1i6ToN9kaqepvdVe9Xqs/Peq4KZ2SuVp4YQfJsV0U5+mbi5nbi6eaVglA25G4aO4WKHc47D4WCUxEzKE+OUiOnI9S2kqPFlVR8cJwXd1V6r2lYIoY1DcCYjW4fpeXFttkZdZxHhODqePf/Mqg9idKWatJ5WxOp7amVxAbh0/o/QDZu2j/X3VDK/XlMpReOxYpLXdi7mOXE87pnnREpwPB4Z50l9TIykL7Tkr7++fKLhQwOogvd0ITCLNiU5hyEmjjlmuqBomgsdjx69wXlxJHpKgbcfvcXHH/2Cp8+f8bWvfpXNbsNuM/AXf/of6AYdsqSoYc20F45aAsQy0YJSJn8ZLLb4k6XEV/99Uuorr/+e/q0j84x5rfM87JosHG9oyNIoq1m1E9VzJkVqs/aihFFaEAf1sMqdK9ANoepGBhm2n6+GQtq76CG3NTFH7INnnCe6LjDPkXEc6brApuvwfc/ZbsfhpYMQzNBbO7e9tVTOb64DeFzNbU1NoZA8KD1WqJr6yrf0JApvff0dvvGd73Dv3j3+6i/+ko9++jMudgNt0JEEslenGSSAU0WzOXvE9cw2rLEdEB+Q3pFFmNOsYgSopGxGjVqJmZRmvV4nRKNH1YSmoM7zeizso3A7af9KH3S6a8rZ5PEcRTKdIbpzigTndM5CSkwx2kJBzNrTUBvHfXCKmKMlWAqI81xcXOCCI6WZOUfmaURcr30WEbrNOVNMhM2GacxsNjvmGIlzZLPZ8MbjNzm7uOTJ58/4+NNPuLx3T2kNxwPME/Se4/H/y96f9diSZeuC0DfmNLPVuO82IzIyMvN099y6F4EEEkggIRAP/Bj+Dj+AJyQe+REgVCVB9RKXqlM3z7mnyYjMiN35dve1lpnNOQcPY4zZmNny7TtvoxKUZcZ2d2tmO+bomzNev32T40VOnx9Ez+U9yCuTw9BwBxGICYTKjzATIt95reauObc1hSTr/nGyYlIpn7WkGnHveniv3HXiosnKmkQrSYnMjGedMxE+f/6MN2+/FYtXP+DF61f49PMERyJGW2EjABk/OG0n+6/quYsx4Dxe0A87JBDO0wlvv/0Ob9++QQwz/uZf/b8lraS6SEmgtBDsvuswTWdNX12QhSlGHbMy36xxFAt1as18K9ELLJaMmxcvcLy5weu3b7HfHzUdKaHTeAirGVIIumj6QpD5S2HHYsGYo2gru26HoRdL4hylTsvgu4ynLAWk77rsXjhPEeM4iolfGRryXlw5o+xdogjmGaZMIlcCvQWEilAkeMmyXOk+4XnaL6BC64RWioDtbRFzr5K6SgYqwp89Mnwpb7AbxF95d4tXb3+J7//sn+Gb7/4C6Aak6DFOM37+cMI8B8xRUsOOc8CjKtGIupym+3jYawzYLHSRSNKJQvDQHETjmzhJ1q8UgDSLFh8BXU9wNGDwA+7Pkr6XvANFxsgRAzymkPDq9VsVZklcMccTTpcR4zRnF844B+wGn93gHBF2w4Bh6LDb7fHq1R7n8xmXS8IcxH2DUkRHBOYAzDPMPYqprJ9jcZ8WAdXDQzID9oMH7Q8iWDlCDBekGOCoE/eu5IAwAb0UQfTO5a2yJDCSGSkizJPsECtTqlrWpHsXE+HV6zcYjgcwJ7y4fYHDzREpBPzf8bu82y9fvMLr734tKfmjFkkltXJl5qAwYXEOmKZJ6uGgCNWWmlsUhylbN2IUq0VgLXyXgDCN6HyHw36P/fGQGffiXaH0Qr+Zpiln7Nvv9xh2Qy6SV9f1maIwqOM4YjpfmlpHMUZhyCsmHc6J1RaywFb41zmHvu+x2+2k5sswZGYVTLi9vZWaF1b7Qgvy1jGWJtAY486sRTzVcyHMAbOuYz1GcZkGEosrDhhiPdJYQ4KMTVJaR0l2EVMzV3Mxt6KhNY9UxmlKb/ntfLlgGkdRLFZMv2NN80oOTIRpnhBm2fvzmcSlyHv88Y9/xOXhIQtOqpmDSomKWFJWuijw2IDK3ytBV/ncYcDxeJT9HwaACF2/R7cbcNzt4XpxszWBJsaIoO7OQML9/T0sNX1SLxGxhHhVpA2qoDJFqbrsuqrmCWuoga6N9VcElA7DvtP4lbRQ7l+/ni1ozBepNirWPpLgKMhAIjlEBvbHF5jOJ4nB4BnpdMbL7zx++5vfAn6POCe8vrnFh59+wItjj3/xL/85Pt19wIf37wBIFp6UAgKiZpPS4jNOmXq2PRH0mlTmX0ro9ZVQ5WEmZWZUQID5HCfb/3bRCKIVi/qN9W1sNQDNV611IvQeZ/cj1TBATYAqtae6H0LO+mOMPViEKIcikECzbznnNNSVs4+5JPxxGmwqQWH9Tly3Hh8voF5ceFKIuIQgglA/ICrTF5yDY6keLSa/iJC79Eje12KNEOgkLjYwTY+EwCMy43IJ8F2PzxfG8fV3GG5u4PevMNEe7x5ncJrhuw7DcMRDBKYETOMEdAN+/df/Esf9gBBGxHmUzFQwtxRgChGP50cgRsQpwNL1Zf/WzsPvCa9evcXNzQ2QEmIQhj+EiHEOuEwT/nB3wdTf4NWvXmN6/IT5dA+OAU6tbI+XEzrv4foOwTJseXFroa6Ho4hpGiUTCFRrA6nZ4bzHp893uIQJ8xiylssRIXLCX/3VX+DV2zf4448/4vvvfoXXL1+DIEHuAYx//bu/w8cPHwQJkwjy4+WE3//j30moDHX4zV/+Jbq+x+XcwfOMh88j1AEeh4Ok9vzu8D0eHk44n84Cd9EENi22pKZTiadhsXh1teYYAsNNZjaG5NRXS6DFL2W2rcuQorGwgJfgZtL0GcVyr1ZFtehl7T9JP7cvbvH2F2/w/v0HhDArnx5zil6Y5s9wJPTQiC6xDJk6DLs9QmBcphn7wy1evv4GxxevcD49oj+8xPzpo/q6SxzFbi/MYgLD7QY5J3PIioWidRStUYIw2p3v4LtCgLuuR98PACGbxaXImxDTOSb0uz2c77DbC9PfDzt1PSzE1bRiImhYDRXG0O8wjpP6FUcAj00/jjzO05TN9YIiJCtUV7kSfL6/x5//2Z/jcNjjF998g6Ef8NMff8JPP/+MzhPgxSWIMxEV7MSkKhkmQAPijahaULeJDSKPcKMcegp31zhSYK3Gz22MzvL9pUgjApsqQyBKHFYGgboBcAO++9Wf4ZvvfoPjqzdw/QF354jL5Q7MDkljElKKOJ1O+Pndz/jpp3d49Yvv8Ovf/hn6nkQTBRFYI1jcj0hT+SZzR005SBgOYM33H1NAjJNkOkwRoITLFBCTxJdRZMQYcqrhruvxh/PvVftZ/PwBYAe20iWAd+A0Ayxa14fHRzze3wtMAvj2m2/Q9Z3qA2yMomQIMTS0k9T7ACyxCDGIRZard+CA6JL2C3AY4Shi6MUNr3eMjhL2HaHfefjOa4ZHCbxNFIE4a8xnUpcadT9OjCkE7PZHDPsO3x0PmMYTcO6ksGzXgVwH17sGxnaHA16+foMQZ0nR6RjeD/BeGVEWwf10fsR4uWCcxqxxNk21ncOUEjCHinE0F0dbAxILcgiIKQBOXKGcE3e1aZ4yI9h3fWHSzariHB7OD0iPmnVKk0+ARVk07AbsdgP2x50oZzQDYJ0+nVlKDqSkFaw11bvvO+z7Hbwl01CehVRp0HmvYxM+6XQ5gy8i6HZemNxxvOTzCEKOucv9Rk0MA4VHjTuQxDQkbrxB3HOcKr4MS3ReYovCNGGOJ8QQBB6dxOzGlJBdkiDr0akQEGaNL7S0t84pzpR4o845HI4vcHPzUuLT1FLSdR2Ohz3Ie8yzMO5JBcdpnnA5XyRcgIGXLwcMwwEWa+GcKGyGYUA/9BlHhcQZH1utNqvLZHxmjMIXEEFj34qgCwAzM8aR4YiBacLpISz0LcLrMbzG7gL7fZfbIbNsQGIfI8diidLvHRXFkLn/21hCgiY16tDvpE5PtFg+k+GcR13k8Knr2YIGE9AP4rcICICbPxc5yZ4z7A4Yzxdo2DtCDPjxDz/g3f1nXBJj3+9ws9vj0917nC5n/Ff/1X+KmIK4MFDAi9e3uDzcSWCLRWOr1tVZJhDlRrI0q3O2h5kUVb87y++v2Mc5LcAXgDjPJSuSbSFZkKNoOhzENQgw/2/TIoqW0cYl+1j0dub3bhvJKIQ1d0co9/U/1kMaIX0IXdeaGiq5xywoC9GUOFI1OxKD4DClGayMsAjawhz2Xg7YOSbRdM0RzoodMiEkYUpEAt7lIMOuE8LgXQffeww7YYiy+xQTZgbGEPHweAJ3Pf7rv/lbkCM83I/obt9gHi9I4SLEyff41//we3A3iBtKZFAI2I8z+sHj/vMJXecV0YqPpvMeqT/gF9/9Aj/8+KNoQ5wEmXlFxjFFjOyRzmJ1kG0kMHkER9i9uEE37NF1Ho4SzqcHcTPyDr7zmMOMbjcgxoRud8D/6H/yP8OrV6/whz/8hL//N3+PX3//azBHhHnET3/8EYkDjn0PqaNCOJ3PmKYRp8dHqfFBksZ21oP6x3cf4fo9YnL4w0/v8dNPHxHniDkmDIcjHh7P+P773+KHH/9JzLAaJ6EpyIAYMY8jzqeT+nxqHIya4v/w448CIL6vBGjhArxX87wicMv0ZprJulZJdbhQ/HWlRio5k861togKHE4ZOGYhWNp6drkDJQ1MVOGCCcYVsamnNdf63/+bf40//PQj5mnG+f4OjACeJrEqBXX10KxUpAHtZIwwm9uXuhFeZg1idxIYSj0YHdgN6Hc32L12OO56XM5nBC2cN4UZY5wEt3qPwe+zqVnmbAyjMFXd4OWM9ErIIPDaDb2sqbofmRvGHBIu030mBq7r0Q07DL2cqzBPuFwe8Pj4COYI5+QMZkEnMabLJKk1c6yYCgAMTawRNO2pxH142+M54jJGxBDhvMP/+n/5v8L9wz1ijPjw8x9wPl9w9/EzzuMZKSa8evMSh5sD+qEHnMQpjdOEaZwltaoV3MuYzVxQiqtVppNVzZqVcqe6l59xK5ygxaCrS9ClxZNxeT3jWJctAc538N0Ow+EVQANO54BAF/Q7hwivGt6Ey3hGGCXeYppnHA8H/NU//0vs9rfovPiaGyEgTuAYpb4DMUhTn5oMZnsRIUxZINb6UknOepLUuBSjMAizJccoyzFNwoBLrSWbYnFlyfKXZUljhksJx77D8OqlnBVPSOGCKepZR5lDSkIzvXfqa65Lp1ZNUKeJWETItAx25AjJQRlMs3RGYTDPJ5ySWEbJO3SDWJFMWBr6AcebA46HA/a9B3cep0tAYmEAwzwBcUKKQHIRg/cgDX6/nM+4+3wPuA+LVOzA6XTGuw8fMYcZHKQ4Z6+FgxlmMRC345QS4Ht45zHsxD++WBehKWkDDrsDkiYtMbeYeZ4xzTOGvpescWy0VxhuCaQVC6tqLXMCjmmekKK4Aacogk+yoqfKiRMY7oE0k1GxUoAkixPlNPWmAIJYwrzWrHHqEul8rYZRBtfruRHmmSGKkag45bDfC4SlqGuiLnWqX3KOAergesm+1HVeFRlqHSYvChhV5nTdkDPcGQ+5G3YSbzPOWSiMMYpL4iRxT/M443I5S/xRAkJKYFYrYwgIZuGACEHOj9kljbxm/fIl4yA5Qt/1GilIoE4ydxn/mBIByg+BGP3uRtlS2ZcEQgiEyBHEIgyRl7pnEeL+74mQkmUU1HPGGtMhQcAqiCHH71glBSoOoJXKRmlsUkugWh6cr+Nd5TsJ6hc6RRA6AbOSZ+W4A1NEYo+cKIUlOYQosRmcSD1FSOHAKq4HPOd6fjC4S/BDD1YJPaYomSecaBN834lpB5LWTbL0RMQ4Yj5FnENE6HuMjx4xzaAu4tPdT3BegjoPNz2GncN4loBlSTAjhzupaTOatOZUG8VV4RUCiItWJxM9PWxJzfjH4xG3tzcgEH784QfxxbNDa/hWgcgkc9HeGubi8l+mYbZdpskTgLDgSzP16hap7te0xOKilIPNtRCMckyIJP6YYolhe1210/pa5zSNpwxJ0mAyzvMF6HeaxYhEIEgJAcKQv/3+1/DEOD8+il9iDGCW+hzjGHAJEfAHDMMR1A8IXQ/uxMIxExBch77rcbk8ghnYHY7oj0eM5zM4DUgEfDyJViy5Hv2LNxheAjEJEg1zAvZHTEn4YucgwbGOMINw8YOtKCxgzbND1w/4HBg83CCEINmTjECSBDJGN8A7KYZkeaxTTPCU8PLtG/HHdg5hOiMykOBEuyjHUc2LCWNk3D1eQP0NuDvi1be/wYfHGZ4SOtdhjlBCLD7WpvEbL2cV3CRJMHWiVWEmTOOIy/mM6TLB7XYqlJzR9wPuH07463/x19gNO/z8/iecTw8AJPNVigW2f/HqFX788Q/wQ4+hE8IYOaobhxdBKZmuSOHWzN2dBvJZliOoMGCAm+E6Vb+TpDi0dJQg9RgSC5/UU5E4hox8cmCeHUjRmKQYlBEs1gwJ1Heq6RIk+fB4j4fTgxAAJDjHoMFh6Dtw5zR3PITJM9dGNkIr7h0piSY7qfDEDMB5jFPAm36Pt7cv8OPvf8Q8j4iQBAAdRAMYIQLesN9hGHoQswaJauVrcjnZQWLJ9NR5xU+GHshiXEhjO9RMrfipU+vCNE2YpwnOOVz8rOkkI6ZxFqFJK03nFLXKxKc0KxOhyozsH24KjSTZzmJERwBzQJCKmzgeD/jN97/Bw/kRvSfEMEqBLU1i8frlDY5xB04J++MOrpfUkqWCdoTUB0wKIdKv4UMCZSv0VuyG6pGMg0UG7vwSZVzM1Z+5BTJ8vHFZCk4DfUt2oO4RzOJW9os3rwF16/n47gM+vP+Mm1dv8Pbb70C+w6dPH7EbpDJ6DDOIA4be4XAc0B9u4IcjEnfKqECsDxzAaUYMAaeHe5wfHwGWYNS+67AbBhwOR0looGvpFW8nLdqaYgCHGVZMNU/GFFWJAM3PaDUmTJklq1NcdUmFbWIpNOp7p0EsBKSo6UG57BMbLCXEpGnh8zNNa0lB08UWwdnc0KBJl0OYBfc6AgeNSUiMy+WE+4fPiLO44TEBu8MNXrx8hel4QHzxAje3LyQ4MojQFuaAeZ7Eg0BkAbgEya4Fj5CcZPGrLDt2RTVCxCTxVCKFU07gwJpsxpGcZREqEgg+M+pO4wWZJJaJqUeJDvPCjAIgL/mxxKNBk5kwVOgQ90txV1U3W2LADZIZTnzDIR4RsRWU7WTpRlogL8g4E1b9Lkn2xBS0RgdUE04Z/1sNCsNBpkJlFfjgnRnH4dX1LyZnHwCp5obqDHwieIk7vcV5CQ/nNIGLJ6+WjEkUW9q3eGqfQaRpYlNQOIRalSSFdEIH1+3Qoc+4npjhKcFRqgSo6ryY1ZUAZqdnR68EpEmU1s55UQZVpgOCCUsEi7+T/ZMzmcCIUWloolzwTgLUBfbN60JgQWisU25RyJKXYn8MFHWMYNN87L3BlAo4zOqSJlMUhQhnod2TzwIDiKS2C0QYsSKc/a4XN13Xw3ngeLiRlPpEan0bEeYoxYeniJhmTOOoVrmgCUv+HVs0Zp6BDriECyjsxN+RxS8zxgSmHt1ukOQRMYm7k2N0HSO6gF3PYB4xK4PsOwB8QYjQonLAFBMSBamia3Gqzkn+Xmi75ApDBJGoTRCxe3Y+7adzQPKqkfASQ0BECBDGXZNrFvSUIUCbNVWGtl6TzKWlwqwhBBNwpKq6mZfN7csOv5ldk93Tyr45kw+JFcNKxSeS+cQUNbjbAn+k16TAvzveYIoTHi4jhiNES8GawQNCCm7fvJYYBt+JfzgEnY3jhF0v1oXu5iXQDRjVNcqhhyeHaZ6AOWDoCOfHGSkxjtjh2AOfJ0bwe4QYNBWkAzCDuoR+16O3g3Eesbu5xTyOYIg/oeW1meIMOr5EijMsMBBImCH+1ONpguv3CHHUQlHFnSdGwuu332LfdeicA5FI3mEKCCnhzds3GOcIJod56nH+NGBSWMoFolRDcBkn/PjHd7g/R+wPt3j1za/xwz/9AD949L3H97/+C3z69DPu7z6C4yT6BwekeZYA5iD538WNRYhqCgEPnz/jch7FJByCuEwMPUY1VT+eHiVVoQqY5BycIrFICR2x1DpOEU5TIqYUcdgfJGXmsMc8FYaQ8/nQgHl1mTKWsC5qRIag6ouRiQarjzNBtR3sQE4IZNSoJqeVmAlGzGWBk8ZrWLyZMCgGeaJt6npl3CQ6VKw2TtxPHEnVdKtMDyeI3wKNk2ZZSVojxnmHlKQIW0jIgXYxSVBl1w/ohwGPqq0R31Rx/7IaHYebg2S60f7JWZBhsT5akoneK7wx5zkimdJDzic5yhW4u64DJ2C8qHVA27VUkJwSOt+r1VUZm6T+6pbpjsV1IqWQBQ5SXMSqHUsQU/6LV6+w3+1B5NAPPX796+/w8e4T3n/4GfM8ys55J+4Zwx5B8UxkcScU9wQNNmfxsU+cEaVJVwUR14Jrhi97royCqWCYG7jj/A1XVuMKLrliqOvbyrCXvwkuMxrQFPoE53u8ePkaISQ8fD5hPM3ww0GEWg4Yzxc8fH4PHCVLYucJQ+/h+x3c4IXJUotzYoHXEEbEywPSfEYKE8b7z5geHpBikHXse6RhB7q5RT8MQtfU2oUYRMhQfMBhUjjkzHSVSRFkV00bn1Vs+i/n36VOkp71KiBeMj2rIKdnjU1I1UxnCRaHJZSP2RRaUW+r5ktxiWVFc47BIYiyEQnzdEGcL6AYcDmf8Pj5DvPlLEN0DvPNDfhyh9MwYHrxEvztt+j3R/h+p0lRJH4lpagWIIdZQgvB7AF4gHqlg4s4KTiQG9ARa4YAA8ykNANZ0LX0MIBkEIyBQUFjtzJzLji1TrOW3YWIAcyoYyvMjYWBrCgAq6LQeTjfw/f7zPhLAUaSdPTGXyjeTqpRdprd04RCkGrwVdCIMUhcSeY3RCjJ9VZsfMnOnFXeRoYkp/sJcD57hIiYxLUGKlxmITfJeRB32KS8l46pcjeFuvSYQlXSequSRL1XzF03Wzh1yxw5EcwGW35ZXy9kUtffeC09CUTwcFKbK8ke5dcIKlhwxh2kyT4sftZSBZGdE2H4dM8TioVU5bAcI6PKg1kiWZMKyba2IMFJnlypYUHiYuWouN+CxEU2csxryiyxXmBGiBGXywXT5aJnnKS2iVqEUowq1DNcJ4UJve8Fl6my2PcOQ7/Dbj/AkWSk9N4j9Yw5Tpi9WBa97+CnLmfWTKnHc65nCxpjGhGR8PHTBwQGiHoVMmYQecxxwu7Qg3rZNOoYXc8I8SLl2T0hzFHTiimjQ5DMAfMMQkI47BX7JRECVE2S1M8tOcBR2VA9QopsF4yR0jIRKJIILo7w6f4zPt3dSeaCTs1LJaFM00AtfNjPJtixoqStIk6Rgv7tlBgb4pHCRaoJUh/4BIjPbjUSVsbUOckMk2IEJalmzSlh1w8AJCiv6wdxYVPk8ss3r3AOM37+40/YvbjHfrfXPOeEzncA9pjDjIf7B+yHASkl3Bxv0HUDPj8+4OZwg5vdSwk2DlGDqAidYwzoMM4XEDnEFEV7PiecpxnnT/eYUsJud8DlPErWFRAYPRgJcQaoF43w7jDgMkcEdnC9pEJMQVB94ATQAeR6MEfdd7FKBEgRMk4M6hKYOqlQ6kiySIWEX7z9BXoiOEgWkxQDpk7cTAYPDL6H63sgdbj7ocNjErckya7F4JjgHTDPAcPQ4/bFS/j+iN3uiP/oX/6PQSlg3wMvjh3+/nd/g3/9+IApzHCdxxwm0DBgDnpYQ8J4kUBfJmB/OOLzwz3CHPH4cA8HiZt4vEghv//iv/hPcbg5YLycACcELcYgBdFAYAr4h7//HbquwzxJ+lqp8p5wczwgssS8xGRaZgMol7Uc2QpYBdGtXVm4+g9ZmC0ZO+x+OTNWTVlc0MW8m1LM7gOmEQphkjNGGlxJknZTsiwxOqeOfiQ1YUTQoAonaI0WBw1SV1ccwBJZIhdYpATvgTlFMCKcY3Qd4fHxMx5PDyKseKAbxFfd9zIeI7J9N8iZ7jrN6tFVWqWEOUa4zqNXtyqvhDWx+ErPYZYYopgkONsRQoiY5yDn0XVibUMnAp9iH7AysKr/ihxVmPF57cV1MWRzuRT9S9klIMQgFuPjHqeHR3z//ff47W9+C2bGTz//jJ9++iOmGKR/73VPZEOnMBlNRUqMaQpajAzCuFouemUyTbAxsl1gaSFAcFG6FODjzFTV+LX9jhfwaZnPzGUkv9hm9IHDrKmoGYygOPjV2zcSdOkS7k/v8PrNt/j2+9/g9uVrRGbcn97jsBuwG3oQIpyXDE7d0IG9Q3Qi6DMlePZI84TLwyc8fvoJ4XQPxAkHT3i794iTZJnimRFHxodPhOFwQCKPYX8oFumUEIMGhnPQGEBkZqsWtohtnW219F8ywUzXJFGzPM1FKef4z+rR6pkRNu0RrEoxapa7pomCIzxJzaQ4nXF5vMfp4RMuj3eIlxOQgmSrBNTF02H8fMZ4/x5+t8P8+Bq9T3jzzXfwg9dUwKKJHtX3fQ5kGhEpkgoHpxkEl9Q8qs98mZeOtEnzai5+FpzumtfNKmSiAACJcYPCP5mFVhQZUnCzBAazCeFOdimpUky5JYl7hSTwcBABMETOZ0DkGNmnnNbWFa04VyMWcGBl4kkVmZIfiNhcImrBnrVtqmasOIiAovWNag2sxRFhqOFIttRLZsaGXyIq8aYWo5fhR+M7ILGIDKgHCGXFGCpY5qxUhfhK67oQA44lCYsJ1WyLY35IsvKKvwrPZuUTTNCSlLtlHQsu0xpXgCqWpN3OOxFwksRChCgeP5YSep5nMAgpBqSQgKjro25sfd9jSMUFj6hD1/fY7ST1LjnGbncEkdQ56rx6qKjCaRonPDzc4+HhEfM85fS3MQRcLhMuqrwUb2l1JZ5mpMB49BcR5DuPGH4uMUNJ4qNyjTZWIdBJIVip88UZP3zper5FI4wg7/FP//Rv8OrhAa9ff4Ou2yPMMw63tzifPmPXebx8fYM4diAOCDxK1hwSracEtqp/nG5e1xE675SAzdnv0WlAtcCmIHJk+CwEJzPv4IYfMlOvpJkV83DvesmywhFziui6TitgQl2WTNtgUq7m6mfOY7Zxw14n1eoosi4WDnEDiTGqiRNS0RiqK2XGnGL2YmUF/JSQLRsJYtb1rgd7VsaDS/9WUhKEMQbx0VTp+h//6R/AjrDfedD8gBQv4pJCHhOA092McRIT2KOyCh9/NtcLwv27GXBdNgH2xyPcsMM8Aicw5ssFcD123Q5vbt6AEmNODuwA7zrshwPupnvAi4XBq5l0nKRIHYFwPBxwOt+J2ZB6EHowJWGO+qMw153UsiDW/PI8qzZdApEGS58LQdicEvaHHf6z/9f/EwgTepbc65wCYpxFkPASUM+64N4Teu/LYSAHP3RgECZOePvqNf7yz/8cjAE//fwe333zHf7j/8f/DYee8PHDH3HoCbeHW3w4nzFaQJpL2B2P+Gf/7K9wPl3w+3/6PeazBHL+T/8X/3Pc3X/Gv/nbv8M0CoKLcRaJVwMZL1OUasudRwoR0+WCWbU2Xe/x+PgeliXDeYkNiAAeT5+R2CGxkyBj8kpH1GKQ3fBK9hHQUsCAMOlspltzjVBGhLIySICVUyYMLhNs8YVOIKTAyvwFgX5K8H0HKwBnpvxhGCRTTow47DTVNZsWIGSFOXUEx8Ksc5TUhYmDKuqEqDuNI0gpoet6JA7oOvEXJpoBjGCWgoV9z3j16hZIkq2HSZIKdN2gmXPEd7qnXiyLHXL2jsQiPIhvrcM8ipDZdQ4OjClMuJwumKZZiZa4ZiQxxWZGUbTOyMW5HHVwroNDRArqO211MFKCd0405ImlIKMKtXGOOBwOuH0hGvPT+REpBfzyV9/BgRBiwj/9/gdx/2LG4+kM5z2GYVChTuqNpCSpUC+TZGmJobiuAho0aMk0EFWTaDEixeRvlsgWvkgT4yj7Wll7C/xRFfwYV89NAPbqcrC8aoWQ906zIlbCCnU4Ho+SAtwN+MX33+P21S/gDgc8zDNOlwsiObx6+w1u9j2m6YQ4i0tb53vAeQy9CHIpBYmZur/D9PgZdP6M8Pk9fvzb/w4Yz8B8huZuzfiF9jc4vnmLF29/iZuXb9HtdsLEJ2NqgxSuM6aOy9jrzDv1lf35M1UBJIsTsqa3nFvbiSIc2Oe2zMZe5nUDi1YYwrDlLoTrhTGN3vegIMHt93fv8Xj3AXE8geIIShehuzGg6wYR+ixJZkyIjxc8xBm7wcM54DYF9PsbwHXoPZB6QpxYM0IxOHIOunYeGKdplaSMkRA5KFzYgMs6ZJewwkJUMFRrx609Y0PNukP2ACK2FY+EEmdE9kpe9Sy8ceEuxBHVxmW/FI06wJnPruUCqsYpcKBnURU2HDVihkmPk1NmW93RUfgt2XybO5X+2OesgsWLQsbELAI8OAkNqBWyLFXnTcBILC6opPWCTDnad4J7xC1HVtU8FYzZt9Stlto19w8VOB1rsg0LvJazEENASBFxDpoyOWnAdtCYjGSbDvguZ2ISvOvgfY/eexyONzgcDjjsJSOX9x6Hwx4vXt5i1+8RU8L5fMbj6YTz6YTz+YJpnjBeJtzf3+F8HpssYrZn0xSkHITO2WIB37//CKaEYdjB6tR55fty3RGqlNgNjnTY7Q/YHw9ZwMsiJFHeCxNinRdBLmo7Ka8tshdEVCVlPhu1YuKJ69mCRogzOkgo6N37dwjjjG+//RU8OYyP90hpxt/98AMOQ4/OMVKcENMMN7j8vVc/sxwgmFLWqEqAnGaZsgmqKJUASUGGwvBzKtK+bFb5nUCiTCCGz2IrMM1BTFKdFGULc9C80NK+tSNCetGYlIN4TXozBOtzGjxCySLgvUcIVuUiSWCbpfGDAEngJAHXmncZEA1sSFGD3sX9o87/PEdJc7bfH3FzPOLxJEHIh4NkRpjiBBpHhBgxxUorAGSG0emYCQSnwg7BY9g5wAG7w07Gm04IpwfNTJLg+gE8XzBPJ9ydz5jHiN2L13j54iXOc0K4nMHjBHe4Fb0jk1Qov1zQ3+xNQQKKJG5dGjw49IO4bt3cIjzei+sVOXAQn2fMjP4g5roYAwJSrj4eYsR0mfHq9gAgofOEnjWNqmNA1y9YJL2T3OeWsjWFhM4JEo3jCPId9rsBv/ub/w/+2//mv8Xu8AK/+v63+Ie//de4+/Qen8YL3r66AYcLPp/uBdnBAcMeCAHfff9rJDjcvnyJP/uLDn/7u98BzOiGHn/xV3+Ff/r973F5vBfp0jkRMnpNo6oCQUyMrt/h5f6AXiuKOvGdw/k8GgZAZMawGxCZ0Q87zFFMq33n0XU7WPBbZEYMjHm+aKCYWAuH3U4g2RB5JazLUhVNFoEV+ctZYTFbwBhNpgQOjBCiuj0WIUHgRxCqwXu/O+DVy9eSTQwM3+0RwiyuQKR+xyCo1A9ANP0dyd5NkwSG5wJJQw+wpCne7w/Ya3Xxh8ezWFJ4h75LmKcHPDw84P7zZ9zud+j8AOoczudHnE4nANDiTDu8ef0GBMI8RcleNs5gniQVYNchzgl3dx8RLhM8dSpYVzZRIpjW1AQHX2WbEaFOfu+cCLkppZwhhcGqrVUBMDECB81qJ5aM0/kR8zjjeHPA97/+Hr/5zW9w9/kO9w8PuLu7kwDuUTLqXMYRcwz4zfe/BnmHm9tXIO/w7t07SZ05Tbi/vwczY7c7gDSxgEwAylQBHYllWMz0s2i7Kjc8+8D+chVhWsVtKGNGlClic9W4z6zG4vrj2herbxnQ4nDqa09S/Aq+R5hm3H++x/HlW3zz/a+BbocZAdPMwrCmhNN4we2hx36/x+wI8xwENvwM6nrc3NwgTjPG0x3uf/pHfH73Iy5373D5+UfZ7jACPEJsKerixAS+nPH4/oQ4nzBd7nHz6i387gDyHch3iPOkZyrB0pUuaR0zw5KONwH0ZCywcna5toz84GqZxN2xWizWIH7dZmRFQzX+3IIKQZWgAQBhHhEvI0K4YDrdgy8PwDyCPON4c8Q3336D4+EFiDw+fvos6VqnEafLCWGeMV8e8enDz7AMkUeGJM8ApHJ6ioAVEp0DxstF8vtremi3ZH6yUMuqtbeIGrUqmEviEujMbWgFW8u1tP1RbsU4M6gSoVKsLoXpXI+k8ZTQn5pRKr+7wdStgv/zfSCY+yBRdUZKXwYVZGtTNxD1aZElqr+tOGD1RS2U6VjN+lLqMkAz6c0Fl5EpJRJG8pL63YLak9IV0+gCgNYK6nupUXHY7/GLX/wCRIS+2+Hm9oDD8Qb7/SHXsCAinE4nfP78Gff392JhYHHfvlzOuL9/xOPDfY51qtc2pYAZTtMYe1wuY44/qQUdyQnixNqtsSn1/gCS6fOm65v9FBpc+NZ8ZCvlC2lMThboqrTLNVxQte7ZnU7566AZAeW5JQcSIk/alnNFuWPeNGwqBWZNDV1v+fOEDOArBA1E4DJeMAx7eBDOnz/j5yni+9/8Fvfne/z08R0Ohx1cJ1XEGZKacw5BAp81u0QKErDjSAvi2FFlDXAC5aAs2PLbYeJymyuEKZIrKsyo2gQA7IAQpBJ2CgmzaokMXzA5dFqQQxgD2emkyLo+guVQUOkHDNEOkAQrMYnfpUrEUrlaDJchir9qUkNmskl5ArFYWuIc4aJHN0hK2lxrgCC5qUPMwsx+kMP08CCZaWzjT6eYhR7vnJj1Lc1rSoATLbgkMFIBUAs2deTRUdJMNh4Pn95Lzn3HUvQpSZYMxz3CxGDyuIRHgHrMlw6nu3dAfwPf7eAGhyleJAuFl2xFzkv6uhQjxsSYzid0kn8F8D0cdQinM3BzRJyDmvsk8M9HxjwFDHtlcoYBp2mEp04zNBD6Q4cYGZgmcdeLATxfgDTDOXGhi8nymWs6UgI6kuB95whzGDH0nRC0GLHvHEJIGO9/xj/cvwdZVd8wIwSPMInlzve9GIC6DnPv8eMffkAM4pu93+3x7be/wOVywX/5X/7nCJywH3Z4/c1bpBhU4zKLi0c3YOiPsIxQYJa0vqcRnfPY7Ry6bofd7S12uz2G3R5dP6DzPUJiBJ1bSmJBCsESGSvyMI2FCgfcINgF0WONVSAuFaBjXKW8ZZIMOZyi1AzogDgHCfyfJyCqu0Scsbs5YH9zyBYN7x0u8yP6nRS8YmLsdr1khzLWxhgr5+CdaPv7vof3km/9fLlU6V/FnxQsLhOfP3/S3yOOQ4/vv32DYX+A6zq8eXnE3c0O02XGvhfXi30/KC8tGrSh65ES8HB/wqdPd5jnKIkGOkkYEHPqamDfH4VxUUGsBCFWxNIsOYZGAED9q82yKWoVSQma02H6ToihVnQXVynJjMSO8C/+xX+Et998gxBmTPOI3/3t7ySmIjF+fv8Jx+MRr9/8An0/gCHa308fPuLzwz0e7n+H3fGI/f6Q8dywfyFr3on1CVpFXJ23s3bRiKD3hRi2Kpla9eqyAqm9WgIvaHVJyEq9oqzdRat5NjxNWtWZgOz6llhcSwU+JkzTBLDD4eYWnz6+gxv28MMB3e6A16+kjgDFgOlywsP9nYzAe6CTmJld3+Px8x3idMb7H/4Rn376PU7vfkS4+xmgKLEKFND1DohBMwPKWCMxpvSIy8cRkWfM4YzDi9fYHW8BdaUDa9G07EfP0KAEjV+yVVtYjFhgV1JhE4x/WV7CVJhWtf0eQFOMy1bYSfCUfl/Fx2hslCiVGUDE6fEB08MDODL6wxHDfoBzhI8PE37+8Ec5HV2HvpNivgfncBkvAIDLwyNuXr5BUj/ziBnjHPDw+IhpGkEhoO89wngBQVwUwzyqe1zrSscckViyhwEOsjBaJYvNgQnCdFGd5ccEknrRRIEp3EEqFoRKsMvCcu7fftbPVLipFaRU4wfOdXSkWy4NVftlSlDDx7zVHnOOPZT7rtGC69RlbUStW5jXav7C+rQK3maSSldfvXolwcZVnY6bm5tcmwOQYsLTNGEcJ1wuo9ZFIpxOD/j48Q6Pjw9V/Q0pqCoeCZJND5CshvMsCiRR6Ar9NYVOrehdrQuLO2jiCAfCi9uXGU8b71Yz8FbjxJFH4tjMX/BlEermnOq+Ck03pZ35O+YzZK5xhRgw1GoA5FoqomMzt0Abl+nCi2WkXMrHJs0G2XVrodFMHIovUsVfwztJbGGwkUzhvuroWdezBQ3XdaAkaWwltAagGOEo4eOH97B4jajaBgeWrBqAmoPFjciDQL4sVKdBj/BeC5FEEGlucNWucGQkxzlzlK1G9i/PgnYx2ZupKIQEjglzmi1zV2a6iIA0az0I/V42z5XjxeYiYAIR0CIfytaVpGMyV6nECSGKy5QQvqgp4yISWbipIgtNnydDZ4zjKD7TTqrzShHDYiUR1xBxy+q6TvPqK+IPAdD8ztM0SRn6JIFUfdfljAUgQjd4SPYYCRRzgGRXkYAPdB6I4YIQxQXJEdAxwOMFHaRkugC6RxjPePj0AcMNY54D0jRiQpQUhDwDISLNAcPxBjMYjhMQJyA6+K6XvOYkghCnhGHo4CnBpyQpJIcOYSSpdpoikBJu9wPGMItgpPsTUwD1HV7sdvBpAgcCuNdsZWKqHacJYDWxqlYucUKYYkbC2e1N3X32A/Dm7Rs8nkfcffoM3zk8nh9BYPjdkONR3G5AnEb4vsOwO2LX9eLmEiNevHwDdpIHv/fiHmBZ2sgT5hQknid6NaU6LY6j+cFZtJyJowaKOUyBMQZh6mMq2hVBICJwRxbNVSKGej9kZk2jjlEnPMjMvXARGkvEIDEVwhV6LMIIJUnqMIg7ETmHXb/DsTti1/caJE2YxjOcN8IoMTW+68EpYZom7PcHJE54uP8MMGMYpBJs14v/Kmfk5xDmGeM4oet67Hc7JdqEm5udnhVJxABlVm5ubxDmgHc/v4PTtJhBfb5fv3gtbnhpxuPjCff39zidHhFCRNdJYPQ0RnBy6J1o7c0FwTtN0BBTXm9HPvvDSvE0IWhWVdjQiAl/EhAJwXUasOu8pi5V+mLnnwm5wJel1XRaEfzdu3e5wFLfSwrJb7/9JX75q98AcHj37j0+fHiH8+WSiepuOCLddNgfDupj7jRgXd3WqAfUnpzdInQ8IbFUcjbLV85CVAsbrcbNWxafhhmrg7fL+rTXWqDg2DKV9bM65ihG8S/3TorJhpTA6r5zfrhHTAHd/gCcz4DvsdsfEHd7OE443X8Sxp0k/SMlCbxnjrg8fMb0eIcPf/gnnN79iHj6BIIIF2GaEZP4Z++GAcxRXK0sNZgS/DidMJ3FFc4B6HdHqVPBUYJXNTOVJUcQnGvrtTF3WUQFGlozBlS7pXElCFt7hd5FsNJNC4Y1PKLrD2O8VRHIjBBnTKczpod7oQ2+QyKPxOKO6LzHzXHAzc0tTueTVqOewDGh7wec7j4DgxQ8PJ9OSOhAfsAUIu4+fcJ0ueCXb1/jn//lX+LNm9c4nU744Ycf8OOPPypz2gaDZ6VKo1CJyuBVDDsREpIUoTSekNp2lrC1djkl1EX5rl+82hYTjMvfFpiOZpvrPo3X2BpfPaat8VpdB8D4HmFtn9JUWwHjZR9WTT6EgLu7u4ZZt6Dmvu/z+oiVQ+McKouP1ZcYhh2GYdeMuxbUiJC/FaVNGU89T2azBOv91L4rldtlDmkhdGd8y6wZH1lTUutZqM6JrGVSnCx0OYEtVry0k1RoSEVx1uJBa6+y3mZh9jpMZTfoph21rGj62/IuwMWPSn4myZq45bljvHXd19dezxY0pqT6oyQ52a3S6N2Hj1J90LFmPWFAmbQIyIKzaEM7eNUulMBNELT6IyTHNSgHgBNrReKUJJMPV8VgCFlrlS8ukn9GlCmiI4c4a7alHCMiFpROOaYSF6baCdOc5UNV+tLjDLKw0+z+JfNh1Sp77wGvmWZgRVySmqQA+FIunjT1oQXjxFmQYuSEeZ4yYQerK4lzSIFzkG3nJP6D1RTniDBNFykWp36TWVvKACDMIDRLRNbKAkjzDJDP8SwgHSeL64qDaBich1hIQGAOSPMkvuW3UUz/HIBgx9Npnu+ElCT4P6YZSDOYJSUrU5RYIMeYwkUzGUVElmJZnAJSmpB4xunhAeAJzgN+v8fQFf/13jmcpgsepzN8msFxguSQZtG6Q7IySA5lh90gdTxmzZIFJ9VBfVJOTUMAAQAASURBVOdVpyVZR7wjgAJO50+QDCgety9uJR88BEZCYByPR7hBmD+x0CnC7SSYLIIB10ta3QBl8JMWfus0cFVM+aadFU2bCIiSxcthVrgqZ0LyYfvOadaRmJlGywRiQpUFSsOEDRaBwg4SZRLHMI1oYqnC7kwQt6NHAHOfM5rBA5364ArMJknTCQJ1EsdjxYL6QbI+XU5nDPtBmNcpYLeXmhWd75Q51CwrxtSQEClOnLOU9F2HqC6CXddhN+zQ+Q5hntE5h91uh/vxAWmU7HmRVaOYGGn8mAW0eZokwJ41JXEAIjGIvahYdP7GSovrmLhDOchYElPObOK8FMNEkpo3gtArggbdG8UzokARt4MwTvBOEh+czo94+eolfvmrX+NwEHewcRzx+PiIxMAw7NH1YpoXF8wB5/MZ/+pf/TfY7w/wzmOaZkxhlvPrHIikENf+cFSCLWeCzMVUBULn+6x5WxJ1096ZYAUWW442aEBmGDILX/W1ZHTldVo8cxXQ5Q+xvBjqbQQteqbp2OWMCiPVa5xMR0AYz+g9gxzD9wl953DTE7yLmKcRcdRgShIFgEsRvXN4+PiI6fQJ73/4B0wPH4D5BOI5c6i3L1/Bdx7n8YI5BAy7I4au11oJMVfwTuMEdhNSNwLDhG7YQ+SnpLEwolSpaZtlc8uXCa3NklBRwhmkEVru2V4wLadAXtmCvHsCzKz7EZHlTd1WdfFKEXEaEcYLOM4gSMG83X6PYb+D78S9c07ATx/uEGYJkicnVu/dQVKaP97fYxwvOD+eAOqwP3ochx3i8YiP5wve//EPcCmg6wekxLhcLpgnrWBc1R6QkVOOh6rnbtr6QvrtPBtjmqddLY/CdnWzboUgSTDs7HNWgqJa05zHSPoxCQ6oArztDcr4t5yMyv2Jy99Wt6u2QuR2SV1mqMybq7blnFbfUmnbxs2OFBelpm1A3D1978R6iJYZ5cjiKh4FfnPWvIq/EpwgST3MPTjvi1kCquFQsxpFmCwWz7XQIdPU9U3muJ4fiBDEVkRP14ko0xpHlAPJAWQhoRZmJH5CTo1X5VE0+HadWDBg7lLCg5LuPzOX/aF6bMhw6PIf5bJK33m+9g2EoqcQ0ZkvdNVmdu1l0lBcV/rTlTUQMJhcKnCeez1b0JAUhtXCqvsOOEktDCjTqVjeGGBhcmTIzupFpAIkOUsK2+bKTM2ttDEdM3LQYVIprAEiWxouCJlVi5vtQqksXuBQMrUYALEBoGreAIBcZqrrCuAgETaEAVW/ay2I5ogwDIO4GgXJjz84gmcpDjPHAHTIDFXQzC85/aetL4lrSd8rgUoa5GVBuKwFBW3OFrsSk2j2wSJMcCwKa01TSiQHzuYteECDaakE2tNC62D+fazpSktqVMmK5ThJ2lmnLiIWZadIJKYxB+sCAY4iHAXJ2oAE5wKACY4kzzipGwxjBiig84w43gM8gzuCcxFEO9V4JwyegDBi5qg++SJkiNVNq7p2XjFUwpwIydz1NGUoewmuzmEBXrXjFPHi5S1EuPI43L6C871mNmF0DHT9DkPXZdM3KTwJIyaoIiZk31VSzMApqcMMQCSWPWPaBBkT4JRZAKkGRl0kDO5J4JRcVOFKYIgcA840eBpoRwQizhVamUmD/UiFAyNSOr6a7QjFfOzIoetE+JGzaS5OCi9R2iMwOtdJULFaeDBL9eQQotbPEGLmtCiUd74ill4RJKvlELkOQ0yaNIEjpmnC5TzhgU+CxBOj9z28P+FynhAmIERxoZPPHS6nUY+GEVpJ/WeKYbD49ztjMkAlE5oeK69WJI0KyoK94HhxVWRVYlTsNMxVSfCqpKBmMLrO4+b2Bb795lvc3Bzx6f1H8RHuBhxvXuBwOCAx43w54+H+hDlE3N3fgYiw2+3RDwGn8wnn84QQWXFaB0thawKFCHAiqBthNZgzQcRoVMa3hAzbWYBQGljIfyVkUGVtZlbl01KQaGnh8tnW3zUbXV7SAFh9mhRGYYQVgt/mGKRKMYA4nkGfP4GcFPC72+/R7fbiQqmuaYkI8J3EW7AkxJjP9xgfPoLHB3C8gJDgOqEprutB/YDeDVK0z3tRKBHAcUbCGePlIjz6HEExSdFRBnLO/JQk9W0laAgUGeNlMxK8rbeqdSkFZMuzGvrKumam1RhZY2wq5kWSSUDpqDJGyXB/AuKMNE1SsTvJnHOBN+q0WJykT/bdDs6RFOKD1GShGHJGujCX1JxhHIWfSBG9d7icZ3x6/1GUMbV1TBDbAh6Qz+UaXpQpJRZIMfjKh9PeQYad6jYyds/SBFUucij7ZI9Zn3F5p2YdTSkl+7FgmqvWslJQFX3lPcqMob6ovBPbbPP3y5UQFovz+JZCPGnbtSjTWEioWFe2tN45tS/UjdfwgCkUUmXRYV5AaLuM8o5Z1KrYruW7CxxD1f2MnQxnKU9UXDNJvGp0h4gInox6opmr1d0yISO3brhfOHV1/1fCRdU6Zam9zEeHpnjZxpxXvlrYamW4et/GbWtrCSGo6oONH5BznnlomFK64HsTEMsWPV/YeLagISZ7yoTbcog776Sic0JJa8YsJiMQwE6lR0LkpJomVpTPcJ1DTiwTTdtqzk1FKMh+qPUGwCQ4zkysrFdSIUfcspIiaOel+ugwSDG3MEtRGMtVbOYx2SDN/wxgniQtKpzXImWUN95Ml8yaLUCDlLquw9D3mMYJUwpA59GTR0cSa4FZgmaHXkzJYlWIkp4sFiFJGC6n+fvVtEtSJ8DMb548OETxHYTx9MoEesrCiyHbElwE4XiNeczymGWOSZq/X9dYiR8n8ceOav7MsSbqq89xVJ5XyLyz/dDTnEKC63tp30sWIGIGcQCiQ0cJHQOeJc0pOck6xW5G5xM6n4B4BijCJUIYAwiztJkSYvLoBsC5Hp5dPlhivZH4Ahp6gVEG5igB9945RCSASdfNNLUdnJNqp/AOr3/xBuJr7rT6NgGRQVGyaTAneDuyVTYLhsZ9W/Cs+s0SWRpClnVworH0Wo9BPnd6/uQbib9h3bMiRDovKXqdA5zTiuJJCZhDwzTCmNoI+N0OBMBDan5Aaz7YYZNMaUmJOoDOZbhijmCWWi0pye8pajVYckDXyR5oZqaQ5KdjLcoUAUKndnmHjjxCjEhBcuaLnoBBFCTQDpw16AQ1MzsnQe6RMY0Jp9MZ0zhphiavGZwAB681RHxZe0e5GrmYs31hLJjzebA9lD4rzY5qC40+OzIzuRwqy3ziNdOLKVtSkrzovvO4ub1F3/UgcmJ1mEc47/D69Vv85rd/hm+++QafvvmIv//7f8T5MiJ++ITb24DD8Qj4AXATHh5P+PjhDgxgt9uhGwbEEHG8fQGCuKuZS50MTRkjLQbp1Coqp1TwhpnTjfnMhM8QcxYuVNPOFUOvRDqns6xwN4yeZOyTl7jgo5rpsTbql9lGurgyzS54zVXWEUbSOFMJ7AcI40VcT0NIOu8O/WGP12/e4HA4yHi9h1MF2nwZwXHCfPqMFC5I4QJOM7wHdrsBznUAdUhwGA5H7LwIbJwkDbVYOGe1xkEK9aUk8Q0p5ro4UiXchHpb92INYgbIO1XuqcUyIbvk1nUbinaXM8OYuZRKaWfjc96X7wCt+dBlqwhnxsz4qKQBzBFJs+hRr5bYGBAnggdhf7jBcLiBv/UgSricT0hhAiGBowddTgD5HJ8RphkpPYLprDFvhP3uADjTGrvMADFzVn6XqwGcFj6MeTMThPI35d3CCG7wsSC4/FlOD2vrYZ9nNFpYdMqavrqb+jTU/RUm2UZ2TbtsPJKylPl+yme26bZ6d8k4Etq/SOZXtAWFGc4/5R8rjtlcXM2fhJ4YXIkyxvZC+67Glcdga2arwUUw4MWmt2M35pvyqjQCXGLF35RdOvO+cbXmaIOvOa8BaRY/5RmoeM2ApE4GAIQ0C040K4aOq97LpRtVFivYejQ4YBiPJlOjLCxA+WHDswSj+1QEECr7xba2BSgyH297xjBBA0AFc88VNp4taHiG+GXqgL33IE84Xc6CxBOQZmXUSVgWGEJil4NwmSV2QzKniITEkfMBAQBQLMSIAThhypo5lfD4XKwKykxpAAT63lI2ij+37zq8ev0Gb9++lSwi04TL+SyZXZxDmKMw9s5lpDHPMz59+oTx8RFD32eNTtZWOyktH2LErJmspphANEFVzUiIwGx+zMp4EBDHgM/zfQYCB5JPMtOTEMaA6D3CHDVHvzBBKSYENRULcTGmVQ8nq/45qHUo2UF2xmVYpA1AlLXrrAxGSEnWgsQNB+DsZiLfeDAxht1B4wI6wHVgcojpgo68CvgdHFJ2LxRzbYCnhN4R/J4QeQLFOadGJU7oYy/xO0mr7RKBfAT3CUgndH2CI8lu5pIDzxEhipUkgvDi7UsMXS8FaLyZYUUYEvcjRSgMPDzc43w6VQFzlLO5eC8ZLrq+k3zZYKmFoNrsmsD4DiCSeIpeMwrFqDUkFFaIJUuQTDXKcxYi3msF9xjnLHB4y2NtjvoQ61SiEkDG5rMHQCrLqnsiovgsp4TOd+ipwxQsMxAQwozxIsR77DuxIHiH4/FG4glI0AMzS/azFOF6wn6/x37YA2CM44RxHAEweu8RNKsLcwIHIDkSqyYDRD0oMXpIWkA3yB5IZeSAMEuszRwCzucRYQ5Zq5c0iFcnqXMws7YI+JyQY5cIA/a7XSH6SUzIru+lHg1B610I0vSag19OiLpEqiRaGAYRtrx38L0W/YxS0E5ieoLsbWagS8A9HEnKXN8D0DoaU1JtucN3v/we33z7DV6+eInT6YQPnz7h8/1nMDMeTmeMP/4R5An94YjHacaPP7/D+e//AYfbW/i+x9AJA7h/+RJm8mdmwANMpZI5Z1DRdQWyW0lcuDMBQAzJTo7g/Eq4QFYmFJaGnGVbKcxfLRsYgWM7aWT/lH5WVyXYLFrc/sJoScUkBEt8YHNHhB+8BronEHfouwEhJszzDN97aSLMiHMPK3LGiZHCrGtzwXx5QJjPiHECSOoZ5eQMww2iI/S7GwnGhGRkOp0eEGNCSAw/DEiXESlI5fEQA7owC0PPUe5Nc8OkAqUWVYqMvttJgpEYMh1NrFkQrWCXJhQwC7YjAvQ5M4NDgGXe4CipxNl7ScSiWfFI46mc93BdD8mp7+B6rz7qWmODREsdIWfFEpmQxm/2Q48wjQgMPJ4eME0XOCTs9wNub44I4Qaf330AAIyXi5zrTlxSEkuWQnEvE3xuAcowUFq4shNBLLr5b8OpyqxVweNEJATH4AhKDarMZoW5IpRihYxa4VAURFQxpBD8rsk6UFrJ/9ZskIxpmd+pdRevhY2lO2K9DM0TBqzQ5RajWGxglN+vmf7C6JYxlNdrt6Uqfio3ZSvvVGlUxkdK6yQmoQh4uZ+MW0qbmUGv7psAXDPnsHS1xmNU75Or7tfBhwpbLYZjdX8qi8FJvV3Y/BVaCYVNsUDiOltiiNZxM2blqZZMVqf2NqgugTcRyoltL6T/ZN4qpELiKrmGLbEIGZuwoPDrbF9NWNmSup+4ni9ouA5pmpBYXHmc7+A6rwEvYtGgKCah3X4P3/eI6gucEKRgkR5MKwHPDMyzZKKKZGaZ2gxZjlgr8cnCpJiUJSSAOjXRFmA8HA7467/+a+x2O4QQJGe6Av84jpjnGQmAJy/5vL1DhKSFM202dR1evnmLt9/+EvM84+HxEafLGblCpOaV7oYeO3WXkeAh0ZI7YnBymKdLzt8szHoChyCMT0o4DLsMZAQptuKGDoebl+qClTCHGXGOCFPAHGeJYXEOUbMzNFo7O3R61q0yeFQzvB8G7Hd73Nzc4Hw55znbfxGxYuQ8PPUAoQTxeo/9bsDrV28A55WJcer3LsGqPRwOh4NkKvM+AypniT5JOsN5lrkFydmfOKJ3B+w0SLjzXmoixBm9T+gx47e//iXAkrbSLEhgE0hJ/dcvgK6lZffwHWHY7TLjSsy4OR7x8vYWw9Bht9tJUHdM4vc7BxUGOB9i1+laVlJ9XisAgYTAWuaNrrNCbOJLLOmLRataV/t03omPfxJNf0pB43ok0I4TxIqIAUyCYKBELGl6UcnalNDBg9yAftdnk/Rut8PxcKtnYy95y1msIn0vv1sqUA5RXJz0fM0p4vPjPS7nCy4Pd2D+BCJxDzwcDui6LmcSmaZJrYNypZQwzxLk573HoT9kAQtQ5UAm+DL/ruvR6ToL/oG4xBnKVzRgSJkDMrGVCrku920ZQ6BCDyVTckAFESdJLtQFULTcGvvii6k5amVP8g6uE6HfdZbSOmggamHoxJAnlWHffvsN3r5+g9/89s/w4uVLgAiXccTj50c8nB5xPB41I1LKLjbjHHB39wk//fxe0ljfHNF1vazhixfoDzcAqY+uZDpAIeUkRNKbS5teS+Y/314TjpXbkuXiMiGj0aa6xbfyxdalijTVd9ho+er7jYY5j15xXUoVE1DGHUPIrdnUGt6FCJ0pGyBFsl68eInOd5jDhBAmfP78GdM0wfsefjfAcXG+iSGA5xlpGpHmGRw1OYP3mM2dhRnO73C4eQnnHC6XC06Pd7j7+FHmO49wQwfXe3GbZan1A2LMccY0BXz6+BHz6QQr8gpAkn0Qwe92iHMENCGIBdzu93scjkf0fS+Zf4YhCxpOY5UOB8ku9vBZlCzmY55SwukkyRBClLgqw29i4WfMYcI4SzIBViVU1zn0vUfngDSfEaYLgISXL2/gugE3t69wfPEKkRmPpxEOHfqhw/H4FpfTI7rO43DYYbqc1cOAJK5j6NF1FrcEkCorzTOiuJNV0MFreFgycwU2FgLIktlSYF8HmCufkrgw0U3mp7XQXrdv9SiKsN6eQVnzmmG217OInt+rf9ZXrpEANIVZy3jav0swsQpPzbq1Lxs9q+e2clMit1qH7PKFEgW4xbIuUxRnN7NFH+1LKCiEs/jX9LG0KjW8kmWEaq72hlXcbjrlMqYEoVWWtriBO8WdxS7Runzl8WivDjkaCGk9sNIuW7pbZGGDVUiVlrwmYKJNPG/XVgKDvK8G5lkxVJ4/53q2oPG/+d/+70SjmOq0hu1/x+MNUoo4XS6S1QeSnjEEKbw2juKbbwxBHbwj7xZpkogUcQ55A2LFDDsi7Poec1CBQYOvvfeIMapQoS4mfYd+N2DY73IbAHDUvi/zhMfHRxg4eifVd4kI42UCd05cOIYOR3+Lw4ubnEmhBnzvfZM9CkTi+uM1AxAn9L0UxwKQs0IBSTI+OScmOBWEiIxhlrz2RIShF02t6zwup3POOiXr1WdNbxgneO8xjpKzuu+EKY3VuosmGrluh+pwxVydtceirZ0vM8IcNCCfQZ2sj3e9uIKRCB++69ENvRZlYpxOJ5zODziHoBludnh5+0rN2w4Ydkhdhzl4hKA1PYgzA5uUOc2aa+dxenyUIPD+CGO0ASGSfdflbBXTtMc8z1nIDCGCAnBzM+T2uk7iAGIIss6nCQjAzf6A44uDMESa0nccBaaRhSY0jJt3Xqww2nbQqvfT+azn44iXuxvNGiYHP6nmIcUodVHGGVMM+MMf/iB76nv4zosffSLMaUKaGREBMRSNS2YsoQSApcpsTkBQabzMukcgTenrMM9z3m8ikmBuR/lMiaCmma8UxkNMiNOM6VzgibTmhXNdFtC877Ef9ohOYrpiBIiLRTBrVGBChSQ6MDxAEHNzJhrM0PQhOZbIzqHRU1FAW1C7MJ7TNGG8EDhUWUi4zfMOaIY9xTnOORyPR7x5K5bQFy9eoO97nE4nnM9neO/x9u1bvH79GiFFYU7DjPfv3uH9+w84nS4YLxfsDke8fC1C+cPjGafLGZ8+3eH9z+/x+fEB+/0ew26H4/4oKZl17vvdAWTWFpJ4t6BzL77pavllI3pCyJwlutgiyleup9415meb5jGMcH6p3SxSNPeWjByXl7HS4zXv1P/qA2Fw8keKo2PJOiRw3WE39PD9AQwHdg5zklih7775Nf7iL/8ZiAiHww0SgH4YEFPC3edP+MMPP+L8OImywhFIFW9wHpc54mF8ANIDvvvtXyImxmUaMY4ThuMN/vzNa3gEEBI+vv8Zdz//BHgPVq1513kchj1+9f1bfPvLX+N8PosAP06YxhGXyyXj59e/fI1hGPDmzRvc3Nzk6sLH41Hqv/ziDY6Hg8b9CQzZmQZQLBr5LCQ8Pj7i7u4Ol6o+RZgnxEnqYjzcf8Lj6YKUGLPTtKMxIkUgEBDGExBGdM7h3e//EW9/+SuEoceHnx/x4eNnzIHh+12u93Q87BCcw/3dR4wXEXJ2xz12vZewbrUKs8K/CbqS679mJ7cvm9c1V6PM/Fa/15DDmhZ3JXjLIUWuOq3Pn0o4VdowwM7MwpNzyOMhXspV63fWH220Iwf5KUaxWCrMvcyemHJgLSC1fwveBoA6q1xx89kWHEzAMoXyFk4xdEcEuNqV0CwJ1i6EVgjNyLbAhZWiCAH576bPogTJKZ8t9fxCQcLMmqDkyribW9c30mi6WXGcjYno6leeFoKEKjGlKZdpyvYc22erPXXrs/M117MFjb/57/5OtfgETlG1rCIxOSdmXsnowcosA/M8IUbNmqQxD5yknoSloTOfuDDPgiQ7V+XHlz6EcTMtMGdfV05BmF51XVgWUfG+w36/bxeOuQGqBGFqz5ez+tfLc/NljglanTppsKoxKBPAnCvsZg051cVczLWGc0aFGCUOIyap7XE5n9H5TjJ2VYfOdQ7zNINjwrCzNG+iKTNG9XIZRfvOjL7vASatMi2HOsageyOBpa4CUu8c5jAjJcbQizmcnGYoYsu/rDEACdh1OxCJW4rW2qy0vwKI3srXs9YAcF78iXKfHmma8fDxsxTrIxXCVGOUGUPvZN5DlwVMZxpIJ4G75IpFwda7ThVnFiCJr6C8D8yMeRTCNc9THj9IBOjOCZMpwkUQDYEzhMmlCFKVvq/2s/SkrgfK1NtzIjH5G4yYhr2BTfudCcQdIksNGIyK3jRls4MwmYbUTIPGDHhPRZiPEZwInRvQ9T04JoQUse+POSUyoMkGun0WCowol5/QmBAVSIOOgyTWZA4aa+B6yW4GBiLUHE1AUtc8BgqSlz9FGBG84jsHTpDkCeTz2lk+dbOMdCS58jkpDuk8Xtze4uWLF7i9vcXNzQ32+72sAwp9NJi+XC56RmRfpeYMYwoB4/msedCN+Eiyg93hiHfvPuAf/vEHscBp0afdMODm5md89913ePHyJW5f3MIPCW++6QC/Q/r5Z8D1CInw48/v8fs/vlOLi7hY7Q5HvN3vZWwELVYFPXditBahywK0SxyFJFZggM2ilqEo45Hl9acSivb77faXLh1Xta3KHNYaV8OVW+9bjM7yusokUcUCKPxYPv0aPzw8fManTwFzYjjXY39zi2+/+QbffvstXtzcYJ5nPD4+4u/+9nfw3mHUwpDeEabxAoQZ4XJGmkaJBaIeL168xM3LVyC/Q0oA+w4Pj48wa+E0XfDpwwWUZoADBqeKkhAwjSeczx0OB7EAe0T8+fff4cXLFyAgZxg7n8/Z2vr4+IjPD/f4+YdH/KDKEsMxUnSUQEhAChJUXl+W6cJ+apKWrOWVoC61/omGlJPEXogLLCGnxdZDTZTUK9TiShLuPr3D4XjAL3/5Pd68fgO4Dn2/l8KsO0mYcjo9Yrw84P7jezjNnCZKopgVDVKZWLwrWP82VULNXW9Vin/OtYI7mEB8VbpWPmKbYbvqitJoscUti7SZYg0oTGx9rLNsowz85hkwxUml8ARttb2cS+ZK81nMQgEVGvoloajt5wrOucLUm1WArB9evwOUGI+6qbUFlnPshuN67JWGHpUl4clpVa6di+XbsuQsBZB6v+u/l8/bdjbe2RA0lu9n3EsSAyU33WrX1ha062O69s5zr2cLGpeJIXFPBMBXjBYD7BCDpGGMnEBBCElMDuR69IP4VxJJgKkHsINsg9dA6JSipLL0kuscytTO5rYC0aL6XNgqIc5jjq9IixgO09zMyRgmqFZUmUJ5SwjeBDDtVTMhzHWIGtDqHRJ7JJaaYy1QJcSgQJpMqwgkJtE2QzJRCdNAGuPghfn1CUiEw35XIRLW4FoRkgavjE4ltBRtOHA8vEFKSZgq7zCNM6ZJChJalWQTjhRLFEuSI+wHCVmO1fqQYjyJA5S16DoHUCfBm55BMYllA4yhI/XaUAIFANShgzG8kDlRKR5DkBSy8gwoBZRUA5EYjjymybCBrGGMDKkqrRYcp6mPWTzYZA/MMEkg7pESmfIbpnG9nIJo9LiX4pDab2LGHCxNoLgHkmoRSNcPpJplQj70ZsLPAXOO4Jx+B2FqEjNCckjoFCYYtVXZ2jHEnhgV4lPEn9fZUJhaBMBgdhn+LcjXOULnNVmBajP7zoOjkGeJOUERvjVpQ1I3Iu1CxsQAYqqSH8ggRF4inT8QplGFE84wF1PKrixJBQtZYmG2nZMsSTc3R9zevoD3hF/84ht0XY/L5YKHhwdM4yTVg08npNlcyUpl8+PxKBa8MCM+PuA0XgTeWRQhTvEBOcrWrZTdt0SgiyxxTwzAa+2OYTfgsD/gxctXuP3zG9zdP+Lu0yfc3d3hdDohRsb94xnxhz8Cf/gZu5uDLJvWoWB47I9HgVFzpWKWmggEMcM7cScEkWrc5Hdysu4hSj0VUrg0tyxZ+w7FP12zfmWG0YKgrzD81bUUErZfuvoH7Gw9R9gwX+z6/pamdmnVeGrM7X0LXJQDJuhSLHt1J44YfefhGRKDND3i3U8XfHr3g9SKiDMcSN0JteaKIq04T6CUMN5/RIoBiBMucUTfOewOe1zOZ5xPE+AGdP1eXBqZ0fsOL16/xs2+RwoX7HuH353FdckTIc0j7t7/jA8//xF//De/K2uqPxNY6WXKyoUYg9I2ce/L6Uezz34qa1jjFOdW1X4zETO1cm7DmN4IScbgldkrG0QAEBPYybuS7tojhog//vgjPrz/COoHwAkNfPvmLe7vIu4/fsRlupRWYsIcA5Lr1OXHsqMVqw9YlVTkc7YtQGFuK0hj4zJroC2Ko7TxvF6zep2ofUTGG62Fic02m9+TNQCTAYTsbHScb5lgrkkauHpIS2dCGduakVZeJuOPtcbaFK+Z4Veez+4xc653lt/fmHvkPCklCymPgKq+ZDzXr6VDGgFaB2btqlY3thRT6nvFYm5UrP1C5iJ8Qva5cWW/y2XZpFQwwwKnccm09yWG3ZSR5iJYzzh7U+goKVXrZrKZApKdhaUr2rU+v/hO9e/XXM8WNGICUmBY1huBcQn8ItUqzCGJEKDfOC1sNc8p+4DbwTCtq2h2WVw4oFo8q5eh2kYjnoZYBQ96dN0ebFmCXNduvDF5IEjWb5cPMZSpFMKcJJiZRJBg3UhHhERSoGuKyeJxtCAViobWJfWrV0JPyOZdNm0uA1IcTvdff3JKqkySYoQeDnCaMhadFjYTwkYE8Q03LW+ccTwMQAd0XmoRII2Is8y278wNyWfGkIjhO8AlCIOmVS4d+ewnL0snwqMdyIK8Ze7Oa0rdJBpxUsxYUvNFOCsWokKi098z4qq0opJ2vpauZe3Mj9W0v6J1kOD/EKMyENS0VZBneWYBuXJ4vRJm7Yct8DeDRuNKw6b9yEyUtMkV4gQr0iFLa1oxUNC5kaTHJO819qHAKWwexvDb6GvioUNySpDYOlIBJxOSIoVoUJ3WQXGAY5ZYBCNiLMJFYmHCUkqIFLO2Xnq3/gUOfedzET2LjzkcDjgcDrkCq7kGFu1xYUDneUIMEmM0haCFJsW60HUeIcwIgfH582d0nVdXRwkg7QfxOY/B3D1S3ttO3YvGecZlnLKwE0JQtyOHw36P29tb9MMOh4PFU8le3T884HQ6YQwBzIBPEvR/mQLO44zLnPDuwyfEoEHprsOwP2YFR1JB4TyKz7oJvM6JK8scZjjXZ8Ytw7tTGLCKLZkyybkQxUKXYU6et9a7bcvBNjG4zpzzF9+p3m72t7737L4M/qr5XuuqnOp1O2XuzYNG0MjtKMzI2Esbkv2LEacZcYy4RMn0ZFgvzDGPmSF4O4UA4og0nUQ05CjZoVKAJ8Jxv0cMkq54vIhA6h3hMBzw6vYGx12HEAi//7vfgcMExIgYJlzmC0byYuGOksGJkzFuQsDSap+5ZaYZyMoRVSDY36LESJmZBRt+58UiUm6WdU0JZqFPjbLDOjX6zkmspCmy+jCKu2YICdTN8o3ziONZrJTjJGNyYkGBJsWQ8aqnujFvVJhaWRJ7hup+K2jIa2sG36zHm2uIJXwvry0h4vq3xuss3bfyawv+dsu1ibEa4kK4d4WeLsawPouF2V4LGglcxR00X1Hx0rAGniNolAyGbXuE5zHBzTcLvEOZD9h4d/Obav2NwpEo7DIsVEJjfS294lpXJSo/qLAHxcJgMH39WsJJVnAu+6MyynX8TRGh6jvPEiQ24LZ+Jkf8ilD3xPVsQWOepqwpgxJ4jgKUjjqAJLjVkaTYrKX6GAUJE0Fz6KvWWIHSOwdnheo05aARcGP8AUXwKuE5iCtN0pSZ3mnFXd1cp6ZVkGT6kexXIrEacyUZVJTwOMmwIhtiDH0VaKhMGaurFvRA25pY8E8iRdgJORWnBGTzgjkQASVLuRn5iz955ChVk9WCkZjBMYE6j92wA/mDVMgmWHIECFrWACyTctX6AEbOAsgsc0tKYGzIyBJ4yshEEJcTYU0D9sXiItm2LOVZMeuZZhyQA63aGhhRZ0hWsRJLkEu262X7a0SVoClTcwo6h2guW9VhzLaMqq2UbAzF7SzGgGkuKfjI2Hs2+b8mnsj9GBIiIknRysjZaPQlhXuDo4JtSCVQV8f1WE8kViGq1olAjc+lyTiuuperr2obOUUgFfe6TItFhoUfJPPTGGZMF0mhKkXeLGOKl6rTOY4B2T0LqnUehgFe65B0XYfdfodhP2jKWXG/886yzgkoStrhhH13QIgBPe9wAOdg7aAMvsHn6XzKgkIIM3L2KXWlHIYBruvROYmV2mmAf+SkFouAaQ5IgTHOAeLLFUCXGUNyCAnZPZLBCAlIzoE0e1XSdMJgloQFDw+SLYZKUgPqB/iaYHnJisMcxbUDAByQWDSv4hWl1goDUON1UPCXcdcEIeLIWlxTwqiwWTHnXMNq9U9uD0umpIbr69fzXa22hJ1tYaTFNdvfyejLZ9dHsSHggMFaEyEzv8oZ14IGQ+P+NKCZWIL6OQQVMhjTPAm+TAWPaZQ/mCOIo2bFk17nyxmnh8949c0v8f1336LrBvz07iOY5XwOnQeliLtPnzGe7nH36SOgY00pAVH3myUN7mpuec1qxnmxalSvCumrDKsvUhVU0tWiDDOcF0fXjYyWF1rMXNKAJjaBRC3uZPjLmCAHOK+rKf913gOOEGKAA2G336nQL2MjpeXOkhwAAEkCBgZpVkgW+upcmWPFhC2vAoc1o/d8xmsFn7amqw+QlRe1UPElN5SlkiDbyhddFP5+o2+ukjXASE+Zd9sHl38zi1N7hTDWv0EL2lV0Kjdg/127jIEvfwFr/HPtb9YJ0eodo/c1Q/zEKGp6Wo9YhU5q2rw+k+3xGvzxirFv3lvOUX8+xzUpv1PLRFjCKVX3amXM07ift95Z9g1sQd4Xr2cLGo4ITmuSJLYBJT1vSZC1prfz1GWLhXPKyDCr36kwsc4BxA4xBfSdg3PAMEju8TBLEK0EsYrEJgWXBAGJtwGh76Rdp4W9LNCbiDTeowPIA9miIUg1sQTGseTrlfk51VwBmXljAA6SWSbMQV0lAqJaor0SBJBkxmAlFjEFpJC0onOHZB9AAm8NnPteMmXJtxJ3EuaQA3+Gocd+t4M3zS4ks8nxcEA39DjdPyBwkhoTKcJZm8yIs8SAOCqBvplXBqnLkIPvjNMp+f3BSa1RhaFlMHIxO2YMQ4d57LPVoam4ySW4vQgrotWI6jJiLiR2NQTOoQgaiSXuJCVwEuHAOSexEFQOVRYadJJmBE2ZuSsuB14D41uiI7eoOsDJVH4qxBH5kuI3WVYudb1Slzf1OYPVWSh1KxgpSlrdbugzrIjgYlY+2ZuUGJ4IvStxCvauc6Vq6rAbsoWNqkxLRNCsTVIsS1xV5ODevLjFPE74/HAPjgH7/R43txJEKnKTwNqsft6cOJ9D10l9CxtT1Nz/CQmX8ZKXcRxHOC+ZdEKMWohS0obuDwcRUIZeLCN9h6EbMOyQGeikKUbDOGKcZpxOZ4yXMRel9F2HF7cvNI2og+97+H4vKYWJ4HrJfMVuQkKP5CTuhH2H85xwms5wJOMVHKVIlgDX75CL8lXMS1IhlZymErR3lJjbPcOK3pXUvUmQWKnGjdrPtsTCNAwCzHTeCrssSCnDRD6b1RkohKxy08I2oXmuO9WXn18XGBZfIZ89at9fffsMirYMIi9tlcBvs7wqt6zfiTCSYkQMAeAIB6FjHIMwzCkhTheNTdJzr0oA+am0TNtiBsbxjI8ffka/2+Hml3scdz2OO4k5QALiPOPz/Sd8+vQOl8d7kSlSKsIh16mzlXmo6unYi7bFAg91EKgKGqoYIyd1gAyVESgnbJBUtsVqXLu0kTaea2dVDKwnqRRPRAh604HgnYZ7mGsXNLZNsxImFZot654loui8eD4Ygw4Wd0FSDQlDeACymCujK2R0p5xVUYhsw4qc2SpNbTKaUXBP8/6TwsGGEJiFufLuksmze/X9pTAjFiY08Lq8trIQbcWmcCMIbDxvW8iCecMk62wzg2v3FS6Qx114vuXlFrjGLZa7sTKtJlYsAq56v16v9jPGVjNtk+2abI97a41rPsNgqhVwKxGuedes3Ks29WfNL8n78nCJpzPMpGVP7fPW2vs07rexLe9v5KHCWmj98vVsQeP1i9ewFMNmanbkcwDnOJ7h2MF50jSzPqfcY5RCZklz0xPE6jBNI8AOc7jgeLjFsOuzj7xJr2RVawGQd+I/7Tv0voNo+ER7a6lAiTQw2Xt1uxHqTIqkTdAQN3LL8ATV4poErQgvSKao0+mMP/zxD/j08YxxHIWZ7no4Ag4Hh/3+COeBaR5xPgXMYUQKYmFIYFmbJJlO+q7DfrfDzc0NXry4AUh8d4NmSGIwOt/hcDhg1w+AM1cMqWUwTRNOjw/wnQOYEKYJiR185+D9TgK7WRjR/e6I8/mkjHeJ2+g6D06S4aTrejAYMcSci11qKviS1co5uK64sg1Dj3mOAMSvPYaS0SQlETS6viu8DwSxR7WGRZ41NjGBLaOQIRP1KxcBiTTpgOxKCHN2GxbCqMg4a/EtXkesUTEmnYfUPJimKb9D9W4bY5IgdU8iEDgCiZvYuihJs5FSyvANIAu5fuhFsNQPYkw5pmaaZuz2Oy2qJ4xLi3okIxPHGb3r4aQMqWbNGqssUwTSGi0gs2yIq9s8R0zzCA8P38n5dBqnkULE3f09Pn+607z7CcP5jIfHR+neefTmB50Evi1uichhIKkPwCw4wOu5NJceY6zHOYJCzEGrwhB7zFPAHBL6fgeaI86XOWcXe/HiBY7HI6Z5wsP9PRz1cC7B+YiuA3iniQG0yF1MDpcxIo0Rj5eAj58fJPmBLzUjlK1CPxwQ1F8czkktICMqKtgCQORZ3JW8nKusmXROA6+TlPljY8jkX68CAZL16DLMmnVp1mQXRWhEzlBXAvorszkK49G48nFxu1sy6vU79lMsp9vXU0z+lhDSaDJXlHytfUXWphWtYyG2TxCqZ9KwbbINoFrjckvxBNuZK89FsQMwR8WRDjHMAESo5RDzWhSmW2PpnENkUVqZu888XvD7f/h7/P7v/0GYgf4ARLZOAI4QCxup8AIRFqSDrKVnTacMKlnqZC7qx0tSk0eSjRmjppY6EitM3+/gqIOVnHBqBbD9S5qQxet5MFrtNfuheRYUrauhWwIToWdkRSDpulCSIpQpM95CA8UVustpoLMwjiJYA3LePKlQQFQpubQP9RQorF4bIHtNK8wo89h6hmqPl9aGpTXwmpBOVM5rew7X99qsm9VYjMOszvrKhWmDkd1yyrHvnKPmfDbzQztvXqyDcE9y+brOhHycvQCWLmvVKyXtqo2H1vt0VZu/wIfNI6z3gjLNAtpPruMza2tLQmkYdSqrvFzv3E7lhr58tvxdRbUr8FSUV82wGNXECqyUUXI5s4s5fula6o54MRU2HPaV17MFjfM4IaWgmSBmZdQI3hMIHoyI2+MLxHmG1aogJ+k5nZNA3r5XdwpY8LFkqUoJiHHG6fIpa3WBUkTO3J5M0rb0mpGjAqyHVSdmBeicEpU82JVgcl0/HZ9ofI2JTxHqypEqTb3PSTkYjNuXN9iHva4BY7/fgSFjSSnBecLtixu8eHkr6SdZgsNhgaCaxYMcMM4XXD6chJGHuFDl/P/M+Hy6l0Afcy2yn8ZAOI/H80mqyI5BGVwvFqTEuD89wrvPuuacZ+6c1+xEolmSdZM4FMMKhOL+llRrncztwBt7TiANXjEEFJO4AVi+864bMnEzrcZlPMn+w6nwKipls3hkxExUXIUy1kjIqO0KYmqJhBIvKhoDud+atq0/glRsR5Iq7I0PLwMgD+ok7WJilvgdCHKjzoMSSTFK1ZCIO42sVt8P0l4i1fpxk6EsRrH8+G6QhAIxqTuUh+sGOAf0+x6OJbOXHY9kBbaQ0HcD9nsp8BgTI85Sx4GZ4XWMh+MrnEapZHweEx7PJ0nFG0Sw6oZe09t6+K5DP0gMEJ1jFgx2O8nTb0KbpcIMgcHc4Xy+YBwTYvSQOBiP482tuG65ThkIYJyAcT7j091ZYUphNCM5j353g37fYDsRmxU+ALVgdV3WApnzhtGIbHliANQhJmV+SfoUHNDDFEUaygfLVaC2zlwfpMH7MeYzVgJRbQIihFohwfqSzHkbTIQyyXWekMygq/B63e2ihf+rjNVSM/clFeBGP4unil9d9e6CGH7hcs6JS9IzJY1rjIHdNk11Sq4RNAzKmBkdOSTfgZ0DWJRhVk1eCAIDQwkit+9YcZxo9J1EiZLO2cZEJEn1o7kBqHCjXAA5h67bA+qOUtcxcL4D9TvFI5I5D1mjnADyAEfBb87onioV2AquepjAbAw5gRHZ9ovQVQoas1LCe8w6X9+Li6wJQEXcEXzMKYGdxp9Zu538bQsmbqAy9MTigUC0ZD00lpEITB7UqwLHhFoyb2RXxazoPqj7qmXR6/1u0bYDWGGAWgtCoQO2f61gsLy+xLCRCUhAc963hYn2u1ykrryVn62Ycv0nP1PF1bXLlF2lP7EgpWqu13BB3vNKoC3f2DDXgs9SMGvxEm9ihC08RBnPI2ealDmJNcvgrrVmtYJVmUn1e+Yri7D6xf2tZ5BfbYUI0wMse9xUCpWHwusA7X5w2lwnUzhR2YB8r2lZUZL1U+/DluBMttFQuohWoKLcaPnuOdfzBY2oxML3EuBI4ivZaT5+ZsYYI7p+j13foffKpPR9DtQEgN2u14BxYVOdl1oMw67DbjigH7rKlKra0tQuvmgNIqb5okXKSlpZW8AQiu93vAI8tuh3n8WHNlGUuIXsL6q6r0QaICtEhbxDp2lj4Tw4JakGnrMbia87qV8vc5KsSCyWim6vec05IgQpgEQk1gXvRKMmRbhQVAl1lU0kMBE+fpaq4rvdHikRQgBSmuFC1CBUpzEOpLEaMWdpgma0YRIXsBrJiKBmQCQaKUkvqEIHi0ZFBBZxA5pZA/alFYDFEjDOk7ZZMWDZ3VmFG1gsjDKG5NS9Sb8wLQIxpNSx9qLpVpeEw5CnWGZKGlpQcdcwwcM0NpYu0ZPEX3BUqx3KIVwezF41f5a73jT6RJImtu/FomYE1uDJ0tRmRkkFPTsjvuuavuZ5xvl8xvl8BjsPr8z+7e0t+r7P/XLirJm0GhbzFDCroGFtxhgxTKX+jNWdERgv50jc9STj3JyCFDoMCePDCXg4NUKb/d51Huw69IcbdPtjfm4EmIhgMm1mWLBGYGKqV82uMimuus+GBjMPW7XAAkPXLyMqhRBkwYRzg3Kv1hzV3dneYUlACoI3onFN+2nKi2vXU9/+h77+g42DWsL21MU1g1N9IrRA/XyBwsA3m67CgzJnJWGBxXNY/q+Ccy3ocokHoIy6I8lk5QDkJP/G5GaY02xRyc6kKAgcW1E6cxNxAPWILNrJnDyAKuKu8GFeA4b3EosiC05ctgyT2rh9xoWkc1c3J0cg6pqcPImkaG1tAcmMGUFiFsmsDcjvCNbz0CwgZb10DWOaMw7NkXEsZ07iuTSZjJMTJ60khCiMFen6cpIsdkI/BW9KlrYGUmCprU0JWeMsUYRRcbF75rXNZBW368K8rRn44uZK5buF8sAEiO2+scIcW2d0y42peU70BVy56MOUOjYnGezmHPP8ja4v2lnO4LlMa32ZAiHP23D01zf1vP5Q5oxn4qk/ua9qXet7X42Hyc7W8/t8qo+vUU7Z9WxB4/jyFwClTNwJJTDVgqIH0iBNtRLExAiJgVG0tfM8o7vELF2buwenCxIHgCWOQrFpnnAMvFh0BihJsS62omDi5mNBqLYh8zRnLTlMYkS76pb5Se65LMLLQdf0YP1ODpT6tyZOqo1vrS35+JhlRqXmouySFJYsiZ0RaYZTTUpkV4LrmMCO1FVj6W4gY+p2r+RnJ5ov36vJjABmJ0yfTsv1CQ7ms83aNiGR0oLqYpMFVMsSKy2QUa2YAoScOGjSReSUbwRwz0BKFfEswyco4NfATGJNIJK+Q9ZsWhq8CoFbQ8HWXLl2bTNZsgJmkJXJqOdQsZdwrEWfxJ2BUDJk1CwnTPtlQdZE8IklD/IYYRguZYGwpCEuKU1VsIPsLSmjKWsjqTMdQywjzuXq1cwiWKcklSnOpwmfThPcx88K75TnWxfEJAIcmwsRKuwr2acMrog8aHeDfhAhty2qmbdHCDuoxPIYe26B34C4TenZFWaPsiKCLSmB1oJYmpBzI/kcKTOh7xRRWw9oMcHV0Lv4Caw8TVXoyz03cgLldaIKT5BlxMkCIrK/LsPay9ilfLeBtPPfRC0BaPA2AxpTtqRn11wOihVhwQg/nSD+i5ft5/OEDd2hJwqLVV5ApQ+zhGD9bLMXI4g2PpRZF2Zyy+da94qdomdjNutYhHYNPRGsNlBO6VoTfMXpBMBxgkOSWjfsJBuZYRGdHMMhwOKnHJxTxtmYOAbA4jK8VnQInNUMpFicxVLddXLm5nkGaUygYufNZZVzurjHnC3Ulkgk6dxBXmU1pzGXsq4pFUFnGPZIcVZaRKLIgghZiUV50Xc7hBQxhZJMhKBa9iSW8Rgv4paV659IvNicJMmDeAFIBjBR+lmcYGs5fPXyFb798z+Hcw7n8YL3799jvFyyRTaEgBSsqO16fSzuwty7ijptfTbzd/pzmXq3fsPgodxu3ZbA5Vn+1mRME5RL45mhrHFPERAXOCi3mVMBNOd7S+st3y2Y38yXlb7qb/MZRbsOVEHkNYZ6OSaZfpUtywqULvGMHvEtPrg0xYr6S5QXYY3fikxfKE95w+655p26iS9hy/raqhW0hshm+Mj0BtcZ/5b2X7+WQmL9u7mX1s38exE0qO9RkLQyVVQxgI6RiBBAUtCrWjRxEfFwg1gKTCcCAAwPpsrlgAyI7ACoK4vCVCYpJIytueMkViQUze9RXaW8RElIIBo3PRc/V0srWZiPSmlkd+RQ5ZMelWGStIWsqZs4f0RZa82UJ1UxMZCsU04sPHbuMlMGAE4PgTFpC7zWeZ27ZXCyGiQgpBCRYPEpNRGGIgdZc9JAw0yKuIAuZV90s2pIAzIFCR4OLHsojEURdMDCwAspMoa2EExnAp1dxmHYPjnNngXOwqeGd2vebFY3/MoIaxwgJzhf+YMbTssHQwVcrhhDaq0O2WWrRnLZrV+yHxUvb83GQABpMHhKDMQyBuleCOacGJSoCBkApLaImoaTCAg51IMIoA7kC+PJKSEkRmSnwpFDBMPZnrHXFMPSnky9RmS+nDWwZJAjEjch1rOh/t+GXFNKSLbG1YJk1j6xzl9EgJQMVxQ4AqCMTar2g5Ugl/OZMlNI635qRlo2BKurubd2lyiv1W3p2RRgre5pRjhbsFyNPR+vanwFh1y7Gs3lati8em/ZohH27Wu9FktN6fLec8b51L1tRuGJ7wl6ptfDXjI71wSbzCRtaWONcV0xSwZjdiI1/TcU3JXZpyxsKIwKMgYIqhRi+39mVmwOyQrYgfJ/RGJZzvIeadE5h2xxbizKUPegPN7WtcfmnJIo23zXa0GyhDArdfUdPBxCinmcYnVwAAnu4yweFaZPZiO4BFFrYZADafr5OQZRNFCCi5Koo6yvjOvx8SzZu9gyKqqLVQowrEmJwX2Pm+MRN7c3GIY9vKaCvjne4sXLl+j6Drv9HrvdDrvdTlJbx4g5BoxnKbr5cH+Hz3efcL6cs0X448cP+IDfZXB4/+5n3P2NuH65XuLq+l4s8ebW6L1DnbazsQQQqSCocFfz90+c861HBSZbHuOqlrg+W1QxAPp9/Z0pUzfx4Wos27bUa0oMGcoWB78hDH3hYj0LdYD4tXN+lfFHUd7RFXZ8myy0N43+PTWGdtwL9yZQs5KyB/JkPfYvrc/i/Y03GmU7oxF2lzivUWhVFsctGvCUlYKI1JX5adry1PX8OhpqjjTNfybDFeynEEtgI1S7iuKjXB9SYQ/bDc7aaSh/kpG9fAEgMzqFaYX2aeyeMMha0kIFGMpFxXJLBgxa6GiZRSLVc7V3waWOAQA4rVUBh7RMDafjITaBDOU7fUWYZEv7V0yMTK0Fg/IgCtdn7xOphtnSXjIBEMIm+u96v6xrEVzKWhMsyFhZZh2HIVL5z/zJBbiU+bP9zhOkbK0QJtAVISxrixmsjC7pXmOJHzPRr9Lg5v0UBjTlJaoOX74IWSx0ZSWRf5YA9HLX5srKK9gcdEW47ErOVY5K+IRa3zYOJEMYARMwipZfGfxqLZhR0jYao26/smXHEIHG2CaBtcKoN5erWCs9m3bSkjEyTvowbzbKQEMZLm3DhJbJOtkeyKsKP3lTsalMT5wg2d7M0mJbl2A5fBr2euNXAGKZs98rIXZNLEteeDRt5zdW62b4rWYiy/3290Y/Z+ezBrUn6JcJs3VxRrmvnV5jHGw2q2eVC0bFvNu7TxGGa9rMLxGT5wokVU9X7q2J3TXNqj69rqi7op2zM1OENcMnXGQKZSwtybaANANsmZQ44y4A+WxKZz6flso/ssyxAhSSA6kxBsocQC2BWvFeFEaFkZdhixImpITOAggBpaiKjyNLXB3Es0BwnWkuWKwtiBIvxhGWeVDiByXmEUHiLQ77G9zc3EoVb2YMux63t7c4Ho7wvtOEIX1OIJKYcTo94nw+Sar2EDDPE8bLCafzSZKpJMb96YzL4xlhmtENO0n9DcLd3R2G9z+jHwYMvaTStix6nCAxIbMU1pymC6bxogHmpuxaAIWlwXUtjlgxVxlODDaq814pqRoheXE8KdPM8neDszaE/q1nGV6wht3yruItWrRFaxqw7rc9Hw1jyvX7nME24/Va/jaQ/hKOWJx5ZhJhVunvtbVYKl7yn1zaZOa8PQ3trfieosjKj1AoNa14pNJnHnDuq6n5Vb3XLKsKQdb8cm7X8FnTJwpXavSVMg6nzDfk5+Y9gkXHCwHkKXxNW7BjbaCCg/LhxjzW17MFDYMqW7zcfCXhGpLLzBuj8mvFghFQQUPvgyAaWFs8Nm2PTrLKcJMnbd8yVz7fMg6KKAwdGTnhwgQQVAjgyt2lPYwZISk2EetBaTMmdUFxrdkr/2aD1PnYvLIUT1oXQLjQvMkMVoFKj0Hh+arxAYAEhIuwpcBODAmMTyaVLQ6c7ZOAZOFjWlRQZ1rKh0wFDUdAHXJRDnrVH4vbFcsf0oQucWFGTftuhNL+obJuec2ge1Cy+WTRcMHMmciUd7TFPYvX9fC2y6sItMBEgQchJKTw0zDVJviSaFprjRWMAeCkQczV4LnsiUzblWw09RRtDfPeUEFubMJDC8MZgVSztvEvSKCud4XJsUBk+k29ReXzbcKwhNvyTjkDueinKRZqLk4ZPPmtbahGp1wt18pRpCJE+f3qd8MU9QsFIhcEoW4WKLhMhUFk3GYvP8EMo9qj/I7L31vbTzWwci2gWqFT4PI51zVm4WusIF++rlD0jZtfqwFsnizgMPdhMMkQJKbCQElbicVe2CVCcBEpC2xQ1bbBbkUWayzSCN4M7d6p0iBJFCknCfiPHHNxygZ+dX9jjIgg7A577Pf7HK9FjjDsdtjvduj6HjnGzhgOFlfmcbrgch4xzxKfNY0j5nFEAiGFGeyFDk3zjMvpDE5BJxUx9T16Tb7gNbujc1V8HBHIdXBeFoIhFphBiwemRBhCwpwuiImRpgkwF6iclrfEDpbMelTqWNlZW3FG7Y2u77E7HjJcGGzUMZ1LWGK0yRgWHTS/k6vgrcG3Vz5ZD/FqP7UQwYtneaxGv6tq2/KtWTna9xuG/drFvH4vCyJKG1afrBu9aqnIPMj6PRv3NXeq/J40hIK/n+if0P7cfHuxTRVazqd+JZRWbek6Gz9XNySsLeX5PXW1epEFXFUEOSf7rfeYjJ8okzEe/EnrWzMuwoadOJ/jFvyfRxOeX0fDS0YOl5OZyVWbvsiJb7mhYwZDKnhTEQqUcJqfXs1oNsxdTSsJquVXZk8B3WwilC0CyP2K9K/vmiaj5khUOkwk8Qa6amWxMwAjm38By9Jgee+T1hio2BYqjK5MLRXG0ALMlbFN5BA5wSWIZqsW2IzgcWFGauna1tN71UlzGbcV3hE//ZJxxYQBY+fKqpUrC4sJSA5wXNx7BJ5JAa5mro2xtlgBK5JoewGUCel+Gle9xWAAKtBV42LktavfZNU+5kNeQCbDVsOQ5p96mMj2xDyZVcNJzjK7wgrwmTaT4CEaeXXBQmlYUkdK9i9jmq1+C2V4UIHAOY1J5byngMSBcKhEZ0VSVhtQAhfVIrWQ/JfWlFqwB1CqsJKdnKp/bcbWJcNcXsNCzOSVLSRjxL8w2Qtc2ZyXzKTZf026DnMZqdteEg9F4lpUkvLf1RqshtgOysi4wJIyf1zsKkJgUNquRBlzuWmWwua+Yga2lquswJLKlfZbmH8Wo9BcayaqPhRL83+z3M3mtef1SwLMWgiyc1ox9QumrW77motbGRsaeGzml4den/7li7r2XAjocrkFt+q5MzM5Utu2fkw5Hev6KmqRak5UzqtZMjrfYeh3ACeM07lkIUxJrAOxJPQgIswxYtjvMPQ9drudJKfYDXj18iVevnqFw+EAch1810taeI29mKYRDw+PeHh4wDSOOJ/OeHx8wOOj1opSAWeaJ1weT/h0OcMqwzJEuJCEJR6S7cqDSKzUKi9pLSWz1tpp4jz5ru8lm10hbKJgIUlxLgWBuRLaCjJg3mZGiQB3Ldai+n3Lapb3hangL1yD84KbGMbPPHEtwHDLesgLwCOb0FZzz0AAhTerG0R1b3FGn2iyYEnktbG9ye/Qelxb46TqjGx1aft6dVybKGO7RRvTEsfl/TN4QkszjOZuk7hrO224fIuvUTVgRde+QBKaVgxmBX3aE6UFKRWPkjz4eh7F6nnNolbgt4XjLbz7dbRHrmcLGhZYl50u8sQyC5IrfhMIUn9A6lKQ66SqteOK0QEs80dOV1dhe2F45B4rcapzQTMjf0euKuRS/cdgCQyrAm8zU6BMBYHRaXYOAHkcNYIhInFpp3XQLZHVfbANKEhTDssCiaWikffewycSQEgFeBhJgsWJkdPy5fkVjVw9DlDJTZ33iiWVYEpVesYyPOgOlHNTS82O4G3dmHMbssdUMoGR1EMxgmipEoldqReQ15SKwFgvlb1TrXnnffU3V7mpDU6cxuYas1Bgyuv8vDGi1fp7XcWGFLlaENb9IC8NJFbLEOkYxDSfGFk4tNS9BEYp+aF7mRluEpiDBViTcZEVUuX8LjsuVg+dlxTIY0kZrfE5JlDLRlQwW6ONDD+VMJsK4SdCPkPUwEeJTSBxqgVRh2tEUgRfjxY5FRxRiJuvzgoV8xlK4CzZmtXDsWdGPHRNi7zqCzGpMgStCXax/Ssro3dlzXMcTCVQaOYJE9fyrBq0rAdzJb5Xgl71Yv65dFmwMddChszX13x61RqVNhmVqzkBmkq8lbxqpwFlAas9bZpvCHkb9Lj8vZ3yhv811evSMil2Fp66uILjJ99lNPBV+qm1tPVIak0wYG6VRZFV7SnLWAWmSuagnA4cygRnWl8pmrIiSRRVveFuZsSU0PcD3r55jV//+rd49eoVHk/3mOYZMQSM44jHRxEMLuczwizKscvlgvv7e9x9/FiYCS8pzpkB33vMIQHOoe+6XCTP1tMZk6z7FWOENxxOhL7z8C9uKuY85exMROJ67EgqdkcriDr0MDzNee24jI/lSDijZvo3CIDiNU4p8wrlHDDMs8FlNxGXz7oUy5VU39dg5yltssFG0TyX812+b75owJDz3drFqWC0Z/NnzVFVZmQhyGy7GhlVS8UbpKLzaFtAsSK3czFX7baPFke3NMu2ttQG+ZpLjmPNRBf8bmiLVx9wOx2bE1WPMp1Q/jT3hQKELHitwqDCf+oftRWi9lq55tJpHjBLoavwpQbTT61RhYtbDVaF+XQPQCDf5fOR52e8BZQHzednu1/DBXk/F8/K71m1+lX7/PxgcGawATBvdaJBqTGKaTOPWX0mGUUTW2UAktoRekCMVhohtDZUpVFrIpiRK4Tap0tNBSMCvrM/sotMPv2W27z6xhmQ6DhqjV4dIJZT9nLRSfnCsWeGvghGhSmtx5sn7krNCCaHRBWyZK2aCi5uVBXTVbJilLFS/klN9WCDQZtJ9oAyhGabUO8vp6wJ06UUQqGarCyIAFUsDrfzw5pZNC4uH75NVFwRahgTKKYG72tGYsG4aIdFK1/wU3OMjLEil02M+fPI+ZkJu55MVHHIqRhgvLLBn2UuKz7eRWNVC6YFyYsLXIX0NaOSVRwWgRZKVEthynw5VMK6skrkFlOlxe8lvmS5/bZ+Be2wmLiUQTC6VLshmCCeP9xiNqHHz8ZWWbqKAgPVN/q8pbLNn2TLtWCmbSkXLtULKKsQq32i2dNqC4Z1ZAQrN1KknNy2y2u30MwZwKN801iEK+JdM8f5OTPY5YXP51DGnnJ6UNRwZAkw7Byg3YvlUtiY6ym261bG85RWdTkfHeKCUUPZ15wpqMXhW8xEeXad0FEFzGtmYPU2JLtgoTO2uJm9MyttQ6x1blR+BYrLjVlIqWhBBB+TWD5SEMa46zp45zBPM/740zu8f/8R8zzDdR4hTHBU6kKxKeZ0BMfjEbvdDmYt4tw+IwUZ0P7gMj2qs/05de80hpNIUuUabLFWtS+CiczfOUk/D5QCrFD4KjQyNfAiFlmXcUZeIcVtAk+1daryilDOL3st1IwPca4fkQu2LuItW75gCbPFepGFcpRX1zSpPsNcbTtXTcu5kyxa3MLwqrmaKtqc6ne5+r39dVuJ0ja9xHeN1r4mN6jPc/XVoun8Z6VckiFsWC9x7exJdsVaeOLFz82LUOF1qshCO8u6uGXJDFj3b99o5rlyPAsNrElOxgdV/7B31vEWxv9cxU+0RYfaFypSXoFAu3nF06WDZfnLilkg8yxPXjZ50vbz8pb9q/stq7m9v9eu5weDh2k16Na8VVxyWuBUTTdI47rlraTuKBkJELXx2FQZoHSD0yJtnaQkLddS4mwIqxHmqv2MLmLM33CFlHKwKSuyqxB8nKdqHHovEyFulqpmJmzOluHI5ifTVxcehuYPTwUJ2hqgEAnJz27UewkM8jOwzm1NsfOYasuDW2iC85oxK6eg66EPOEoNE08V88HaY03sq39dAzdlU6geZ9ZyNywljPRkyr44+Kv5XWNsMoarOISm4JH6NFd/g7lOTLLCI1YEaYkScpeZoK6JlxWczISPTC/mK5iFInhACkkuNMyVd4bsXyECTW9c38+HZGNC9frYe7oDRihsuxUhERkBrs5APlNl/63L5kxuXsqAGEOiH5rJ2NoHWotMo4BAzdxUOMWmDd07u73wxsnMgi5RCQblrR/lGbfC79LSU9Ii6jwrJluEJ8MHXNxsKi7E+BBGOTfFRYBh2kdmhqKBhpkwelhWCUB2IWwWMyeVXAqrW8xFc9nZfnqTK/BKWK5S807evCpIDMu1r+azMU5sfeFogSwKfmYUhuXqwJtmm01v55PXXL711IGjoUxJVR2Z4ToRLPp+l9spKJEqmHM5nbytTXlPBI7ldF3DxSAzLPZ7ZgCdU7xucKPW3twcgcyKqO2VuiMEy7UqQyt41tUHsLnWnuHcMHKkKXZ1rKTwou1F5Qe23EdR9V9fxmWsRyNKnvKi0R6gxslUnTh7zsrjtJYyUazkfhqGmZq/azAvY3AFlmoaYjh8MbUVKmdqSB0WoN4OrtJaoxLEjA/i0kRxJ2zh6KmLMh1b4o7iLWN8Us0byBkpWvv8Te2WvbxyDZ1C81a4Iic81T1eCif1P7pX9VFcLjbbgwXOWEJgERS2xl7o15MXMxBDPueZ3qGlPRlbpgLTlP+t6Yp9W0IClgpAkoa2jtPV6/kWjZrAoPRr5q20BIh6KhmQbVKlvdyuIrJa+5cgNR5SPcmNTdlm3OQ380FfAk99WfVRp0h+bXhtr3oMaw/h511bUnAZI5cUoGaSX7y/1Npc7SddA+T1OJbuDvUzBzVLqqyRDKlUzPO2OddVv+ML75afKa3nV1hYddNxlUaEK5esqs2cZYkXh3aFmKlBGMzrMVwLDixzsbiNcjDrA7v9TdW/tZJSlVGpvMeLX5aVpk0wEsLervcWDBmDW49pG1aqe4tztELKm3wXK94t7yZz5DZSf0UDdm1szXsbRKTRei7+XvbFrIUdF/1VX1fLRLbAyJJSnieM+m6s9RpHFXip+zIcWeaE3Gw9Qtvr6tsszNXwWDPl5Yx/jdl7SRxrnmTZznJtqaIIKwJfP88H+cogVoeXth4AAOb//Qd8+k/+sysN/Qe4voIAb17P2ZothrF+RmiX6Uttfem9p95pkO4z+vsPcTW+sdeEDHu8Ek3W7zZ8Y1y90eLSFpjlmUn6G2G2G7jMcGLNaVhWQKCl1ZtLztu/5200dLF4peCbDeF8IaDm0VU4ZQu3tH+zfbzhGUNNhsTWO8V+MeG58EpLN9utK/MV1k/dLptbNLa2fsHy1wsnv19d/2fi2Cdp2xPfAEVxLYNshYgmJS0VOlM3TwRVni7nVU9FlJambHjG8FbX8wUN1wFUfP1XjFquBVEvvPo86vyZ6owySzcnA5xKeiJocFjphwntMd6cdXmDlYF0NeOx+MY7S3FbjaRipAEUl5Bq7suDugSrp7R9W8xO3ViKXIKRKwSWYeo5u70QHLb6rqXqRiBbCgNU4mAyf1UxWkspn2BxD1H9ZsXdR/KuC/PdxHAs1mapOa3vJQP6FFcwxNX7zrlccApUXNNyn0ocYhV3k78zmDU4EG61cZ8rypKK0c3nlbRvLtpG7V8K4aXcV5mfFcuzzqtFYQBuCWGLq+Dw9aNNDVI79vrv+qqVAc3Tqs3aYrHR+Yrxz79ZjRRefsKrMX1Je/4Ugt4igluEjKvftqkOby9w3deV/q+Ns32mtgMy3+Jqb651mI+hYqFqAAaLqBgHap4vx1UxE/nZE3u7HErTx7YzZGnT0FixPj9HAFoSytW1Z/B+ftZ4/4fr/x8uwoJzAirL2dcI3VvXGu/UZ6h+r5wIsepSgwu5/h4MSk+fuSWd5FWck54rO1vtx21fG8z6CleucF/BNfLcpAfFRBW+LW0VxnetbDalU4V9c39qOaL8WxEAyFX4r13658jGWWlk3+hcS6xeec1GYjzsRmvP481QcKR8ssEHAjmBUHVj1Vda3Gv5sFa4KP3I+Ot+Hco65rhpFV5SsvX5087K84PBqZhNa/JsFg1yYrJ1+q69ZUHYZV84Lxbnf/QyIYUq0rYoOFf/nl1wbBE2EUZ9sPVOtXGWzb+xrBhDtWRMaxGqodbVjwUzdE1a3WLs2vdLnAUvDyxXkuwTFxEh0To460t/X79fTXQJ74s5WV0P5xx2fS/pD9UnOGnmFPvPhI5a8DG/YyLKGU6c0zgKEzjC3ApNqBC5+ut2XZd/z4Hqtq9aAyTEKJXem2q7yGMCBH46zRlvayMxIu16dV2HEELO657HTWL2t6wx1u48z7hcLjidTpjnOQthywNtgt0S+X9Zc/6nXX9qO7w81BvtFLO//tBDf63P+lz828zvyfOypBkV8l6d0er1Lbz772QPjClZjHlrLDaGGlM2wokJEM0ar9fTBGXkNutF+RMITEXA1w/aBRcB/Wv6aL8//B//DJf/w++R/vry9eP8H67/n712/+dfoftPXmX4auD9K9r52jNNjRCRW1n89hROe1q43zor9flt6ASwWc+oFTaecf6e4hvYsAQVPESFilHVV1ZoUEUAso5jzVetblRLQ7mdCkfVVqHVFCq8uOym5s2Mx8gv2nwaZFspcsqVNjLh/UkXt1DAaN2VSDVR170AgGzD2eQV7Kf8klD4ksJzpvIOayHjMrxnX8+vo0ESBmnZdfJtwNIdgYpdLwMPgbN3AIGwcKReaOtpfUBYQG+rPLt0RaDM8K3lra30h0WbXYGIK/cyWa4Arq0U2vaUrSyZGar7ym9Vs6rP2EK4ICO6S2FG18c+/lJ2hzxuX82Icx/lb65frxsAFvtcJOVy4Mw/14C+LIrdd5JyseuFUSdCSlLnIzbWjdYvcLfb5bE65+G9BJ47oqzZp6HXrsrhqDMiEBH6vs+BlLWgAUAyo6UE33XF6qBjF0GjuHk559D3EgRpe+AtSVLGmw6d9mWXCUkmaKQYy3yV0Mzz3I6rWtf6+tLBzgL9letPZdSfY/UQGH7OKMtYFi1UMFisa0ut17/tHOq2GitLrtVRj6jtZ6Fr2Do0Vxjr7f7bbxb3Wnp2vc2N9chntdLS1eSq6WDRYU2IS7MtaaEK/9VCI9V/X4FE03wuIfUrQAfFi72ckd3/9ZfgNwHxX5w2vijra/i1HdPi3p8gU21zLn9aG3Rt73nr5ec3vz5xy2cFy3PzV/1BRZ+vrGV5na+vCy9vPDHQK5fB/1Of7f4v38H/7ljel1/aAXM78E073FNgbbgpH9olorDXrk1s+yzCXIN5OSZa/LAzu4jx+sorn5INBURWbm7MpaCJgieMV9lYBVWQFJfZ1WrTBuwvX7m6XwtmevHdJu0iLILkueJfa/5iMR/a+riMqD1NG4N6co+UTzPmcmHxoNJ4Bc9bvRnMpw3SVLx37EetKJQ0z9WZYTtz7TSecz3fdSqjohbJWyDW2qevZlJtcGuCaEBd3EdaAmb9eiJsIYCltSALCZkQZo5+9a1lTM0Iy5h8W/CGudnuM8+jmt5KSKjmU4h1jRDaDE1KiyuKUz037O7cs7CJAStRtaYLpm3LlaN+P69rPYaMUyrAK+oU+OxXBMxTwDxpMSbY4qZm35drFcK8aBPNfJkZnlzzd9PGckz1vLk8u+4q1PrSmhDTWhQ2jlpl7q7bN0HHvo9VdrYtF7Y6xBDYPtRPueAs39la47q/a+891d/6ogYeVk+rs71uyzaljlm4fi0thV+6tqyLW/0b/9OMr0KsNWRsws6VsW6NR561mXYajdsTTE3Bj9szqelQ1WKlZNhsfNHKVsvXrtSOeaP5Gu/kuj8bL37JRa5qsRnT4f/063+LtvT97SF9+eJqNH/C9zV5JKpdQzb6aGCzCOgZX9ftZiZ4Y8iLtbkmxDfCI5c9XD5f4RisY8gKs19gcMW0Lgb7FA7LdJK3QsmvXDX8GZ3PvMzGAFCY2SddR/JGyE+3cZa3lBy0eNY2afTgWpcVPdq4t3y27Dv3AVXm1mNuX9rEOULRabFkhbfZGgkRlWr1C6Gp6bu+V495xbfXSip9gTdfbb/T+Ur8QTmDbAWrAE3+WHi35dnizCzWlwSyFjmgPWf8jMHZntQ9Z/4J3CSlKTxSWt/Lf1/v6zpd59V3S6vKc6/nCxpJmUPyaGRQTuDkkKhU1y57niQYeRX0WDHVqOqtskyllqpKAS1sAuNqIZ6p7awPt+UqrjWqy7P6LJ6GtkyFy1fa+1Z3YIlMrQI5gCbtqvkHEpG6jqHVHGUBoEKOX2CynnP/qnBVMcT1O24TaUKR/BJW5WDLtrexMU16uisEaHOM+mudmcnMf/X7S+H2KfcdV72nQwVQvllaJZbaeHGZSqXfal9rYcO5kqGkgQtqCdX2njyFvXJnaFUi6++2QIJRzhvZS4vx2djabvOD62PLQ+BM+PPtan3rv1sLzpcP6Gq9jHjWXJ4NoR5SzWRsMHPl7C3X9Pq1DWflEC+WYPVNLSA+ZWlq281fb94rVqnF44YB4/YFAdIi3WyM9esursHqytjb9+u3jK1u29jo5QruMBy19c6fel0TNJv9rObVKFew+nUFG41lbrFxlgijgOh1YeKp+S4Vf9feKYLyU4svLdV/Xmv1+fR8e2TXBM3Vu7Sm+cv2v9R/bpk27tOi/w2GPuNUHfeKl3gaZdg/WILPinYu14FoFU9xTTFV4z/KY9s+k09d15Scy7k0E7oGC82BEGBfC6ctfuf6l5rvZ1T1klD4koz7NsbVXNIgoWq6UsDm9WNef1/BsI0/ruJ0Uvm2VgAAqIPkl0Na1wpaXHkNn9472uCNn3M933UKEbqDACybE6lGrmWgGo5EB5+FE6Ycw5Hjx3OzJbViQwor2lbAZm1+rzWP5idXa69XyL1GDiANeKENIK0af/K6LlHW15JBWD4jZcYLjmqJUD7gFY9UEIEe4swUFRedr9Xu1dcmM8MotUlwHUHlOTmJ0VhmS2o2dtmPIegrSOlaf3Y5LfxXI5SnxliPiav3t3ZzKUjUiLi0JWkOjaE1axEBUtFTG861KRZao00r0uJZy5is2NPyvf1N2lyGiXrMFdPSrEkl1Gp7Kwi6wjEQsIC9ejzr8W8932aQuEIUTzNAT16GhHBdK1qvk2RpaAlsWfoCy9fO2+p+vW+NpvXpYS+v62d8Mf+sDmvhfXlPlrZug5F9dpsvC65/0iKWqlTcG3vZ6Ak2m1mvoaC8sjeMCv9dWcCiKNg81Vit11dday3gsq9N/LN4xjX+wWK5CGh8pxcXWQpQ+1fPx9fi/OeM/dqVPR8y+qLFOQc2N3xTAJT/1oqC5Xsb4yDA6n9cV5bpi1UBRhnK1ljW1/q95Rjadai/sb3PNGalpFnNaHMMVwhUfngNojOa+YJkngWD5TdY0gmUexvDMlrwZBRDVWxO2gKWFNiY7bocgU2oWM0YVDHY3DbQzK3+lpfMPVHGW5zHBv19MRNTHiq9qGkf1TDeKBkaFre90trSmBVCtOCJql9bK2HD/Cx7KLcXj7bOvYROfD0e+QpBwwhxoYDFf+s6TaRmCRVhAMo41i23v10dhQE7MUB19Wj5fsEr/vfy2tJG1s+Wz+1nE5y81NRX35fr301Q0lLr/9S11LDW/5GmkbNq5tfa2rLwbGqjY7q6hvmdLxH4RV9l7At3MzwPnKzPnBqXWphs950W9+WWWTSaHplXSGJrnbbW4Utr/dT9Ggaf2vqM/L7E0zPnopXXLiPMzOtx/Hu5vrrZf0/jqK6vgbWt+09/+JxOasFjLWTkJr4kxC1bZAYj5epKqIngV69raolo05mM8toarV+vNLb/vuAM5Sx639IurhgrvVGxhwvSzk8Q3H+PRO/5Wv18AwA3CTRqGvYVPW8qsYDn4YUtGKhxFSkjaQz/fx+uzXmJVL24ta3A+Nq+6j6vCQ5fO94tXQlr3CO54kmy0drVPm3b8vbxtltZFtfZ3JDLR0uxqz774u63paSwb9rg6PzMXG9iOZvkXBEojAYTiYKxGWwRQEqTxnf4Zn/qCZoHRQhhYwXq5p/v0bL8veYvnM3nTwCzr6qjIZIoZTznycE5kqzSCSAtENQGgVH173KDStv2luXrXUp4W3NbbZg1rcxdE2peMS01I88slU63erjGoBG2EZKM+9+OIcpjKjdMDaAZvXTeMYEgFgJzPZP4gKIhISqsQSsRA2aBAgpDfU2DY0ICSAX2+rBSOScAl7ioiha2wh9Xgf20+FnebyxkzX2dIxPadK9FC/JcxoIBkHdN1maBjSJE1xpGgPO6Wp85Bghc8lEDKIXU1xmTipBYz1nOwGZ2kI2x1z9lPOVctcJBG8SX27DvF8LIJlxXY1xpVppxAev0ewVWiqapDGhrr1ISl0u7niPkMqr00wCu+YBvf/tleGlCG+1Ibr4oT74kAG7NZY0blyqm+nc5j+LOtRhnPT7bjzqoL7dtsC3/GkFu9sngavuorub11EXyUjXmVkgQ6lL2Y605W6dBXu0C1++sGYovXca8rMb+JYGlfvSMNVrhWz0nV8/gEjdflRabE1n9S0o89Pcar6LeYmqayAqERW/5Xq3hVHwi6cFNoCBJFU7Ufn9F2UBUMmwQrd/5kvJoyXjbepIqJVsBo/qQW1fWrb6ee9Firk9d2cWYKpWsjRnr+a01qSWebwU16m9O+Q29Xb2yVEU+rbgEYGOrGOhmODpG0md2nnL/Ff5Zu1AvB7P6pQCq8ReEUqIkt12/b/wo67iSFksGQE7czwGkFOE8wZzWl2fzSUstAHBcFHwzvgkl0RAhu6ix4j9h2bidU90uVTER663YpDNbwqe7et4KjVy2tcRFK9jA892ovkrQMMa0oUOkvuu6eAkJFkdQsFctEJQDZUKgtSV1rjNazLEZy58GYV+DAp5C3ssFJeCLCGb7OT/x7Ho76/cLM06qxWjMbtpVFug2mLbMbG4FLDfvlBzJT407cVpUzq4Bshn64jzwld+/wJQ8qVHZ6oFXT54i2myHe8GMXmNS6r3dRjqFghG1fy/nVOBuAzl84eBeIwKk/odXLQBfK/yuCBy+iHBXTKk1kwm7EeAvUZh1f9cE/vLu88/rijn5wlCu9Np8V9i+tp8/2eqALUb7a5+3TkUtKmBFpkXrttKqA8hFBet95bVodk2zugWDzPmf/D6RWm2v4WQiKUbLy/W9MvOq/c03FkqM515PMmFP9rj+pv2eG3gvyrdrjcpTsw5vPWXd38xk8PUYQqN5m5bjheChD9p3jJGj9lSslUXuCRxqfZT5fe0eXWv7y8oGrHDIc2FkvZZ17Nd23yu8UCl9nhZw1rT6qqKEy/vrFpCVUJkfe3JPlGGtx7oQNqydJgi+7iGPuc6AZDzl+lxxNf62wH3FMxkflIXSjWDlapwMBpJFwNYK7QjWRCTMy/F96bIUsozMH9djaPgmyv8aiMh/a0FXmpGXnuKHapxR39vCoc+5rsFe3V6G72e2+RXpbUsWoYbCGxIjgKMAYJauVZBzi3HnsVlb+jMjGKp+Lt5BOY9wfH3xgaIVqEnymlBlT8C2rZpxrc7UFnNRvvnTr0aa5PX9/Ex/1ogxb0m9rjqHTHCprEKDmHiZzatCYFV1xDrWJY9hCXjyRO5jLUDZ3L5mnTbNhk++L2Owf7mdqnZeCancfKjjfN6Y1gjS1rhad7SEo0ZC2dZAVQO5k+e5vRFZfzKedv9qKP4CU7qB3JvnWPpmPncXCeJLuvj0C2tcMtV9UYaQ91dwaAu9nvuXGJ38+VeKIPbdFuH/UzSjK4JeXWTPnx4K7Ow35261GdrmktGxs6/vpKqRFe5brmlevyuEyeoj6f0Gn23Mq8ZjZcDtWbR/n7fWX7O3G0x1vi+LW4lZ4NVXXybyWTln7xIVhEW8ogulu41zqetMxvSUjdwY2RNjfIJRfurba9Y8AWVj3q9nl/s64aLm6loCWCz263kt9W+KRTfafs7c676vY8ZWCdS+bTGVhdVhANtC5LK9Mo4FA1Ctyzavsgw4X3LIaJj0pq1F32xMfH5W6F3mMCqrasZNRo9rAZb1Z4VvCpm2ezVhR7uhOpYGynQra8UuIyJXamdWwbx1p66I82q+9QCKQrjA3eqqwCmfkcUrtScCgDYR0BWl6TVhYstKsXzvS7hymYDFpmH3nkvVviJGwzppkaz1n/Iqy7P8FjO4LvRHjFo8NXgigpieKmRo5zf/bPmojeNTDS33/zTiIqKVICTuT+07iUvdCtvA1XdEmwv/XCajaLVb5qLWrJSfVbXGLTpSufQU94nqcaXFRP1dO/J6cLpPXzAnS+Pgyoq1RH9PH1rrbk24tjvbvrX24FkwuxVjvVFssx3tFfhZjatiMnOWh0bIsJ/at2BsYQgyt7U9u5oR2x7DtTSI7Tm9dq0ZqI3rT2CWaxe70kzFsF47mw1C/nIig9VeZKC7Hp/y5Pcb+6Fvrrqo79YWxGWbX5rDlYFt9vfMjyv+wKjcNoFbjm/Rylf3jNzLipQK4/zUV9c0wGi/a9Bkk8b8S+Ndj6tm0njzfjkjaw1ik65DcB8V2vOcfV+jXnMdItQOLs9ge5EFk6z0qJrFM5eoDPjJcbevfsnViBZ4fXufv9T+ddqwVCAUi9dKCCYszu8ivrN5+enL6EWtrLkuLGtvjKY/2sQrjC/t+DVGsjD6lohnizIUt9qaJ7iq2KjGvjEQ2NlZ7smaRcUCL1cMcR7tE+6lMJotGIGRqnTZZSz2vO6+cCVKgygVelxrAbfGvJqbjn4Bj1+yIlwXEIsgZP/RIkFBfQa+ZL3bxlVYtXNtnFv3tyyaz7me7zqVNawGjFQxbxLbXzQVdlmEAGXAaB5T+7PBO9fmUTGSXN0j1ItC1Qvbm5rfrZBOQ2DKB+V9kgNQW0GKoo6ujrne+BoxXJM4iYqWqgHKBbJ8OqhWZrSV/WOJd4yZqxUiy37zHBZjzStHhdhaVjHG0l0D9THfvP814LuF76Tnai+eIXVvoLOmPb7+YgU/RtQ3EBOVkdUHtSzjmnA+Zx3WSK9eRc77+pzGnmIQaCH4Xm3D/m1A50/zc26FHm42IiNa+eOr267bKONu5/gcVvULckhFdP9URv369bwW6wNtfytM8PPg4rnXMlZk9XxTCfOMMRgMgxZpvu3ftg6J9bXovGWknrxad6wvMb4bA27xD22rwzZdnq4yIMt5f+FqlBvWTovfr02rPVMb/T+TwfhTBJPnMDsrhmklNF7Z4829L4R/Ez4aertFobZwfauRbs7ckvptDulpPLRg+5qxyb9pha+b8dQSTnVkRfmzmM9m34s9W71X5lpGtZ6vZQKT31s+aEs5t7wavEpuIbRatqfWab+axOIeAex0WbYZ+O2/F66bVYxmfqfmnXSNbQtEiFjstT7PurgrY2nGWPOytWDX4J7q8GP7ONQK7epu4SMggk/Z3ee7nz7fopFmHXguV2VcJ0j9QCMYS5cPq7+Rp7nKC2zXgqFevJZWG4KiqKeyuM3Er3ID2k7D1JXMBJXCtTSQiVzFnJhw8QTeqK+tjbwmcCwlxxX7eYX3K8yTfUEAfPXZtmawvlrPTWPcF4Gi+d0C+AyUzATQiuRP8x9lAAsG+5oJsL62qsVnnr4aXzWLzWvD47x8WR3i9RGsYNGQVH5aCYE1n1cJpK0mY3HvalT4U4xrOZ+lWJYhiT/9+hrh52uup5B54wKVF3oFqP9uBlU2p/y50V37/rWr3nfdq439vo6gl4zTtTE8h2letkcyvtrauXx7iX827hE2xl8H3+d/ttuTc0JXBNhKe5+FE8t1WMFHfsmXqV2Zi63BJjOZ3yhrwri+P09pEEtfilGcOsBUiqOr31UM4HqM1xVKbZAn5/+1zJrRmNLvCuNlvLOB6Kp5fQmbP9tSt/F+piML2HtSCQI8cRbadPPSlq4x6XIXTns97QWzS5Vy6DojvFy/bQtAgZLFOeO6Tbf4GxvEeoNxJMKqpsJS8AC+tJX53aZdLvczHOntvCa0WJvMUFX7Yd8t5mftfhGOaLFuhBwLURjwjc/sp1OehnVYWaHsN/ih+o+S5KA+U20fPvNLxX1RnjC4hJNs4RJX4ylhcresDvlckOB03oCDLOjoJIrAoDca9LNlHbG4OGtvkS302RUyv0LQYJ5FSFCfUCIHp5JkQgRr1ilyBLbgQQBAzHMiXE+42gA+8WoShlAY0IwHxSDI+vEmUtpEFmtOdB00nWW2zfutEKMjYWQk/zXX8qBVLUIHXZjV+lppd+zdvJA6Fl4DYNP/Jsy371z51sZB9c7qGBrGsR5j9fO66Xd7vF/SgH3Vym+Ms4x2fei2cHyLBNbfNfN+xuAagt/cW4tDK63o4gXTujy1uVcF3NWLzxi7/bvobutcfslku3yv9FDWWKa3/n7b0lP62xrLVder3NH2o3KvPXMtgX4GA7axvltLntEO5dX+8kVArWyovxOoKm5+zb4sDu3qRDTv0MYbi3e1kSeFGFIFBWqGo237OTjDnq+V1LT5+6Yi4Vmwtb4qBWDT6JNMM7WU5ku9rBVS+YmitbJ+z5VJr61nzbIWvJ2HvdlO2+cWM4wVjnva3WjRh+EZXr+31IiXtapGU9FqZtOAPw1Xm9bq5f0rtGo1FqQvzp85NYJGYS43h7f4ruJ3Nsez5eaENQzWvIm9Y+xOJUfUCsVsHakac7i+rtcUTk+f78U5ZunEsOIGGc1zICPGXH2/deI2cKwpN3P6+nq89vuCga/RgDH/9SzWK2wftDzH9fOxAYeruQDX3NHW7dV/rxuyOS6D15+6ni1onO7ew3mPvhvQ9b0IGUkJgKUaTU6lQwfTD4hg3TIHeey1KTy/oy/EskGtVcwYcQaoFQbyQVYJeiu7zRZTH6EuPlnzVAKbaiSLMsKGMHHzxdPXswhV1dZKOuf6j+V3NnrSha8LcxVkv3V+2/tNZ/r3FfHVtBcbQoVOoIz2WXNvR/DU1cDGFfx7jYCZNoapStX3xc622n7ifbuuNt8SwK3+ChKrPWqvEN/qUX7/WczYlwm+tb1sbUWmNrKcLe88RxBfjwtogsqfyTxVwIfrUEUb61TwS+ZpKuBsprkx55q5Ke4dS2xSDe2KgLp6tT6az8LzawGgpavKkNg75lLFwPI0ktataJb060R77d9iD+p79caKIqvAQDuHdquuqa7W877+nvX7jLefEhbqfvM6kmaVNVvj9vldihmtDNfSAKM/9VUrK829t/5gvYrPv1r6ZzjP6MlSAdM+v3bPlNz5ZPAVReETY5JEe+v9v87gXz80Jmy071/pe4OHqG6AkYQNQplb7UpVW/KK1r8emX3tGtrAnAAqqeafc1nfnMRV6YuM5lP0uqKVxi+x4YCaR+aU98eE3fo/m6HxHGvFg9P1qHmKqsgvEZaKk3Y9luMGQHV2PaOP9bdbNGB9Od+B2bJvldbK2Nvx2CsVOihDpaoJFD6ynscX6e0zLtuL9tPrfASAIixu8H1ZtnkuDcZXCBr/7C//Cof9HrvdDgnA+XLB5/sH3N8/gGME0CHFWbJQKcPOgFg6srgp6QtLth2nBGZdkTPTMAVou9pNqgQMW4RmRexwEpySSWMYCstGyDUbAFgVZ86YzCGL8AYxgDI9DpJOrQq3aoij/HwO8ixAymUStbuWrVuDsKX/xtePsaQ60n/S78m+WyLdLRNv9dwQetaS21AXyCtrbKoWiNSsuQburyEu9n4Z8arbjNi3vtmyapn5sf1uY5yb7a2tHI1bggHbxjtyWUaHLWapDWTkSowE2vlsfVMSlW4nKKjnf02jtB5R+3ObbHuANoj/lf7t92vC4Ka1ybD1guPK2slrBIPXBKFoGGscI4wClrBGFcJeMFeL/IvrfvSd60Llxpivwk1FkL4kSG41VBF4UoameYuXX+saEVV3aL2paPdyc7zX5sP1vSWjiOYsbM1Q3qthwZ5t4wIdVNuPtle0oS1sLS2r1+DMkSsqnhUMbwKQotRFgOYTGsN8Fqv13s53pUfliop3y23lWl+FliWUjFi2Py1WKDQwVS0wrJqy1bW4Npb1tWR8Cl7lKqWpkCelbxWttDHWsQFASacszXPFj9SiQhnfk0KGXkl5jjKgChIrDXfTVoPfjYSvx2DvZnL/xJrlcwihAk95AxBJMcX6sF2lC8oDFKuSuusZW1fVP1muV46loOv4OvMM1Yyv4blyDtrXUd8nAowuV8JGw1c+Q8iw94gK6dm0RFXza4Zl1pDMb1ZMSzXuMhY7P5sjqT68PodakF2+dw1yrsFU6zL2FVIGvkLQ+Hz/gIfHk7hrgBFCxByimpAYzBFQcyCxg8Eg4OAq5j0LEBlLFAbahr5EmEsiRSCwlV8nAOzKFxn56N/KlzDVbdUHHJDCd6QvapYGrt7NCE4PfkZgDFCS+aIAHxPpYZMc9GT9cjuXBvmzDN7AJyYLGqJyv0IcCQClCHaAYxbXL22HcoESBljqmpiGjPWesFYLISovStG/ZctOrZFhQtI+7NCV9W5NhSb4UMVvN2tQr0PVf/VH1XoLBw6uvVMzSLU0aeO2nTCCQdTI661A4qr77fByrReD4zwxI2RVm/XAGviXlgCCc8U32dp2VacbTlOLCZeMKVyvgcK04VpUX7WIQgkH2fclwqfFhZxH3VzV3gIVcq00d1js+QLcQOQaQlDQ8IK5y2Oi0oaeEfm9PdsMhUlqNcplnsvaEeWMgdeZaMqYGrYA12JqDCmLhqis82pD8v5V/W8xfWSKkTL12nxej7K0vzbz183/f9l7t21JchxLDDCPzOpqtaTR/3/gPI+6q7orI9ygBxLAxoU0+onImpm1xMw47m7GC0jisgHSaFn+VltEiHk6G5xkS7sxab/0eS6n5w4cUlN1PMepesw8T1DPfLSimcNnDkxgLWyM6IEirNUN6tScEFgoOsvkxMJqQFycLyKJZ+sHkO7UskQwjrrD3j8lb2vfeFPn2+btCrIkZoi7LkjgF7U9gQ4ZL4sdAH++pNeKyLxmYT0KFmI6GkMvLQANebEYgJv/go0XwpV7IZlxDj1NyMG6YS7b+6P9EbBDY9VO1AaCCgtA3UhaDOSM6hdulZsIe87OdTcrRhiVX/OFvGIYZJ/iNrAoCR2/gkWPvKVkUdDmZDZl0mx4QnNeAObRbgTSI9ZYbpPSYLM5Plc0J5M3Rv0+/52/EIJ/dk2mzGRUUitYbvWE+ccVm1vnvglU2JbGOQHquCAFYLmIJdGujlIdWIrjaiPi9zToIcDjwQ5xwug4Xog5BNn2KB07Gn/7+99JVxrQs9Ee3be+nnFGDOYDaDzf2GtAWxEvDfOjQtULLCy5Fk6ZCsYAtasdQsGZt2/zpO+QdwjVi+S+7AoqJLbo/w31axID1uGenW1IRHRb32of9QUxWhfZeNoj22iPQvfFhgEjOjpWajSGnMKoqOGctJFFnhA5eH+DgZrtEdbjCMmVRhgip1O/FP5s5j5GyPAz5aM4rn76xOhTXH5t2l2AuVVjHqlLCplxa1NoxGiwbSfAMynwBXi11oW/cMhCFJhjbr2FNJRu8civ9SAOCeNnD/mleY62g5Sv1YCd6SO1Im54Yn+zQ+Cy7u55xyXip6AF5Qt8BQbHsNnK7LDzsm+B2Pewi/KHvhQbK9sqg21oV8PAgBRbtF/B6iKM7vzAqDSGziN0bGADTF/Ku0v+nAHycd5jviu/aqGvIQhT0SmuR50/LAjU1NtAFbXzPd0SPoBX4m8EvavCql/sLoBzHMPMj7aLIDmttYcaiLtpHMIybYjpDNtnAOWcRodN9bQwINryizr7EJA0CRah+NDzHCBBOz54KERx3ZCFvvF8qNYCjKAmxGjJchXHquNK35Zdy5Co7dCfyJUL46/30xzadxvnoEEbfl3ZDNfv2dEQPfQh4JQZRtA+ZhzAlE5kYru5cjTUVoplB3tG5MFjkRCUiw3boBS95+1Cm8sDWDDPyTO4lROKsyKgpRpemoUob10KzmSlLhYl6J/JyVgo6PA22nwd93CPFVOlug/SsaPxfr8DMUQ+6HcxAky6SlBeywMemirrUnYCHxI9A7omRoVAtf0ZCqjAypSQXx+PmtTrs6H4k7IyILIHoXn0T59K8qgTKE6ohUlohF8u7496xqYRL0JganSAIa4rPrm/Whf+hmvlE7/rMrRGfSZVwbEjy2MZlI6byFdNqAh8GB+ryVdUoiHNc6PX3DncQ9uRNzYvtVqMWqSE889q2EDqK0hxYxmcCTP4ZPw+8iwA4qIva/MGCg3l04xBzut0uDJBw+H0Wlnxr+jrOFl+wcc8SnQwYzDu0AQ0kGju+lzkgVPGZAST21G3uaQoGYK4pv3QEvYHPMr1jFnBqcJWfFhGp7RZ6oMURodx2yfWjbnZ7qXRsu9ZpsDXgBCNBp+0ldUoQN6sQ0vWpPs4fleAuGvNqjKenVKedE6Va23naSuBAF/CeE1rHvgVv4L8bKsPfXBg7hXCCp6ZAQl6wfuKyptcllV3Gh2qN8URkw2I1llXd6v0pG2/oL9vuQGIgW02lS156Ug751dSP3Prno9It027qbpJV9dw3HIFCBzxUBnToVHJxXpSOt3Cs0tZv6hdiVucVfPVVTq0QagniXDnyDAYY4zWxw/Z/OVgC9jDtpwCanQQgbYOsXR1dN/zNdWBlwakCv+cz0ldXV7mpM6C1Z0GNen49WVW9cVnoNpgk84TTa2EsG1O5AhsHyojSOenTulqLBFwz/ibjxkdsnobw+M+VXMPWjCm+ThWtqLJvumDQpNRQGFKPvJM7wXdLkRzCbo6GtlIV0YKEc5pWoVosZtCV2luEprPqBhzytx2NYX6nhGjrhYQRG9H+z+VixCJvIlBeNBOnKV3+OV6do4rADe0y84ibMZbt310UxqX8HQrXkxlbi7ME+lxIvDeQkiy8Innx3bzio2AUKzUQ1TuumyKcqNjM5rNL4HEdlFpxH/JQJTuBfRiIDYq1LiX+iJc5h29chucjanVAtfRG8kO/EXokHb9Vb2xR1gX5Q0YLgpx5TKue9BsnwtP+Lhg7sRTLc5XY1uP1AxL96xtL/ZMN30uRiGs2mkAyM5MjPySWCK3KWqAgL4sZ/qsQKwu5Um/x/yNCLHCE1zL9Db8xKtE6RaImEymyVdDrwARaU2jGK7YST2s274q31UndPZLQaYFfjTfbTTKlANXkM5EBVzYcbRJBy50Q9BPQoP3Uffpdh3V3cG5iNcYy+lf0Ol5WHRDQbg2eVvHMchcof+uNNnbw2+fuTIf0ynojGywxy6HQd/VUvYCXL0XdUFtIlxt1Jna4dEn1N1QDG1KMz6tjkjlc9+4yRtWvTFjm6KcRuxU69072ZFOv3BWRlvNjp0B4YeyyzpFCl/gOsFzn/ptWs/3PNX2S449HaWRvL0J0dB+3nTHwNIBVqf7C04G0RfeDN6npAjE4fhFEaiBqg1Jl3glMWS3h55mHcUgBmFKEEgVnjqDjdzpTfRKvQ1OkSKoW6tL3pip2CvuBPStCG8a0/t2WkS3ejgA8sgZVJ9WngPE07dJzojQe9VdqHTH0FbWvAfdEveajhB7Pbfuxk5oLACYHHPuHqhSq7gkK8xFnPoIeKUMWO1g3Ym8T+vxkjBRWRfECMNsvLnP+CfIFpLN8XvrJOcnnlI94jlwCD0aOc9yJ3yIsktsDWRnJDc6DMdc8pbMDbMvjNcPlJvZQB4H4K0zpHHqx7+7dhLZQpNRV1fG1W4LUJZxbLtC8MyviXvlzBx0AGyfoBW1/nPMBdDAMHDR9fAtKbOmFF2l/LubqzIQK7pdFuzvRH1BK+V5kMn33TRD+VBnW5deTQCisSsZSKruVCBk3WYQrmBqbxh7XRUFABHA4XBi8jNygWY9sEDgmv24Frq6JpEove6I9cn7u1jxy06eeLkA7KzgHEn2vqP9LKq3gL01UN3Li1PfOc/alyC9c3UgN5mj6SFgK0IZvPuqdbVnuSx28cmZQTqedGBxcKySXCmthrjWM2UP6dGUjrGAPKm+rhEhCMacg+gccCx0NaY4l83X8kpIDJQUsvHPsh3VGyYajR3L2LxvjIytrSR/hpjOHY3LB7cImr2sKQOGlE2VT14lAIX6GdzLCTVw1shNHieAEChF5YrXHoQMVOv4Nt0kfSEM8zCwgCpYJG8SIrETPQJyC7R0y+1efh7lJmM50COKs5tJiB+BhoZlTBh0rPyhao0sqWdcERPUFS4g3Z3C23BFAAW13ti4ClTMC6b8OD1tk9gpgHg/KizO84oyJUThAfVl/dEDbfvXsLuImEMsRHO3m0yHcjiWuVedSeHcN+5G4z1zgsILlJ7Nh7OSjhFT2Kan+UxBSiXog6k/X0af8sa4ZUab45IvfgcoK1dilbst6RZpyulSb/xswkCKU9KbqCoHY5W7MbTS/QA9CTX4NwcI+rtqFP0ZedKzgDwJrcsjPWVVA79ma4x5MDqZdcDkSQU9uhqH3ieArQKIjGWmW2G2b9RhpHW6lPUaBhKwfl1xUN0et8l0AX8EYmfQLdRotqVN2g/muVuhsw+cPpv5z/kHsEnqIc51APbz44I8uk0rO9lOTtJuzGSru19M50GCmDq9/KzbwAlcAGaidJBJF62ffL6cjQc6ygreY8LGepxQsOpJtYu0WASrVCUnMgcB+kLaSF9PWbWT/snRSnO/gtxATy3wEd8eOxp58t3o4tKdgwslsiOlY/C89HdKU/bSgjJnzBsvxWUjpXk/eAqiVzly9NEP1OVyb9w3SsNYMRG9cQXmYNUhJgUk42mHErgDW7Fi0nodl7jjsqUashFV53l4l1j+4kl/8KKXtZuNysq3wEgqI9RtP9AM/pZP0WdrUlpGjSjPhzhIEi8b8ikYmMuQQ3assgI7Neor8U9Ndi9FjQkwVlZMzfzE/qDDsnh4LIiY0pobZMUFgV4p7YXWzjW95B9TJ0CEqI3gpN+WGPWK/muOaxQdXy2vp/9EvZMNx5Oz0s9BedJtm9T5X+vGh7KQwtJ+6nvXDeOncDNm3Er/jkbpVmD2DzYif1v7Fp3V/kxZJOW9jtclzF0d0+QEBbdlN+7tIC5z5/5k4Bur0LnQDEP3jJTeKG7HvmK/4jbAMTTxaNocz8PxaW3eB7x4Ej33arjcc9r3dVr0V7cIdoAr2YFwT+27RoUTiFZ5sKkKqxLYl2pbsvyV7S4bujBlngHLUlchbOmnaC9SvOelG2w4y3ZpsGJimg2tQKXdqzr8xDmJtUWaogMoSuKCnid6z1KVA0nz4WMFbenfRXfbLXJfTFGDxzkn+qzfHzgaeua/MpuOAZO9yxWB0WbiV3euZnnvaa9dvuadH0fwhQD6kqRxFN4AyrsH2EZF0rSvijhp3ZKnVQwg0LoPTvfMs75oZv4zRWbj5NVcZlBonjp4jWMUOb66z4/82+1z7NyiNWP5w+tap9Y/lbDQeFCO8xjjfkYF3wmV6tnmaFRYTKgY9j4HPxNINpKs/13qN9xof0z/thxBQJ9HAYdOSJbnlhnIEpI7PoDolXYP2KXnZUKfajJwEAqgglDEOIhtybhvA/7dQ38+Ek4bLgPzNLBqfMS8556XTEyBxMJ3NhFsRj4+pwRKG/5O4kK1nTL3SUciEv/vdKw0Pw1s8BzrqCdax4eJMMLPs57StEz5UD4bqAke3Fs85wV/vZ6mL80qpPerrdrrMhn1UgIFV2GbDHSXJN6VAAQ6UyOVOhSkskaVQ7uT9OK0C+krEtTGNccWzKYr7aWvM5/JRurfdaX37DRjfb+BTycfqSQqKHu9XgTDT+GZxEpk/IlA2DLEww20LWuiOHZm3aBFzBOdt32COeFhH3MgQWU6Pjs5+8BUTynSe+ZI14HOW5aQHHiSxIbvjoU9iJii2MEhXLSp7eZru/xIX/069NkqgGbXAE+kqvr2Nd+dMVRsayKDbduWd7Fq8ckWrl2wAdsPdWa9csKaD3lXNBedjzQ91NP1DbGK6TBh50NRvZhb2DwXp6YFIMAn/tUHz2iggOjnQvhI7VMj0Ok3TnIG4U/7Am+qTGqRFAU4JfqTTjMo4J/LCH7CY6Fvh/nGwUyR2Y3G+ZkfuDfaFobBsO3FFCwYWpyHuvx6mts8fg3drkQBzjA00rTFDPkhny4rBgLtPSX9uKgx8SjBfj66l2PFSK5BYCiU80znAXluGvYeZIiBzqLs7jv0t0ZyqX0QM5DHAJXafEnBSXI8zQjqA7vr00V2dbv9nhruInMQkFbHIA+SYxV6W5m9V/vQwxiGweExWfd8XV+mbcoiencBKrkX6pvMZrUBwOCcAH3edY2cY1/0yPBuKPQinv7C1APdmqKZec6zrGiVQsSuVtEfzjDvJNnq0tMzpQo6nZzsdAgx3xYQsXJcu+lyCg5jS/yG3lJXT1dut9Rj+tYfpkc93NGNPFrriTpItbYVETiuOqlitfWtHrNeS6yL8V6lG+14bCmXq45GzBEqjXQvbeoHzy2p8OrnZZ1ss+fLTw7Gij6k877vgGFs7BZd0Dk86qMLqn1R07VanXpatbpnROtJjXifQPcljDgbats/TZ9E5n2MyWgqwXHLsG4LUJHXfXHgew+IPDhiTR9CnGf+jnSpzQulen1MYKPQfH4wbh8/DL6dRO6GL5bbeZaowVZK8xMauyVmBb+KG7qlpk7JtcvVpU39N8WRmQhPg4H8An9plp3quLRRxmzV8ZJHvG6evw1NJIXIyRcxnK9ftNVpbgIRHPMrZmT2aMYkxZScbYou5nzWc8WqA5uMe7et+hiGcwNZNSSgkhjBdMOaG6KAvhqdGyJVboQZpDKPFQ7y+H4B+LS603E6rUGSxtmwthwU6cQGXG0VQF+ApuxkjT7pg/9eJoJt/wzOBfZ+GkCx8dHrQP6BAlO59SdHnMd7MJn6TmGo5p/x8s0A7JnGS5MYt9ZEmTCaseOzvEhszCKunTaQCfj0/UAXlzkxvVTUFqwkCoyK8eLK8LkTyc18+Ph538L82t8PdbXVMcp2APBrWxJiHYNe18tGO9y/73o4hVKG9WW6RJI7O+dqPb8mZBXYJ5vV265qpxBcdmDdAz6dWMVx8XnwT+VjJjIZMMebpi5OzkV1NnbziXa20q+fpsvsuvPicWodQ71V7+yutQAw2CjYurghqQ0gmbzFfPiZ6+hozGZhzOGellxHk6vyWW4r46dkC4YOfH702gM08L1pO1/r5uhp3IYs161+pX9qUgkvIDFqTvzRgqfUOd1us8QbJaI2aNn0BWoL+brVE+9J0GZlHHFnxqe6+fx42w3wdkJBICCPLwFH5VkEDL5r+U7JmsJeMM8qsuLKavxzb+9d6sj0rZyeUL+9TZsMeOB+1tjZpDhNjka7V3fOqVNOIXrS1h8LqYHFPfRqMFyIrVNQAZwgo9dDmQi6yglCPGuwwwTEFE0xLB3cBwl3u4Xz4o/SO/lMNF++hMbOehXmUgFhNVxu/hrlZn1NBmDOG2udPLceEUYptN2LrjSHBhH1qMXG2BRauDMuoGyyrNmURWPIcG+07SdjDWdsKj0lEYCK0xojlx3tcndLtAHZln6GPivo5zhv13W57MPc32l1COnxMZDZ7k22IcbEUohusd7qvBceRgUv4v0A+RbTC1DM5toRoTDw2e1HCxrPLYZInTiZhIyVo553Ik88AC3O86zXNd9XV7vyUbRN24TzHOdtrecdzLO+PDbYppQPZIJEbAx30VpsX1eOtQVObBFAVnIOOqCY8+F1vKY8n1O0vdmGJp1FQ49GMnS7VtKC/jP0oWt79TtRuqQpl8/AzR3eRXtJd0q+D/dqOz0Nq9/WHDiTjysTD/W5UAjRZoyfxn+09ZxnOU9Jn1Aja7kvpa4O68F4d06BiK/WGA/fEnivooivpYGF7npNv2u/wPF+Sp3erbhXTPe2WJfmgTew4iokW95ij+KQ2u6s37cWVtLzopIcsEbmn9Kxo3GLjO09zJFpkkYVisYgJI7sngfdFGxTNyp9NeRv2Av45BisANtK6WQFet+rff1eLtBgABIRw4o+3P+v6QoMyGrYCMfhfLI7xrJrSaACbdKX5Tw3zXVsxPVv7Hcu0wlbvMZWad7uZHiR6kk4OM1ucPDt570h39GV7xE5n3QzU+pmf8bA6oLIhefto5UdEHSQP2oZjtiD0xwUZ+Tz0MaDDOTUzesqxUdTd/MP4JTcAJL42GdDJyRljB3gqgPhByhUDkWuQyoj8DHanHBi0q0CSW8WxzCmGQOg+77N0biuK4yFG2EtM97NYypn+iOoO1bz8H6/q2HN/WrK3jYnd+BJ1J8VeKDGwD4/8wvywGSUcD1/x7ruYC/ilLBeXNSR+5RpdCCmNDkEWoHx4Pws9E1Hg/+giUFjHXmuVO9W53oHWMcBBFGOQgfmx72kHYMAK/u7SztwH52MBa/AHdnle3BquzxtenAGog6qEoABx6GzQd+aXu95e5VsngFghMj1xt6WumjaVgH6G5t563OHUF/u76ltuC49Xn3dt/1zXmvdlWXgiS0Lny/yed+zngM5Fc9BYIvaNoF1Hbs47d0zR5p76P1uN806NRTPtubXE1lI6XxFg7y/lRAgsBGEEDFK9fZeXFUfeI25f2bB6tKGAECN7FfIu4qmjVIzr0biN/vT9Yi70a6kMRhgxEHyGozrD3toOtQ7rdjqnPeDNA5X2RTu+CdlL8aVCPrLpG+Ej8IWGxlROKZOeeI4tSSi8jUF5A+KM3NRPBZ9TIRL/RHKZKDUKQPkI0zKn/kEmgDGyJX+kyFbGQIRMUAZ+4ER17XB1rwX1TYKYLh8G+BstgVQo/wGTAIYLw76gsZgNGbNwh5hIoY9rXRP56Kji0dvgV86vbWio4IPOLSBCMYc8orrhOyarGZd5Kb77e2Mf/XldnUu355HtG3LvDYycI8zCseamVSRUNzRG3VrrPrM0egAXgcQ3FGPelmdj+uABr7Q9ugCogpSL2s78O/YYa7WmRHqaEebU1f3lsBLbUC4lu5L12pt320R6lyTrPTbaa0rX7sDRfo5RVpkMU5PKbYZ20D+iDRQuL/S5btrK2AeSylP1pfOajL80o4Pj+2aMwAZAlkL3lzRnMditLkkq01+2IlveBrBT1W9CYCv6CLV22oXZ7VPuh++X0keP7Gbj/fsoIfnbV27QEjUz3rwzug9zoetZJOUctpGwFFM4SRKUVAtGzlDO5yhVYI+vvsGeAwKCMl8drTt+jZ99IxGFxF5Sg4QaAzUgspVNKbLx8xjX3ta0aiZCcZsAfJJB7g3fidptW+u5FswAwc6iRhWM7BcLns2D1/0Sg6Sku2R4dO2sgHLKUvEvJoiEO5h3yV/jmIuYOQhvRtKg4M8QX+6xov8fvrX521G4FQBSHT0znnzJI8Ck+is94B8HaXZt/d6vaw8/nu/3yTvYW5fv7/o9e316Ay83+9wj8mbZ2Z62faSr/KDl7MVrYUDinmEqARMjG/fbxK66fXy/v348ab7ftPr9ZrOOtH3799dJ16X3fP6rrGrJznOOXWR9Uz765vOCSlaCEaqc4B651XovisIy1H+PG9EFPrW9SXr0tiutkEBwDEzjReD+1bBPCYWMDu0e+B5lD78mUnpj3TmeRH6bKvbZ+l4jP4np05Gdzb1c9vbt3eeUrAkAWARKfLwKT2f0AahiG1dWN8KFwg49P8MufgkmeVs9Pdu5Wc9fo0NDva5b6/7nRNv220oSaRUl+5hLjoFe5DOHQ3maVsGSNgxh3W8yYN7j0nW3nDH+PasByVP2qpgj3B6E0RMdEHEUaM6PE8uUuN35mp4NEijX15Omnkyajdjpg80317HAoz5XtqxtMqNQcutWxt4sgpEFZKpDs1yvDVp4KhyRijZovcuQ864FxHRfOjyLsOAwEhpOGBmpeciaHd8viXvXRbaHsPRXQbH8AlkqAEvsRB8+i49AD94OLeVX9/YKBoFQ1udMCMooa5FthJnJ387PcjGiHonJ4o1yuWbE2LU1E8GYyvnHdd6I02+YnnNoII6Hp5l5LmRJlAHHr0k+u36jUTmO+x5yD2qKGay7UXWM7h/Q5slWYRpvqP2AoOMRKiMMBxTIFLgnrfxzfs5HZPXJST0Dluofv/996grJa6sCNFYiWJy3Xjhfnu0Og9A406OtBARRMEk6fNqlHVVhqdjMtqPEWfXpnnOj5zh2aW41sIWBLBH+u8pP+y2TLcZumjpNsjqhPkcI43ivIfC7aNQxqMXYudnwGMxh41FOnXJG/B8rNoAM8RtOdK86JKIFifbqf3keA1fOKYOTdEvd5rHPCaYxpvINSobdIUFDNZALVDcONKYfz7mHqdNvP5L+8CxbIcZjN/m53ZVbn5PKGhef35/Tt4+uWpj17b25zSpXhnqJI4A6ivLb2OgdmAfkjxxPNAeo6/lK9x+ZdSZX4wYceKwAXPcrV/PNHTXevonPwiOxUkbaj+jpUAbF2idL4k1bNo1UaHFtj+h3S86hR84Gt7wEi53TMvxPvvogB3uhR/rWjkgQWVNQxIHXgU5ifJUgMzfaDwMznB93TdVqN63/DB1ivCmPm4F2oemGP2i1MPnylwFNyP99mRHwUq+43nzVpTQjoEtSLeDB3SGUN2ENh4YeBlJCPyFBbbVxboOBOywttKwn9o1iWIKzkddNi6UUDu7GSTm23q/ec+AJXjGJediaqLt12XORpBlcp61EiGi3cz4ocLKQMKLg7Ob60IwjCCfiMYhAcCzos7Mi4jfdk1ZFke/jWAFpyrxunuRob+nvDX0iA6ljuE1AR0RPhfhtA2KQxTe2vUvWiXq4BVV2aC7fsM+1SlVGlz3vccJT1C2yv0Y9VW08CtyeUt+bgr1nczX+jgQKU5AACQOIuGi12rsvtIpaGdWMpD06UZUOgDd5mcuKgPHFE+UKaSU6/rsF/K4PphrDEX5ZakuihDt7uhP3VBnySpB0jZy9YgdMJBEEQAjkB087G1incvVD4LAbNN212/39SqP6BzZbpkTp3sBevfBgNo/Bv6+xWUnmNsH+cxbhNGH6oLKYezHl1Uvez8Y+uH8kzFVX+NeNp+TNIePNK2QPYO7aAvNRyeIQXeXce9QFvxmr7GbsQ4XjXbiKwVO9fHHx9u6JAJB1DCsThZiYjXKAlXkSTWh1+v+JlM2AAGnIKklTsy178D4p/n0/d09c12JlTuFPCMX2kWgwadbgFdgy5feswiN5k5Cz6gEqUp621PvVVbKOaf/7e9ZhCqwJvTL7jn1KttuIzoww6QvdFoqqaXyuufQWWsO9DQKlhy+XIM7zmuD9ZR8rhtwwT7HeGRvbWKpEmbdVJRXG4Gw0oNPWZlqQbO1A8pqt6qI9x1oV/oUKgXw4UrjgXd1ZdLLM9JhIBoNYVSZBhpEfymtecVoUDnhrYNy+PSV00iXeSN22tw9nXYzq2GslC13hsxWfMWfORlbO/1Bd5RXm2cds3Y4c1tSv7XkBCiRqoyyLEob2gG8L2M1w8/8r1s+Mk/edjrZSi+EX22ekqOwXjbedSB6ndW18KBfg9wnmbD2iUQUhUWejrId5WGo4Ci/cTlC781f0j8bVSg3cFFpHfUUY14dtVIf2opcX25GFqsqQ3e/Ln8m8DTauga1B7rfurvO122lXtuwNddggCHvEsl9/nRF4qt5zDYEPq66IdTV1Qc/OyelRNJXhAb+3NBwMj6iNg1aNXlJ+PbjpIytOy3WAXufc1TdODaeMzisEjOgPb8mEFNkNuwaaBnxHSGdXuB5OASnMTkdiw/eDN4ojSaPTVSIZEEMCDEqIRhHBYlbF9AgZQauYBujJVhnXmrO13Xgc5K2p7njqDYROPskGi2N5xmWFY0uhL+M2VvgGOnx/KjOw4rGBGc5Mtn1NExZUKItLCNlSysv+ABvNTCoUD9L+z2UHX/EPHFPtqZPokDldzeATITH0+Vy3IxJW9EDG4bawTGt4AoLBG0Wm0P5bZQKgptCorF6Bh+DR8yFWPRJN+JZQ13b1qI7Hm0nRfnOj/qM8q/v44j6CDxkuJ6d5Th3bkLmuCLdjW5sKZ6ksFzk+uRF5cWJc0xtpsX7062qRpqblGiKBieOV80/51V52nM1QGLHyM/AqaPrI/2B+lGig9Yazw9whatyLITPMzWVApgIuH3VOIKK4tyjzWDI4jYp5HrgRc2DtC11k0Ab3Mn3Wt/F+U5OaNhv7fXUch3dn4HwrjzRYtssd3mdvI4zM02OebBig38h71dSaeeDMm3qRGNhG0PfQiDrmJRH2lDPrPI9AWJ0lkewZNLeit6ab5dtAMZEKyK0npus66PTEds23SL1nnYsQKygtuNmaNThmTbXX6tRX6dzR4Oyslnks0iXKpO6n6+AZ/2dBkcV9JomN+o8/1Mlr5i+CDIj0KEJwjjVaZ1pIHjcvx1K2bJiAhcAiMsSqqOZ0HVbRlWlLQ5A8jyHEZrjry9zY5JwtF0cC2pTnuKhJ+aLmVho7CzH7QhGaKlSiMJjCroFqzNAq7RSlmyD0RuUXsHkQaAwnggGELyeKnvOtCgf5oagxOox+hw1kwS4V4a0NeSzlbKE7YVCm5pXkpHlBCYD2zbakFW+1LGF9UMyeRUi4yl/bkqjNOafJydSwhZGisMLVSNd8eki8R7nMbwGzaq87W7I1+xTJ0p6gUE54wkku8TqjxCGnXAb3piHQFmgYdDR8Qfr/4/JZnmCSATBPL/EPehzSx0RTFrsla7Ohnq09CaiSSVflqXOaUWbFZVeBIZCfoQOyGuYx1GH1xIojz2Zc+ayNL9DpaG0dYXtRaZ5bErPGOppIpAqOJzHyeaMQnm/1/UY+ZrJHAHQcWz9U1m9J11Obz92sarQRyQ6lFVjqLpM24hdrY04LaMc1gsNNmOZVxQofkQkKDjfMP+FGCac6ZBjMiHPuRJrDHSZ8tmjbcq2IN5ZrTZ0qza6vyPzSbeqhMEAswNEI3CivCbKp5FO52/nRKMK6k0mURsudEd6uptU5xiwHpav/DPm0IMwUfcJkTsBGoQmZLeERWDcb9H+ji2zwHDQVRhPiuXjzpqu7G5ckD/HSY4MYG67ip7SB44GAqZ0L0VF1AgqMPKI220G1Ei0ztZ9bSOS2jsbkQ1fNc+0Z3Y9PFcYFa8dT5smPE7RFLBstCftygwdGB7QQnwQJY+ZbwOJA0DEdBe5CVvT4ENg/6Sy82ByCWNrUEf0IXnc0tOxZFbKYGwsF5N1keLu3HEs6mQIAyx1Xp8Upioyi5CaBtYtUArQYOY6o9Ic0ZgVGEbgNaLvJ3yst3247YXfYCjwGNSiQwNFN8yrZkjtAv8U8238NCXl8gCAA28U6BuUIPALM/F1eTbJS75zxu/+2Y3RngIvHQR9CzUcRyDjun6yPeOjkh7dsXuSqKo9BA5ydNHkRchBGUqI/lw5Av724zHOeMRflgsdE9Vf/htf3okALIwma5DE50iLiWAwBWib9V9XPbSAmeOzOIcOMwKqoT9uY+JsXnAVBZ3cDqZYmdzOqIiI8jYdB1VZ93ZOHqa4Wuv5GY05E/HrmqeS33bkJAWHKM5rpC7SK9pP0M+B6lJVvBBbiMcZd7Z3djToPU/pVEYT67T6p0DGvjuhF2Ps9XKbbToc5Wd+mfNoY8R+cppQfzQ9yp3h9amewnzBHvF8z4Agmnfxdwl5OSahK42njrcE7g7bJkFvtKGhJHsCzylmaTDOEIXuTPm13Wbepp6GmrFJ8nGL9sDU+9R/eWWR2Q/yiMnCtpBvfr8k9FP5Yb9qoOFgbX/8YZ3gsHsjk6N9R/2ufdfT+yK2wfKqT/Ppkxcymcw+Ns8s5jHDscv6pGBDBWKM/ILb3fIo5femMDHpiahEhnCmOZP0Ut9wKA7HeQsvs10kw5VRBZDJtHVnbH39ZJXso/doNCGjZXIBxauvoCh837Eb5vFJkMff8JxBzA2gx/ZFWkSt6UM2wJDPgCHRsnwol665gdV/OisRmDFzedFcVzdS0+Xu2AWFEWqd5Ewmy8ytRqEwV2qLaSjsrARaujy6KLONEYEeDpnczvhtdOmUzxBHQB1u82p/S2IeD2814zLm9aLVMyR5mx6WW5LcCfpURKEuznlPHDM3DzrW1gdyRVZBW0coOevQNPpNGTMRTPTqQHpx3l6hpGlFbdM8EnbjKr71DkpGOmpYyzL7rWbv6UD1c45Rfj9JaKwRMPX1nIL9p3zd0ZZBhzBn7HLeMwxO2Ly9AWB+jeZCR8PDaIx/Jh3xuaV7gigi0uDWgyOz0s8lMORGJqlml4EAIpHZKYKbQsHmXiG1oS1mwHkdv4Ovpp0wfudQHt/zYmEBA2GBjJLYM6MCD2yYa1CwFVbVDqZbHQaTWLBBK3752e1LeXoE+kjw1XGJQV3TgSVZpWWSSGXIVqZL8W5sc/UApu1iHC/81O9d8AQ/Bw6ZvCIc3g2SyxgUbOhEIJ1uxPGSZ/lYtdOt1FiZOa81QBxxx2XOgc6Fy2xn8wOeTAocaXH9prKKdiim4WihLfZ+u+zc07kHG4a66yLA2FmZ7dPnD4O36bzFPgrVDc5ZnaHkZ31fN/lFnXLqEvRLbyrYAzxs30S+QFzrhay1gRrfMXKW8342ouuhYxqR4RvwS637I4DxQGrZ2muZ8tVXo3C754TWgvwzhqjlGo32AD37FLckBiWUjq4cp6ztWp/XcQAT+Cm5ladbL2B32EJO2m/OV5Eyi/Z51K+p5zRlw/Qnp88A8P9i6QnPngLfdQ0f5tu3cz7Wv2Y+sKlGpbQ3h2hlff/r+IPLr67uTrcl76Doowek2te2SFFDGPAjIgq60HNEd2HefdBTTktFlb9CJnt+iw5ZT9ACTa+KmV4WGKz8wrV1fRzydTfP5CuQ+OH4+fz9fFBh2cbCm/pVrWZwz2uDdFZXYJWmIpnXSyB/jU0wxUACfmpznITQSs5LOGvnI/jx8bYlyfrmasx9K1X07DRd8wVaXYQBvb8CLHGiJObPbQTPkGB5uMOh1p+10WLmeZSo78mW5r0NyuA1spr692H7lie19VRnO77MbUV5RWTo9J1lbeib7wFRrz3PycjTG4C6LQ3UYee00MNDt5pveuo6L7rlIiyVG73PfWzb2kYlkZrnOizlyBLFDQEjKuv32jpihTFIhtca+nWsbGyo4WN2BzYrprwVjogJz35QfssYA6Mp2OanqWyxind3BYkIaQ+c+HnbX0zdXK54ZN58LO/F3Pnq8PHT6lobBTzScf31Tl+2drjh047WEom0kLvbHQ80zO0LacV5rbOz4fMft9Hnkvqz0XJrdcdTgvzZ6aC+nmBvVUfabyxX9XgOGKz0NUZlu7whZU+ildvalzDGC+C5Sp/OD0bBJYx7J0kH9T3QN9ThBvYl1cSqv5zgIzrGboSHlyQf3LM2n5yrLTvDHF/5nVmQT/8K/lbWfOa3Z+wUMYKI0MX5CHUZ7y7a4EqlItpp0MGqN+Cv90PpWdMfF2jTLoxiu1BmMtGNnB+kD1Y08jGvCdM7polKnshBPOXBWBmDHiBmI7LayoL5V3nx2nujuIJiDJMdGnahAfAFDYXsN0XmSZUtVhYq3bDDfQI6bE5FRxexRwZmMpUkHa21tdG9W00BzvoZowUhNidsMjjcxKVEezljN5/ZjtOaJ/Ce3hf4jkRGGolWS4Tqi/m441zfVaEkQGN8ikYIjIBId/Rds0zcACWZ74LQF7dBzymPWjvvuZHZWVTMncPrzs6q/k5BTc2wOU+cE39YTYg0D/UdJ0dqpYsijURE76DR+7F4frnWSXLHbRB56oRCDfBNmbR/e3An9SgbbWCD+/sRUFG69gH1cJZpwJQixaoyMwD3zplYBWYaXpSpu003Ky1EzPpiVNU/DNXM7SnBNuhW0diWJx4vL0U1717NcmwKzQfXGRXVBynWpc8u6Sfet9dZNi34iTmBHgIZMvvzSRDHBy4/b4daTtklHn9qT2Razt1Bo6v06KQ3353u5qFpRpqQv7p65q1bsi+XiLxDL7uMrVNpbcDTljLttezx10mK+Ma/19Vw2OJTaMNcsWfKW7sHlYdoituEPQTyDMBvGnj0/txGgEqDPY90yNwdbgwBt3Y8Kp6Mum9gqvtu5mtCD8E+Brc12fDs6B+mj94MvtKZMVvjJCiTUq+O9s2eG66jqNphysBpGymbYCxH/CnUsKcV8ztw8fLVaMIDWe3cqwG8jUPzsp7OVRljiSLKzE0bCAjqGAfDm4Ai3jdK2yjQIoGBOgEzHwGeDCiBbnNSbBgbg5GEXUcpjFDKhzmYXYFRyrHqVwA/qYQah1UtOIZLSdF+P4y54apDkcsPIkZaHSSVrqVAxifJn8WKcxDB0Jri1Xa/PvqzT3u+jGMT2juow7RXrxzMOFau2dPkeLhzMgZ1n2wN61dGmFC/wXb1ODcw5p2uf45GBqrNiPrYLWgm5039DTWTQtct0IFggsQbpKuDTzTv7lWAe1buKan+G1FbSXLTAVDnP9UhmSoDbEv6ZXE9ym12dvU9S+O76kpqhmM/Bp/wc6Qj1gG/Qt5+ZTXp5Dy2yX52NHjg91ktP2KrgzHCup6CvJz4xuhriGzL0+wTBp+sDjYnQgOBK8Bvz/amAYoRf2/Ag0A+d7giEWiEvN1Y5O/C/l4ws+lZLoq2yXasn6frWjiHoIWc9XAwqhwGzHCIr88fBi8gE3496bTp4YmApWgUFCokjS2FOzpZMHnl7cUL+pdeOFXPV9JnvCnO4EHJ3aSn62Rvsvaz1l+MTlNef3sX8j22ikLAV8bDrq6kMhVrurQ8qedvSMOp7pVYA3CiHZh0upDnMdX7FVB7FAyVU57j1gFKdXcp17OK3u8U6aoPT/m29wnYoskalT0R4Zwn4Fr7GOVYQLuuxnUFBnpuQMAhVLnsPK2UdaUj80HeFreq47x9Tae8cF5/3d4Tom+rZlDwR220sN72gdN46sLtAyXbopuph4f+h5J1ffvQftAdwbak4TBWSIM4FUmybFa31Y+oY34Vyvzdpz7Q4n10ejdC/oWUHfht1erkgLIpcs46To7a8SCWlc+d2TYGloDz8jjNSj8F/H1azs621M+03QVfUZfmlXXjM458ZrS32GnekPj1mYOUDnwuNPI9Bl1X9X3s6AdhBblZ9g2pJeBBZVN8hJmi85J4q9pz+IHyt1ZxS/q0Em3/6vqwwBMyj1JE52QsxrHJQFy1WDTfUTRfxT5wYCzvcU/UX7iKaZQSnkH3SXDtg61ToFRKD33JyEjNgJEU1OtbdKv2dyPqR3SF0Tgi0/NvgZt49W3NyUK1NQEQ1VWIbuVhVJdOLwCGLhEsKV+WgDFkC0CxPlyoUbQ8lB3oCrPDY+ZKG9BsnZ6L+lFTEBXRDbIsnqazXZWytyf3QreKugrcT116NChLJaFzuSmD890rvHW7OsZMFBztXN7qVcfNwHWt2/NrCz1Yfo7QoQLs5wqdi3j4wMKgQFTMgNzRePX9jPfiVqJPQETHTyflc/4vJ7WBizkRov6B/KYOlcUaRGLyF679OQ+uG4mN7tEgQqcHMWWyuHPAxDMOPZZXC6X8tbzp7eUMRfJ86jlLc0ShH31ynaUllK+w3M87GhjZBvKBkF6PGI1GLz6DBffTGAkR0VXlC5pbpqWzropvU663E15fDmbWOoj8rc3rdvTN9kjvLp3aktB32ErqcCbbF45jImQ2egwXp3vRdiRKZjnFDFeZi080wFMgjjnS/rPaRXnQVnCwzQnw4uqD2JhYFhh3qJhIUjCTkI8y5f4i1VWf0PZXZ3Oe6jkPYXG81ulI66jVsWrPxwjKkgANzs+KFWylByZKSGm6gaZf7mh4Wi334UMleYBiVHFR76g85O+jQJ6/M4SDMTbLO2KlgSGh/EpxYTv41UCRHxnnWaWvL5WPCYD9R0mKFcnPGPQ6u47rsoV28uJ8d0wfMQAKTpOvNIFMbUjLvu8j7evUKsAm6fXtSWBG03latbcCkSFKw33eviwUaNtKRmU1LiiLTXTNfm6crtz201x5ng5BfjV5nx8an184BCRaIEQUxifAGkl8DUarjTZjBamdp17rXH/qCNW2xp+nUlhtNEkUx8N0YubXrk40wKPMzg6EmMWHgYJAch7zRi9n+vw3N3OG5XtnumTlyvOtQ9UUXF1HmWwqWMhhP04nMtvq/6bNOhduiwOggrF9jEinNpHeLuDjnxls9XVp+ZxvFSzBz3yvow3rK/J0nBa6PuuahUxa7gajdFjmK4ETdKZPVVOfbd124fvUtpWcoKjgByEi7p9ve2jaKHDTEMer5TPFF3aS2J4nu3pX99/v22Qp4oEqC2N+dc61XX2hriQcfDZ5Xz7e1joOA6IWFXFBFk6apw6FOoBoPWe4m4yVMIdBuuOpzLmMLnGLTMF7Uprhx1oJWf/NYvVg7RZ8NL4mndyTZ1nq+OX21KsAAWIaDyIGZYtj7C/vW7VVFE1oc520pVFVBe07gzHux/dd4MOUIlSiTffqhIwUpSk8kkDNSTT6usZL3ToHMfNxjK74Nc2bad+lpYyIjIcFmZZ8m9s9ykPVYKmTTUSuLOkq7bqCj9sVV86Sr8jMOpPSVoAQy68fIHQ+apzGKz6rwtCeyrQugxd4JBodgjeaJ2MWHPz7+dx/w64MpyDdkUc6vhLRthmu+fgZDSfgAMDvSJ3RlZiXBJyyOi91TlJEXLJu8uudvFxfeRkh0ESkcogvYSTCQIZfig8VY3oTyr4QhXfv5JfD9ZRYs46A0mfO7ffW0xkqrO02cq+yjAHe+x7jw827W7Qep62Cnw5Qo55jFDgc+wZIBdCP7zhrSNs5qLGuMU/XdS3LZJ2NqXM+Mg1dZHqVROaBx3UYNAfVeb1CXpSlK5/MlB+iD/KF0ts7pU9O0u436qRxb73CbPov9TQ7fmqSmGCeoFz3ziGjZ/az6KepyDr6FUv1TuQA5MxM1/UK5fAz1/vt27dw37A1mzanau8auprrJDxN8+R1rjTc9w+41mFYogmcD9cxoG8f5v8oISMGsLjxuD83FrXNLAQ7AMxE9ubcnde4o2vlFH3Sl6KQ3/dCYNkMwfv9plUyph4/IrBpFN5pVKIVLMozuhvvvaP1URIxrboCq0fV0OeC06ap3Na3V0v867xfTr9giD+JVAXef8r76Gh31782R30kjunbtxe9Xi/69u0b/fbbb/Qv//pX+vvf/05///vf6ccPVLhr8KvpZK4+n0+h9/sO7V4AdESE7vveGtBKA/0SvvgzU89zORjyGSf8tCy19HRpoYMSUPpKBPhn0jXO73Z6uLKBywbYBnrW6wi+3fHf97Ffzaj17sprer1e5EjsDnW7E/M1PfYpzX9eqnyl1v0xuPcFWfGG3HX+9TL0nM7aO7DeR2MgIQBlevauQcF9U3gM/i+Sc6HiGAYaN+Ok995v71fGkZqGU7RaPb6DDf6Ur37C0RCLPBgzEhGLKx1XbGl/p1EcPejSwsJr9shoKRDuYz35+gow5LY0KQOG5wfuSBOCmRKBozXAckXtniyn5xRoRnYHaSumU0Xv97/lt5BzVJrxEwxNaeLeyo26j/5QZOAK7cmvczKapOwVplbgi3nx6Z7MHYkfOAIjoVLar0Lt6t45uCdpGYGzv92Z7spzT+3hXD6A2tANf9u8pxfQ1RQvUeS1XtDkNN9wn8r9zOf3fZPITe/3m75//07/8fe/0fv9Nud9gHqUCV0Gj+OIEfmV3tF73QrEKjFf9Jqyy9MAqtxqXRqlnFy9qAeBA7mQLN8Sj5qqn29f+XlYdwV2+wpIiWXGHmMx23HPPB7FdT9/rduP220cWy6KRcijyKA7i0d33vZQ412A6WcSrsTwtC+9HmKGPNm5awCX267xTN7gy2xH17ZrZ4e75M4bz57NVUS757xdymzqcyepp++Ef5+CdjlSvyrvsvkaZYjmtn17CsP+IVnZtjJTlNCFfs808TxRjKC86R3oy0k6Gb+jwBvktfxzPG+j1eVQCOm/06FBcfvQunlVAmJ6Rl8+O1RplgfxO3YZjn/m+mxG21flE9PVMXXPsOZAtd2bxW+mlI98UAsPOE66pk6NNq+29ZR+ckXjWYDnj6kXlEHmR8HAlSn7palzo1UimpQmY5U/Xf/27ZtNFK46oPHHrTuFjoOxUkXJxGGbRKS0A1n+G6NJJnQHUfanNBSe2JyVbooa+VwXGt2VId63e0IrsxrHqFx3465Ve+Bxf7LJSmlaOdqfyN6D3oZHG1DapW2UHfsYHOCepq5eN9wPq4KqtZjmSyv3yY+YzfU8Fl3Q+hmI1XbU2SAiW9UcEVIaOkvGfQX1Cva93a4XlO5/NU25FQcT2cAUx/VpAE2VnDk7mZk7nuSk081I4S+hUtdnSeVGVYdEtfK/WDIgYvNxAKS4l4lyfwGEd2nMwekkcPehjZU2MULqwC2241vOquM97meZ8jzdda+GSe53ecD5UQx+uSPXpzY4Cn3qAhHj3rzmdzWTCYE+rbdyrLcJsNha/uNjz+HOg3PY1fkRzkj6KdtHTEPOlOJxRQIN/fNHKg7upMZ+ZNxlp6Z6Qw2/7voXZeYpsc11La/3s5NR7o0fJCL0ek37bKft6ZiuaEbezD35rC9EHzkadc+4DUZqHifgTkyDHehAjywUYhvFXORVHBvuin9IOjbuKYqdAV0nCKYsjQgsrzcmYaWpNC4Q+RdJD/lxHTe9oU0w/NY3efZKT1+opA7SZgwImTIbEhRATpqpzhHnPhwCBjRIw+N/EUsez6QglFWmJ9QpTePcoaFqw6DIpno3/gLiQuQJr2s72z7Z37jFx/KRkIAMphmA/lC5o5GXuKLR03EZYIhR0NXxBB4BcSOY6/SE2yZVSNfj/SvSLlAxlPTlohlzQZ49QdExFMIo1qrOKPNIoz94rnIc2SnmVW77Z2BuV2MQ2SyAJVKDv7RPzLmc3ekb5ufvDji6OrrnQzokTUk9Z5vHUKx7lm30VqGJjUjSCadOaH5+ZVxDMKrj1kpmcx3H2jSZ8xrDYRMzOwK5rD+jgxEdhy4AADg52Z6MDVAP6iWTBugfJSdj6pOIByvN0A8EbE/p0+BB7zjp6T9dXeI6SYSEmfAY5oA7gH/zumKQRZOJFe1ZoBo8RbQcn6dxWzkd0Q6cJQwEIgbEudR8J06rBXI2fcF2mFfYraF11Qm0j6WQOwe7tHLGIi6e4zW8qVmlkD5o7r3G51ivyDtAoD5XyfPZS5XlU4k4djTWXY/LaSU6wX6PSLcgPTP9UEh7cGYPu1LKa/qqQbMc68YzgZ+cDd1WwWmUZTJrXI7G70LpNbApAtA8+AvaXiiNbQAsRPoGW2Mw0tOm9OHpON4i+ubtqbyb7R+ZkfmKYDgmVGzRIMjirM3czmrku9Utu6ZWC7qXBSgLH4mE42HN85fabysvWnOlpV0RyAb2MT+ZXGfDGlO/PSjKTW47PztUy2g5fEjbFBP2oaEoR/YVVK1XhxBCS7nzSfIx/bycGruxWjHex4MG6moAPvLsyihFWcaDKhAcElyr4+P6yWnoIqCD/qvwW8wT+zDv0Oej3dAqDa8bsLHewE0oV/q9NvKCt8OcxHY9X8MQTdQvpGxU20gfzCdyL8iUz7GQbT2b4/R55HxjdaGfa/wb7U2UVSaURfuGzoREnhZy3o+y4Lwc20F9pWMCbYoEedE6NK+twApC6QieMe6+cgTCKErkx7jSW8t/ZWVyWSYxTI1E9zT08loBK+KwVCkZ8Mm1WN+9hpztU75drkTFXK3e7nQr8tRJQHhHE+Yz3Jba6VdnFKd07ffb5ENQYDn20caCoThOGOw2u6CETHHh6yLmEejTYP4og30gUh3mGMtpVZXGenBKa7/6dL6isaywn0Cj0dATCksvND5QWk9vLLtlraAgS964l5EYaVEKogXL4J7gt0wnw/Qd89jLlsaBuY8CD8OTQV/0SncCFVd+qvEfbD4iReMBn/iQHBpEp1EKKPW+DAbtFfJ+m0+WG4l/PkpmGsPY7OtpeZIoCOJKEeQ6Hg1RMP5RMa3HR72eUnN3cV1+kU6jdUaD5HZ1KZo2iH6tRNdtN2W6q5+zSUvHmq+J5M3EL9xrP5wglQeR+OD1yTYA7DfKdOfI7lZdzPG5Lmt/FTEeN8n5MCGQqDcZb30JUH2a1JCac5/vIygaKJewj09sXB2x/b1o5N3JRlpXPfHHcfXPuU7apRQ3adPHcyVTitkdpOh0xnrZypAqR63GwEV28ns5r+9yMputUfvhdfblQRetgGaet5MkIrZQgDbtk10Nq/vnRMD3OeBVR037wVR4c6XXPNP++amnoMlperRrizLX5WN/4kS0Abo8XuRjg+WQ33fzdJIH866wGgavPX8s3wblH9KTA+cO0+AbDQgwE72+XfbcrzsmN903w/N/qbagI7KjQuaonaQPHI3uuM35gF7OioBWDZ76GnqHNS9ew4HUSEN+KBoVor/+z/9WGqjcdWL0r7lC4voN2yuAAO34dDZIxCKjGC2PlMznKJA0UDIdEMHvaIxlan7HD+jY7FhglL3Jj4t1gFWTjMzE11Drvg2/j0qk0hRBszJ0NPKpwaWSxDdtrg6Adc+8WUKF9sx9EAnj0Cu8k1NHOqjsAoxRhzCv5FsMDYxRnIu43LxWioGC4qusH+a243nNA1MlPQVigpVHY5DkuR+z9Tjq/NyBP1bt1bpWYBMdH3zW4Z7HYcuPO+ifqblsrl6vVxN06Nr1oEGm4UnGVw4HM4+Tsf7lX+j1etEff/ygf/zjH/T9+/fYf3MwnL/bKGmjEvPqgfmcm4RBhGjg+4JCNLY6btM1wbaQvTQw1BDbX3HHJwBK9fQp3BIAzBReQDtquMqWpyk/H4LRX8VDREIMx3Xk9Ow4Tweb6mEeeopkdD60jfxsBigkvqH8uFcOATY7gYBNx3bsLhisfrf05371ACkGGJ7qWKWdYztkMh/3rf3YHGMe9Ldua7mD4KG+zwjHXgBHRGHbbaMXT9JOP62u9wEe/M6lDP7+iiPUznmTb4d5VvKEp1LJtJeKZwzXcNfemj+677tVnV26yLeCB30M274sfiM8MbQ7IEFHBHuuO2Bud9Q/mJafPt52B4xR+Q4wdxMe08W2X5HoI6pn7atI4dnSXaxr/LtI5B7qVHrGUOCBdbfvPBAxb8pMONOYXIY9c006EawspFhWtG0RugnPd4+ANYy+RkBakkbO+xbg0s/ny9PZOyL+jBSXlceHOho/E9mZFdmch0slW1QmhU91bs+Rz0gTeC3W0UJ6UlzuDKmzwfTjfpPI1YyTO5w/OYJ/WkLnLr9f5bouKq6t3GbMV+9jyc5fl3arFSf8puf6f//+nX78+BGMQXAO/onJqDZdQCY/W527VRu6ZQxAY8NnXkl9jokoOkc/G60NLUPfvNcYLJjBARwTI+SXkPBziQGAzN/jY4CMmz5zhBxo7bbdNmOh1w3sr/LATAe6si1zWVLgt9Pl5mSIktGfEon9+RxPnKcRZa7BN6JrOgeD0IFH/HlLpI0pPgtb+/7r6P50DJ4j971SyEHCPBfYxx+LY/5jYPjPskzOgyLDceaL2/ae+AhHoga11uPu40vEVx3r6xJ6/+OHORvuYF0mQ+MEQ3eaLJBmdb+dizod95COHY3px9mwmndNM8ocBtY97vCwCdHw7Elmn0c5HjjGo2MI8hEMEmIqJpE33df8zgLYYOxdxmVRr4imkksTSbdF0XyyvVs2ccJFkaG5z2LD8GXiwKEUpm9jis/qY/d7LGkepWkCJsnwaEZsma2Po6ppYiySCwY7RXmKsr0uV/Y2p+hk0fShJtiU9+yfR+5t+XJG9jI8wmPi1hEIJspGTdYKxiAIRq947jeGY4RHHxGwCPnIQdM9UZGeMSKpLps9e4ZnjDWPSAIKM/Zh/sezbbnFxk+jgZCZdDXLVnwExtyce4jGAN2v14t+++03+vbtG71eL/rx4wf98ccf9P3793mS2gAkPqa+3sBUeSaPCwI0Ij2YClfDsLyYDM9cI94iFObE5CFe8aqCfGbnICWZI3XfE5Cl8ptAxn3P57au8a4CHSV2xRF4kIlIOLqC6DygfvPxVn4XjSkRTd4QnptHsAGsu14iUgODN26fo/u+Z5ve95skLL2Pz9uGSYjoLT88YOGjRbpPxaGunvYlFF8y5tQOflMntx5oQcQzqtatNMZ8MWUjWQ2zzy/oR6WJ9TvUIKNPAOMbelOzEEgI0u/Kiq6r6lunEevv+dO+N7sRLIfqfUI+v40m1BNkedzOIlCvDrTztBiCuIIsMzCQcqDTpmPtumK04xlYKOoX5jA3uiobQJI4381mrO5QTuCZTEIexfmPK5uqmC66jNVE1KCDPp8ER2c5v7hOd4zcUxZgHpUJJ77hVN7kLPTtJubXxw54dvRYgczUO91BgzsHY+gYiliAJ6eIz8c161FFyDy2gusJgO/7HvqX59HJ+b0f0PZLsQ/qYvGRdzM8R+49+3pFfd+tuCgzjHF4pRerep8J+VT5+FpscSt6NKYc+NaKbzLhtLZ+3DRxj0rXBMrir2zQ8eILV/yZeHoI933Tjx8/iOk16pAhV6dc9MGKRoaHoCRw8EuJVIvMzk5mZZ1hnS/GPZe1Bldhqh5djUQFR3Y/WdTC+DKXYUn0WQQChRUjuGb4qTEkixY1r6r0wkKN0MeFVT+JJqceSPT53HM62QbkaUR0mfyJ8PzAqzKwPr/SaR4jYszdhugVZRkiPCUDjLPfu3oJlEmX0Hkq5YM2oUCl2bWSEjBIYFx5pSprsUlX2SkG2vo15Kxud5Dw/f1+0z/+8Y82WjTyEN33eyr9SGfTHaujMzC53roqmeBaxYRQ2eQ6LjeUiDL4uxUGIGo1aZY/RBR5POPBzPTiDMZlWFWLoqyiU85DlzoZVkTvTf0h0eUK89nWXHk2r8Ka773qt+rpzP+GE8Xy9FpR5esOSH11Yo7IWD1b92pcvqVfbdK6KqiKGhMDG7G08kCVhdlYqtMzBJZNzhFua2BmAAb9HNUVtKxbEtULGfbn76K2CIEdANJFP5W01oMhuADA3lwaJtJTu7JWZqSNpPRZ+41tBkenC5ixB0jZ7uGm62SvWx1fRwAjySGCTK9irDyKrEJd6yscCChYQZ0HPGmCqQvGywhLOM3vomOIfThxPJx/3NaLmqMPHBei2v3Vb53Tt9yT9vc4ghznvMCpRgayHY0fM6VAJjPh8a8df48PP0ls5IEXrVatYt+MPH0f0iyjWIMobhXf9m+RhHTOX3Al5dExgcOMRr+RgYWul+vsEcw9n/PzU6cYIwncDrrfzUmZWTse993CCW7RwKP3GYCguDelGhKlckGXXq/Ku1c6o+pXEFT7CMah73/PYpHWPsLqemriKbTNpcZctkhRypiBZhexzXlGNfVa10Av6InyPDWPPCuUT11aRfE0t4lKdoQzXyCwXGCaeSpcKpaeAxl6v9CVFR4rXmvkJkfCNyRBuWbwAmh4TtoP5QeNcuC9PRHKI7PVG/qhbRBe0v2t3OJ6g2QMssAwtuowb0DozllQWrXu5zGen+q0ZgN9D6G96Q380PNneE4h8G0nR0K2n72h1eY+fqT6KngMORyhWLscdJSbYNd60EedEuPrTKOCAY/+rsQ9ys56VjqdlaONT1sOQn1UdcjWkB+KFk+jp7yc60ZQjfcQCBYdEupPFR8ktaD6HW+YT7sYC+f7fDDBoi1w3IOTFWtPv5BvJ7UL9bzreeCH1tZ+ApUO2wFnzu8T+baneKOzs1qnYR20L4n6jDWGOOZ6CGi6wTmtW8RPUg60ZLoU3C7LN32JNPYYZPyDZ+nm37HyQfNoeSLTUBKfkd32Cb4zE+HOlpEQe+AqluMSZ4Nh00J562/kZ123tqAg6C2ejo6I1hllUPNoQOLJ8VjpQ6vP3oLutjYGsYTGSkY60fMgHTsa3rkxdV2nsfHaKdgSAcDZI0R9e10owSdJrPMmcIkuTGEpi7lMTqs0s4L1G5mqbdtO8cj7lHIOixjSeoIVOK1oWJUrKzyt8kNHc506AyUidlqrKZnsGBwCglVale8iNsUxBru2BEDUg5lQHztgeeyPEFETiT8ahwawmIr94rjiA9JdWeTtykfDAMyMo9zcYhhz5fr1ah11XdfUJd2sXDsHJpSX/jr2hdi3J70fHSmmXXxddcdFHX9VnskugOWFPLmH3ZNNijOzoYyGsNMF8xOGXzHhdbluxJUPywrTZawvkClmSQYYniHLHgll2emfw8DOr6BiNNYNfzVOCV5/khsEMDvdonk9Scm3A0N9YAxqawrW1Qy//gy+on2PbT3rknPnDo+VxdYrbgjfMk5Y8FDOZd8C4HjCLPukvCnJnimg7OoLuObJQQPZ1QhyDizE/vR8yUzj+Uq7HlqiMqgNvXllyQHx2i6epG6uy4oLz+foRAiDwh50nlBdIx1S5cu+m15IvCZkzujgKa+r6tC5klN0XRpHHRNtQoS6t9avgg065h1sWzmouTzqNse3GcvqPRrnBzTOsvbP7507GURfPt7WhcTmwS6DEdnI0sixB4eYt82nfwSXyJ89u0LLFHoffn84a/SHnFmQJm4cnExf+t4pxlDeDMFztKUXbhXWyMQzU/2O10yHxYitA4x+9arblFTmQNZ9fyz7ixOTO3wakRkdjM7UylCUaGrXxkEfKmjfCHBwZjJMrTy/i5St0srprkqrB1MyFXx8FkfvJiOLdxoloU+6FGcu1bNipxovcEPsRiRus8ijr7J4OpdK00lkSdtLtfinyktb1x4mjs4z6MUVHT1dzFyO8sXIaIY02eCqrgg0QaMWfEAOafj3KVhSnu0KxkjvU5hru069tD06GEq7AIOnIl1wo9YtUa5SNVsHq6QJtZ4mWueRcHq4yXrS7oYHubEfC9oycMZqMxbPfOVzPtKVniEyJ5lXspb0ktXrJ2GVvrT8kfgYgKU/V+f8KohScxWBCaru61LW79Ux3c2V1dLU27WRx+KQRyVNbM3QFJnBG2bQG7Vs0L0E89fSn1rE8VF7MOctjutuDsCh4MqnK3pLsJ6gH6w4tGv3AERhvZ3j3umsjGtKF+ZYnTUf0geOxvi4zIt3WO7EUnI2aMmHQZ7SvWxMcv5YCSoenSBnHp/Me/6LVVzXNRhLxiNXzrNaryorP97LFdfoJ+tS2jXbSb3KQtp2BYEUEYG+eswPV63lQSkoOkjclLHuzC+uf+YRwuOpqFAOTWHP1E1iIqZXuhiPjPs1Sal7G13MukT5mnTfziqN7s99WkU7WR1O9j3j25W1jtr01vUrGz+8Kz1/tMp0M54ZvOd+5vc2+EqAj4tdu51nhmGI1A+V4BD1NHKsaRkdfBIUrIOAX+eD36L9I1D0ABSGfI8Lb1iizg6IQP4uIS+FcQg1wOkxrCCthmMiBoWDNQA48TRSyi9eFloMUc6or5Bej/opaII+Spxqptwvr5PZn88QIiKpW4RyWl2HDNYu/DTiwpQEjwhQrIy5P3XCofptfpznVmfAvzu4XVp5lBGss9qUje7kKiYYCY/ANN+PNEf6iPTQlUxnar7WCQ4WJ09AZYlVBrogg34He73qv0D+3Rz76l1+0eCuftTMEavEYNTQiRfpSuEPv5cmpwvIjHpr+DHyAa4WVvq71EWvoy6o157q7mQ/XQh1r5IHZAR0lY/zBcEPIiK6XVu6E9Q74FGNzYAEjoXVG+1yrQUTPH8WTUnYvBDp6fSKzykep1vl9ApBoVjF6lRWX5fPL4pWW6EBrjo/0mPEg/TBMxpa7UP1rh8bwdSb04DDVWsnl0gA3I3ehoRWMfXK6r5vAxL3ZM6lUILnG+qaTKnbEBBU5XS6xJjhBdsf70uOqhdIkpRO1/aXVg9gTHvj1SgRpqIkw81SfQ+Cfnk6BKmZjgC+yFiAhOuKR3HKQcuhQsj97tseyi+ML9ipUprXo45J36Nh4qvRIewD+Bm6vKyRaVR1a4OOSjtvxUPgo3me08n05aieT52d32RzxsTzBDsd5/HmcC9TgQeC8TcctbgFros+iBKI9ae+gIoFPhzrdFmXos7M0dmVPhAR60fHx5FnN9tsMlDSvCtAmIzjbpWjtKjOX3qwMmapgEi0z6TP/bHRzZuyiw6QRiMzKGDB57mik0GkQESijUvcnSPXek3B4tYfS3X4fOu4jx4HHdToIx2vFV25VbyVAxb6V6jyWFsWrjkfaBS7rj6UMTIwqa07DqmSdpBa/QXVw/XRfO3rzpGipq+mgzeOFdp9nOeCmQtcyPRwupfa+Ik0WBb5udIxrmetFpOpkzBsjsk8gzstVm/SXaiasg16DoxFvuXYoamz1UmqMkjE4/07TGH8v72+Ea6uaLAUtSAeGuG+Ez7BU3XxJCv9VilwOc02oqwiH6YvvEcDvaBeca/z60SvwY890JMH4fZB8PYePENKHKg5kbng9zeoor7TtO6QrhFWmnP688AYFd/K7YkGAb5ujPnPUSREemoMRaOzZ7qT8UBHtp+38zrwO74t5Ct0zVo4gmkFghEkbhQiRTJ6gIb9VqW0TvfMtrAbg+7NvVB7B+AEVq2YxwseZ2VsyvORzH3AoeamAXjyEb4SszOT8HqMOH2O7z2AI/ZHY0076UMeLKQvkYs06sOJEdS+Xr8ByTLpTn1hB7M2Q2hgZp23ogMIhxlgkakTbZUlvsjL6pbKlU/66cSAZHDk0ceKZ0K5DQ11y8c5TZwBLDpCm3KSvg37sy6RgzsoewM73TZHa7kU0s2BdrJWANijtjPfRsvhsdpESFmW7Dh38zS5LI+dqDT0iFTH+m7OO41ywjSOuWeyEx8pzzGXstLQ0J3KExzSAPgwl8qk7lTo+eQpTCObX/G3FJnJNJe6tR8CevaIKcjlXh0TUJ94unvWwjGIkDEPjMYDXzzTiAzmjsAq2csc7Yh4tuK5ZOzrDfwNbF3sr8C/E/KRx/KLKanpz6puGId5MpTtKGCm1zXf3J34Z+zCmadbzZfOMr+MP07sMp6WRUT+HIyNKTh76ng8VblIH69oxGMRG2MxP1VZdlEYv9+3sUpWhuNA7MrndsoWAYqnV+ug3klRgVO8XvFY9PUpb6bPIz9EAb4uZACjFbitY6XMOk91RY8ty/EYdDl0YjCL4aXGKclefez7WYorAgtz0XmvKWJRo4Sx/u50hxLZbZo3AUWDiWXg96pv+T4zWeRmQvOW141tH/gtf9f8oU6Gj8kHq8j4rk+nEeddYspqss8zGxwfi5z6Hh+kQSNpdbna+9DRrSsBdg2Abo3SAxh0pkgObNWjVv90ZHbOfreC0DlImf81+UOY+7SKtuM1ESG5b5DxvbOx1EnMkVdJsVVz7DDz+oWqI+Ms7+jLTlV56PYF7xhSmyGzzo7X+r5J6YeShyfsoF2I3Yiy2/HY0+xlUG6/JddPW/DSRejLKtIEfQhZ+nmeWm2jt5iZ3u/bZCA/VxTyL2iOwLk/fGBnt7oUTtFEeqle17pyfW53Xc9r3hUvFNoAbUY97ujpI96Qen1sa+oPEwn5DuejrWNuiWJmeEeFOojVGXxyW1ZBkpWeXcld17fBl06b0dPMVX6miER8bgBz6D9sA8s538c5kBvePwTY5NjOznIBN2qHPkwfnzoVQR2la3pRF3c4Wudcp+X2NgI4SgkZYvzfA7VhW3sIgszBiNA1ojXfrR7aQnrEhb540ubxib7xhShP/oPR/uT+xYtTKMDZWJ2mg+NwcpSp3J3X7qkaFI1sje0nZqi2fdP9iGuwul0ypvX4dfzgUdj6bhULoPjAKodAP1jxNjEDtBCClYD5R1Yw13mxytEKRruCtXnkdyNrKkk9ENV5XzoblObVBbXea/r0SVoCzDTWsZFBU0uF3B7LbeoO+kznsKGprxtBmIQper1e4NzRnJN60kjqnN4go0Juut96rO3gz4svul4vuuAFk/eSq8ja9ePRk3OBfc0Rwqlf5a0v5eMm5jv7D06VmLxDHXc0nvn7JMBp1EuT8Px+SnTcqnz4MaLaVd9awOTyC6Ay8L/2C+uu4NP7W5Nhskd9J0Qpoi/JZlZ7FRMCvOxABr7v3qqWypkOktq3+75Nl62CB5qeglgjKFJftrpbxcIAmtfDg7mld2xzPV39cQ88teO3BqbPKTuRak/Cdpesg0l5Yfy45osinwOcK9scby0dJsAQSBve91cT6N+pA+7+5blWFEB0bnA1L30QS/U1gHNKfJLmbczpQomEhsHEbXuT5kzxoNqixYoelu2CLQwOuNwzcNHICfKs1j3qfFO2k8ZT17exMhKcBsDrXOVExJ+hktluDBGc2/kvOxoIHHtvdb+3zvImY44RuH4y5l+u7cbfe4C9TjKrXwj1pqQqQvf29+3vFFZvRCMh0qGjVHdmijymbfQHrhVPumCjGlH1unUqAUAt6Jy/KL6v5dmxyDR8mjCC1Y2DKh/DjLHl6Dx1yhQQRzYoe5q66/bN2yMeEVipq0BSvqT7jXxh+0unjfrZPFU6q0j2qnwElt5Wp1AjlWu6dkY782RLj8lX2ndt9Xw2RibtUx/et791HDOp4reATALvbV+xb23rkW0nHPegSQHduXLBglZmuYK0otMJtXzDj9nJ9n6e8Z5XE52tETEWczhM9z6gDgFaERi6ae5o2MuW65q1XjpNK/vYBzU0ExEt2+v116f0LTjpUY+3egMiDacBqNiO83cOQmibXX+Xunyhk8yepjnAfzY/k5feIFf8IS/EfP4cyzJ/U349FxnM3kEXPenx8YPpUcAsK+j9zldJTtTKvoQinRqb37KtXwbBSJ0Dval54Ecqt1ohGQnfcfI81z32UlX2sBqIBJOXqY3QwNpTPh5Q6TJ94RkNdzLMCxIHltMDcCOzsRFtxHB6iDgZz0BS0ucnaYBbIvYTX0jIls+pXxKMNThjVsWdaHNrBPS2kGRFbavAsjDctGAcyLNyEHI+vPcE6Fuw7nfhL+SxvH19GSDp9zsJr9/V0zmYPObbjafy6ToS2PWpo9FpUwBajZbW/TPG+mOHymSIaKX8LAIN9XdGlygdxckOqZ6o2inr1bXH+gAw3beEPj61F+4n4Imqy8YlFiYS38LAPnheE0ee2MlF5Dt/mPD1eoU8uAKF9eTfpKBXcu/26cQJnh0alXdZlX/0e2YOfqbI+qO0gJ3QSzrXT3zXybQ6acQ86YHKMdAFRGP0L9ed85JXgVdLmUCn5mEgwTpbcrVJH2sOLViRajPsPtbfAmW/PgLDqFMKEaQBEPABvKkZ7e2erdA2Hbht+GQH2PKeN/FnzQS+Y37Vad0qaGw2zn90SkhbIf0GNQZ52emnMCV2zXER1tHqUi2POn+jA38GQJ6kHvj3ZHVBr2hfMcmEi66LgsMWvKGZ3+zzSo5c5oLlA/wTcCnWM4OksU/Pdt7r85VX1+v6vOJaXlapjmWlaRdkLnlUrE/tBKQvORpZuPBlTcwK7RaETMYIBlHraiZ3BxIwKpEjnE9lkX5VDtHLlUjrpl6me5qiCNKsnpDX/7pwFDKBWXPbNwDztWPw7oDQIu/TNaXCTudqczwlNd7SC3ADxjI9w172eZwnxrzpKS5EYninKu+7XMyRhxxJ2kY3mIdjenD++RMQXqWRN/MUPyiA/pkXBBI1oiHpE3BP9vrEBTePkyz4cCWbT05vAdkXg+ynLSCLtqqzB45WxFquo5jHEb7sJjkAzQkQcWpcz3nfcDy6pODkdTHx9VtoB8uuxmmwXgeWqeTfObstjUJjO5PyN4z3KgmC1NlDbui2N8tru0JEVrcGCy6saOb3S61ubgIkNkSkzTwFsqD9BhRiW1qf9Z3crj0GacyBA8NOwI9SbcVV+py2Nhh8dl6nkLvvTLZhos7D4k3SVY9bp0M/rN5FwKVSiGR43ns5Z3WbDJ6Ukz99Q6yOrZDy2Qpc4r3QLkmMcINOUa8r17OyKyJCfPkpRN3sLQOxhbQ9hirBpWZYGeZxVdcu9asdG5xIax0Uv2THGsYTnVbSZ98uuxdqAixpIshrvYIy7hjhpnFkNwan78fx8fpVn45nPGqcptfdnXOWv4/Qs4/3gEfn+C+O5efOxkcPg6sS1c4PYMXloZaB3R1SGzncbl8jBfQCxkUfQmwBx2QGdxJ0UiTm4b3MOWjQPrFPQ1K6e2NKE5CcDHzcv0yEQCnSduIoKX0tXUmZdXUjMFu1Z05hb6tqeyEL/pL0yXB/DXqOEhiw0cLUFokHwtjPpn1Mmy0PDbDout8r0j7PLuU8ZxHm0anlfJvFw3rJxio7/JYX8zwkhFZZQT4DOc+X6TfOSAQa4L59NWrVf83ftWXU74ZZID8C+CQPMcsNP06ASuobjb553WLzlB2hWcjnUekwaB/7Yu10CjLRgZ8iRHTfNE7p6gdMdX922LE93IscSiqbupCmhL0fet8NqA5F8ywP8j+AeNPbIsSXP5+w1ONSRv8ofa1UTdmBxusrB2v8CHfiN/5sW81JpD/zZ9C//sCQgyu8H6Z9Ydfyl0Md5W124IxI9FSIg+qiTpNwPda7l/OONvttOEeVQE/H+PRhYOIwzjR1x1P7W2cl3ZB8hd3OlFUIwBdPAPVEP1Z6xD6CTLfdUBsF/RiKzZS6B4xHBU9BsvCbxQs+4MHOIUA63dbU+tBX6pxUva7f7ztub8v8cBKM1nnU7cLrVaGazp/RSLyegUQghphkgg2dcM1xTa5E4dFBE/ceyoAZHfitAJj4oh11jrQOi8qQt0FE9GatT52WizRal5klnieAV6MJXCVmBWIyH9SWRan9JIZo6oMSeYxULuoI94TmA6Mynr+jPDKD5GJUmWg8dxGB2vxBKkADIzDhS7xWyaNnzl/WJgqnXfSNVDRBINPgllH+sjw27xNcwhMqxtstNxbrB2W4H99PnanI6xzHFAEppFtkvAxsgiirA+2QVxlAc9hS1PBT4CW3NmNWN0bxxCnLtBktMqOGalnRNm6c8OeVBDQWjdLP92SsgMqkB7ME7E9zWFN0dBlEAXrx1KFQOS+2nGowKBMTDBLMHQnQutY3StOLNZ8zigWFQN9jBDaMmf6EvxicoMQfe1A76Ye6cguabrvKdWym1L/C/fEZzldM/V7TBdHnBnwHx6tEl+A7IsfD1Mplrrqw/7qM1zmj9Q/8qgkeTw8Navl8rEjoNtURrvjC4a7Qle4XEslXOKLtz46bGL0e/Q46s0vcWkKj1T/jqu6JjTv1a7tAZVffCvoWWgDElhuqAwCfCYlhAyI/ZGQX/NnZgidgj+X0u4ANNFNBnWbQ3SdX6GOwY5uBLysJge/jGMvEwau0dHqFpn3z9Ug9NIKnzRtFua2v+/0Z0tik+3PcQvQTz2g4aBupM5w9Y6c8M9POuz+NiOZ0XO5g3ExgOiP/v0HKD3Xn00qePFqPiq/U1cj1FZY2sT7QrME4LBh+Lwj13jiSdL3d5iu890TXU52fgPBfkX5VHz9pLxujHS1PkbBd6pyMJ3DylfrJgDsCzKzvzvqBMprp/jzq9+ckpZGZxxYeHm9P3zl1BtgXgPfPTjhm4UjOdLqL9km/K/ArrxbY1O/XKPmq3QpEGoEEYnLqQEV2qh3E+UlcT8O8C2DlwNuSj20MuvL8pOI/Ss0aX0OOz2U+6TgGSnLlh0j/CwmDDWtZGX/cYSEH0WCzfa7V/cr1MF3o0D/SRotut26g0YN9wz7uHGC93tXxZf2mmPK4QBd8eGjCAnZVTnnusGQ5OxCpUGM8mcMdcB/szFft4j8zHTsaukvVMB7NB7pEPHoM3sdwDNMA2ORzywgrZ0O9uJR5av1VNKHX05GmaAH0aMERpOCUT8uTMSOSy0Rj6dWiIv1r4UO/Su00x5OmPk4wxVzledVecTEE+EZBJd8vmpcudwK8i7hYRNTGRnrMkCJZIhh1eHLUbh8QE3pdTdDLkiJb67TtK+m8jedrcpQE/4n4UYh6Xn7Xfh4/kS1eKMlW2ZoXY7p4jXlo+QeitkxEN3Pgiy51DlYxEHdSwPzgoCqpFxu1GPXCtr5qUPAhQKNzEUH7rOJQaa2XuzOFRtIjnV1PgkOjckAYYaWl0dg5piXqH6YGV5o2gDWrwtRuAQZ3NZs3OBs38N2Qc59vDDjmpp0AoYumWmv5tvJp2CKSu2cBsTiOoU9KosSVCCHyVTlrAiPHi/cGUOO4guigXbSVHxALm1eKY7Tii51jYLr0hnnJqz0HukECn8a2XpkPZ8bx8yr5ySKyaKuooQzyxIHwAS7GUdoxc8sRbbaIjLFRG9ZiDPosTRCIkP+mHnBme6Of43mvBV8PBprR9AR4Kasunbexaj94WrweinreupCZL9CcHQiw9frR6OBVQGm16vEUkAmrQ9B/gutbfCC3ne4l5YWs0NdZU7W2UdfhNfvOQt2dVVJd1fJim9SOvLa5rP6NnW0XCn4iuJfT+YoGMJGCWN2SEc5ph/xCHbCnKuyYIykuf4slllX0xrR+8Lbbq0tJeSgrzre0GnDxs4MyXejxuu5UOiLAxrQFQOz7ZEWEbuK5PUnMZeHUJkk8i7uNzACX47syVnR0ysCrckHz1Z0xXuiTcSt0tR38jnotMDvTeBmQKuwN8Aq0Ngrc23PabI4hGpTp3C1HdoZxB5676NVqvC+iuR2lmbNEg4RcBIPp7WL7ub5OwRe6mCk4mE8p8CHKjkzna29487VWEdp9oUpunvdezxgvLJyUaEhqyvPJrP/iQ5YrebMgSgKaJc9TvzYBgl1i+1PLdmOWx0lE6P2eb5dWPrswmNAY5llXfKB31H2FPHpfr+AKj0xQgYAfEP3UnWJPYoMOkckvPLdNspDcd6MBdH6p8oD0hphZ9zCTyanazOIUK423xPJcy+e05me4P/t+GX8BmJW4Vz3XGYIsRHTLePM8S9oCRIp9cVVv2NOW/0VINs7hKnVmbXxnAJo979/zId2R/NlPlT2e76mQ2UcfEKrzru0uHQEuL2djELJd9F5lKJjATl8T9VtTyRGYBhsULr2FAl2+NdzrdYyjjfddbJ0G0F85oBn4pbGPT7zcJa9fCt8O2aRgJ3NbJmN97faJzoZ+AOVB45BosDfhiYnvaKEvNN0Ceii99K+MyQGGbntW7FWcl52uKcGtD9L5w+Apwq9Dqdejiqc4EFpqzpoD1dQGwUM8zOZHqtJFGM/xzwRCzhL2oKPqtxtOBwDKVAmYULbOQjSWQaBZHZSp2KdB4bLk5ZSjcR1dg3rR6QB8JlCHP3/ANI4mzSBMaZlAFYeCjcTYNS2ZmEqVxE1CbDK0AzNIqTcxsAE4cGroFg6hwgd9Nk/n1EYRGE6vGQBRvrD7GUDVNq1mAeUB4080WIxDfel0EoLxU3ChlDO7MhYGeckGEk0F3A1dEKcvTcVt/Ye+icueyQhrC2TGFMFQ2fJjfwToYc/P7qirAXBy73BNFkpelMcOkwUdqN/Ta0/dGMhxvQAqnJgYDASl8XNQBg1AJphJZmK+Y7aZB8cvOtNulFSPBONl8uayUxwCEj9lA2Rb59jxg/NG0NEGKCVOm/EKAHzTVR3SGTwvbwQCo32e6Gjo2QkGEt+bzp6Eja1NMK/KQggi9CAqlf1Cl75kSpKOV3txTwVbgbfXyzCZ7ihb/wKNut0hDGQdKkMw4n1X2vS4eOCrStM62QxNWfQzBdhlHXSWjQjoAa9DfAwaGhCwqUMlco+XzKGODkPoMnmZPLqiL0EtEAYD7VF12X2kL4I4+zZo1gMNmOjiCe6wzOxztU0QKJnDic6u3DJfqIkv0/Snf0xuGHSyjrbqZ3U2Jp8LSRi7UTfaDx3TOcjsNk6rR1yl/fBRRi2mbdYxtfEjpFksFwOgxnq0/riK5fI06I24Y4wzaOlGBrwM3ojUdhoB6R58D70FgC8TeOlsxnq9ZsMHZawi3QH3mrpO9kBfxmqO/hXHxg4rqPoe2/FgwtQDVwwgZtuoukwCP/oKbrRSENg8dDrOHY3AluO3gUFEYhQ7Hj0oABsEl6AezpcZO0huI7TujsowmFovmJhmbBgclZqSgCDN2aDYxPR1MTIJgAYDM80YiiocVO6g/KduCuBJbFvZRWTjJMCfIFyyAA7WLRBKUL4OVGE0ytGCo09DaHF23W1oBdTeYxLr4TDcggWMBjK1XvulLaoRHhfvMF9YFQLk7LxmOpjThopA3pyrcOxaXTkzhcaYK/cDlFPgRQrMLUTTyaCSOhAjkw8c8OXk4wAbTewW43eOZVC2Mp2BgHJp0W/NziprLuumR9IYDuDgNA4yOuNwBZ6vidP3DMR81dfymO2F6+BkaDWdXrSsqycLq6UJ7XLKlnumY2W9KPztOthotC4kmiaoUcsU1SqAVj1zPggJT12Fxs/v41vQs3xXw+8Q51KigZeuVCbz4ypq5/6MyoJKvE6g0HiVebZMYYgCXweND2NypS0RCOpWNtbnxm1DMrKRMqYqi06Ky1JnN5qAgQbFhFyXILiOfR418gTFvWMFVi1Fyd0JWduuWTDmSd29SejS27eCNBoBPOvXyKCrd9dv3+jbt/FPT8h8v9/048cPkh9va0h5bIkvTC/cRGJeM/F12QPBDnxiChwEQQDTv3N4usCurm7YKgr2M+G1MB/WhvMi/jP62bVy5vdBIsgehcKzO3p/sUURZZnxQICd3ibHV0ust9CxqHsWZYWi7ejk4566qNUv6lwoHdzkY6YLcWMex5DVcV8JIBNg7QZPQnOWJ+AQcAhP0gcPgwfVFn7jkkpellFFJcT2IF2hsWKmMt2B9eeYFGUNJBrgWBiM3dJdvp+vd1H/nFLXmjY9VxAR8xrQqFKZz27ZPraumqb2Qz31nHuVht0aqqTyPRuYUO88gr3LjLMyc7FrqR9ldcZoVBGUcnKJkUhVuMPqjGf8OPU8AUJv+/MxeqDjUxUVLv9ifUwRVHVtr3jbDYaXO+ntU5R0UzK1jJSM/rvRwNsLRUuxb3FJN4/bLHYxkVypDxzzGsvH+TDcu+SJqucCTMJAgdENEj2dY6TM8lVyQZf2NOUl7jwWPV/0RiHWBcYGDaEpn3OZaXWrKe5prMR1RqZ9pQ+EYz9itg4IjM87nakeDCYUF9rxQaRlyBXyKPBjM1a4VQVpV50VfQEfszZyy7raOVaad2AD5bDUr/1xjz300e9T0WEr26eR0VxPpaqOUp5/jWjvtmxo1PaT1GGUe7qM7/tN317f6PfffzcH4sePH+ZE/PHHH/Tbb7/Rv/z2jf7y++/0l7/8ha7Xi97vN/3xxx903ze9SR2NPTgN19Lt+77pYljh5Ua2FSss+pg3FaoTW7VYr8ekqX8Lshf5mBq84tELIvgazeGZzvmK7XqS845HfhUtCPB3NLVaF3RmmaumHvz+es1n6e6xRWtce5mTfF1oSzK21hVfJ+STYf+So1FxYOyYPmSD1ygohKRk0IBP6m/RyF8yjvhdFfA0EhedM0V2Foz2DQN2ZdrEYLREbawkukDxQ/v+u+sDL5ioQOswwu1oTF+mc5ww2ZhyrKlTkgqOgtkD/rjK3tzeWEVewXp8ZMLd7PwQWfRm5ww+pQ7cn6QchRfZ0zEuNcfZJOOSebs18gHXrTkp1/HI05m0Mjal5pbGp7qY+nEPAI/HA8jxuSO2h/U1KscgB75EvVCkCeh1NEQA28+nR1nZ/wsgG/pttfVKu9YN1xfz1snz0Qs277StCIhkcPKyXOVUrzf8DnWvmLPjS19Bh+I/3qafQDKqM4djmZzvAVaf9b5/9/39RBLml8ij2Lvk6yDrORLJgFWdv0QtsnVKjMqwS6lqr9Lb8rrY/mm65yljlqe8JyPOoTgTB7uHgCnatepkxIjxma3vZBr7IyL0477p+48f9Ptvv9N/+2//jf7617+SiNDf/vY3+h//43/Qf/3Xf80TCono70Tv7z/oP15zx4CMw0Lu+6bfX98mDnIWXy5GYsAAg1aqbzjau8KL8/mTVl/hKOa+p2s4DpJkZafDdwFbmeX7vOOPXrug0Lh2bf2MG+zpCmQ/pQ4rrvq6wwIr3uzSZcFSbsc2B1lzYIksSNPTmcdDA5b/8i+/0++//06v1zd6v2/6448/6Mcf381mjm2qg9OQhCvVHbt1jqk+Pt42DKpeSxEm3ZmXJ6NGbxOoBmNcfBm9PySkudnTiNfqpFXG+CogFZnLnQHHbM0XGQDnuM+1IJ/RSGiPyI+szePqdUA9Mzrh23++JpylFxOEDPs79qcuheC+o5FvAXQ1HSt3yhw6qCuUYVXG+z4MzPCsdB5Buc0btslGW0eG7dwF9JRjfatI78+kkzmvSlCvl9qaOje0cs0f2BWKxiNeI49///6d7vtpZSfqpiXw3c49ABtRp6AzEEz3/SZX1lVm+UF3Yft1vmt9GSc+R+pGKQR5NcFe+FaH7+mmQFmXqZNyL4/trHQ5tuWOgtoPM0SlzCqhDulsQccPybUxPSx3PSp3Dyi0KndiMFSE46F8gfqiQ2QFRIrzefE9GPoiOg6xbyPbwxhOxy6vUpX0oMe8zOKABgw6NDTlNvEYY7WZ3759o7/+9a/0l7/8hb59+0bv95v+9re/0b//+7/Tf/7nf9J//+//3YIZWudf/vIX+td//ddQ9/u+gyz99u3but8bGluZ4PR8Vbg1eCIf15uqdB+0tY9VvvXT9FwnzqjC1CamviGe6WWYiIXpao+AxS3F00I247nWjinfg1NgT5I09n2nf1bpxClBWUTK83hJWo3VgxZWuun1ehnfvl4v4tfg33//9+EoM7+m3FDrsJzYD83yCW780ns0rNH5yaStj7crDn2T2cBf4rI0QlO/reBKKAX5vg6Tobo8wU+gsklc9hOuqM+ulLdpwPjKTt1tJS9hisyZH1QCmgBoq02yl1dSEgLNT9QqprXqFKLyQPpIL3iQVMidjXlxfDQANQOokkwBr0ZzZvsF2PwjXlArzuDQLYrpccjxAUFQfImGrziEXy33YStUOzk4xmWe19k/mKMIwMfDct6en66GivROwK+ptAc/CMAOkzocF/d7iz+oqWl7DtzPTKeqg00durv6LF78hbRXJiMLr42p3s9Vat9UO7J+yfitbeuA7KWjNeX4JwbL98xHmKWBodOqO+qusF6SH/TNmlacR1Ia259XIMoB907ndMB0lVRvdLbZ+OOgoh8/fhBRfJGcOhb/8R//EaK6zEy//fVfiJnp/f17COZd1xXeR0VE9n4OIqK3jJfwvvj6KRH9JK1EaTiXcaa7Mgjiw4owEcGa7My73qa2Oya544drxva19vis60PnqHKtftciJ/JiDhGrzjtLJ07kKnDtK62qrECf3+j4aHrmpOv6BgFfoR/vN9H9Jn7/sDzfvn0Lq48eGPP3Hv2ZOOH8YfBtFJcootl5pQFo6GjUOuM2A2Q025Mv3tYFGUxNLpTcSTT4kyhEtwwrgg+ATqpmf8qyIdSxarUFuOKMuPAJ9gmA2g5Ag9lpaYxOUOo1gARdalZGxgiRjae5ydVw1LPsPb2BfuOr8LS4Kx+7BPzTdvggSWk33c/5KCp0LRvo4BopeGLZU8XQ0rgBbjuAByXaOk8iQPpAnBdUMXkCtq1JjXUrEJiKXETii9mA1lhvmpsTnxIjqxZhTM8gBccoltvV+6iLLC+UeyS6Wu5VO4yfC954bGvj5dfoaZ+3i2jr72wc3X/1a3iwgUcwI0DUa7nNHT3qRD/l79Iu4ol0u02bIG8VGe3aCPVT5UNdfSHlGynR00zzyepwnssdbnjiV9XVO3u+A7+aXq/6UD3qKrRN7/eb3u/3uH87j2kZ3dOe+VIBqxK+1i6R/hzhzgOgZXFfvmGNCRbz6p+vdrHXmec+yV0ng2dP99WUXwbcJZaMlJq2FvYgL+KUkuzP+tUqv7Y7YKWHYrPP47XDWjfMgeu2nH9Ht5j/UmlVZzrym/J950S3LSTZOU0fr2h0SuQGhlgr35vuO3qOYgAzJXa2sw5BxMcNSo8HOgAdXn92yGifME7HiMyztzm6oGWCAwHgtagmMKGtlx8ZEp+SWJ8g5ElfkKWCrcwXxmgDAnVOUFld9jbBCmLzGLGpUn/poI+RD8Exa3+SN/Sj54slv0y/Bnqj5uBQkTlPlzuC957Bu1NAZJFdZZsDYPM5WHK6IpuAnNo5fgkkUjaWU0Fm2SkAPdNMpKt5bYTbrrc74LdAZpz4kouIR+HAudCo1KAZHJ3Sc7/lmGTfR78+Wl4Ccu3T/Kt0xkpNS6ff+8QzlODBngV4aIIFK0dcgZme9oPzHYyZ3ifnM2M9NAQPKesd1XOfpKjjn6OAeG+ZD4YLn4sQuon5NSKOOcaZ7MYYCl6P+3Q0Am2KP3kPogrdVjA7LZ7/EYw1t09tbalb9FQsgTnV5+KIVGYGPxGRzBNEKR7SIHLTDwBazKwPKFpXFYx1ATPTCw3d+AzWup8xXMekYHO2DX1/Wi3S71oHiRDdb9NTY0wcMwQniYjs9KsubfVT/L0FpOmhlWA3ujZ1rvAo2kVdhqXoWcOd5OnprP0KzqvSpxgZ23zSC0w0Tq5jyqdueX63Bytsgj/0eNv7vm18Lr7mVvex6of6zDkDbfKZw9WljxyNLqq0y5MZTeQ25he/6OZPARKBScxKjOFBOqkT9SSMoa4Mah8GrxOmXbkM1Fftt/VzHMd5kYgwYtrT85RQCSBjZeObjf8KBdkeXhgPJqZv377Rb7/9RsxMP378oO/fv9P379/px48ftofw9XpZtWJ/ArHYkH2cAIXubgTI3Rjn/A8KM7fDejQilTHepRUtu+hnqVdCxqj4cG4S759Haer+eS3a2P9tOomK1Pt1jDCqF5XgPJmHdxHWjdxOZZSd5FzU2nSrN67t5mlcbYG1mhdsyx967/esd71RJ6pEJhijferkJ8ryGAVAv5+zk4iX3rH3owNPaXk0oPb+mdDQ+COpjjgudUsURqCRzh2/Zvq6+hAirkBIWw55bHpTMsf85vFw8Q36FaPrGNUOL604SJrTgfZeYMt9hutpvrPOO4mU907OtczjAcjpWJCDO3PkJ4+AaMJnEzjLZDHbCx51nnD8O916YpdokWdVyoOP5za+TcD7hDw3vyDYZ4qIP6IEL9/NyRL8Qj4hmCdSFeNPA8XnfDwP/nWOd44KLzGedLZjHbBWz8fal84xWPG3iNDFZ2tBKz7yd6BB55v2pcG/szttW3bPxkdt1VXrMV752gpGTj/1jMagpxsICUzhHqZMIJZi9sAYBVo0jgOrXiUJzJ3z/WzqFRu0MxElmvKlgImPDUH+LrW7o9PgdAAx0rur/wvjtM0/+lUULjxMRzSUgDocupzNjKdRNeAJtIwpJhTyQAENZQGKpwfU3bg9b7lzYXVnjxtaNGVw/wTqtRbvkyoT7GVPW2oZ8rjTg+Wyw3GSsjx0IC4qwoe6xf5Ymfw9RLpMnUi47vznc6nM4uwD1kpRCCs/RfCjINxkFXmwcXaIBmgWuX1pWuI55bjPGevBvqjcYIpAuMr3lgUUULV5qt6251sATPm+3mcguwsyrUj09vNVCcfScrqnf9XYLoE8AOKOvhM6C9jwG54n9ONg6xveF7eLWpuIjPPym/ZP6Vylr+R5snFfASPbQNsmb9blnY5Gvf/oJJoOSTQAEO6cYbzusitVlzS2IiddJQ30Bfwk5kQZcfARAwjJTqJ/ME9zwkNuUUZ8JKbNChSOdBtNMXVBkKVNlVGn0HDi8uEEaOuL4xKniEzfF/c5tRuuM8G0k/nrZhs4lMzB2cxTO/7P1NQy2ouMT6rOzYEUvIaYpAQiwEFEbDTsVD7pLVL+KzD1TzsaOTrq18e1qxjHYd1lntZw2onQhpyYvUpnW9dDX4rign/zhl3PD0RFhchDyEmIeL+rdHW3vnxtV0sFbZrykWUtDWkc9PCzh6ZG3vl2ze8/fowXGN237X0lwj2zN4kwyXwHgozC7VwNxcNh3l2Jdwra99zGflHoyY4Htt0tczFbXhR9rFMVzgS//nz/GcAzpcLDcKjhkpQvl8vRxx29WUF6lJ1aGlcG3tq7hdwB7/u1uqaOzqDF35NL5MeNiiANAzBf10W6nZDJgYIe5GAANPGIy3+zrcAcif55DONT3K7QGONqgHB8hfDQhy1oUUQyDXYziqUedTTGCqM/MHvftx8dm2Rn1Xgw0YvxEAVkPPL8+NHVi+ACAVG8nY18BJ4j407+UEc/5RltTV3U8edstOs3zrNuTVUJLWCPxzsyiMkOFsiOeOxzJT8Cx8ozMmUkB7ByumbHmPtNiCs5x/thTgDm7lOv+6KTgS9HXOuRjjYEeRNWFIeSHX22QNPqJ7K3n3Nu6wOwEsaJZR7zT7aqdxktkVfUycjNYNOoUwB6hnY1gGoBY5lyKoRMGiH7QhetZJKZw5ZoNB8qP2rLQntwCTsg8LbyHJAWq6LAfavMSiijN3XhEcIdZgj3xuRAWd/GVrefxo2RYgPiZVcpB4WGXmns8BUUeOEdxR1ABDgteOrjM45ZpWNHo4sUaKoTIIFJumTeMgoxBRMIfyMdNpk44fNa9HzB6CXh6DxQvJajXWtF5YrMcgDQs3pI69PG7I8L0SzcAR00qit6Ml2z2jIHq5KdwojRGqwjClKcuaSsZ6T09XpNxel5MQI8diYD2At9bZRZphdIuklIwMk4Ga88912+JI+Jqhod+jihQl/RKlT5A6sIbZ8bgSen3++7sdNRQF4novBgWa5W5TyPZ9uHDRBy3rFS3tbF5CuDQnK7M6ZgGtuJ4IVIT3mLANFJMoASHPoXDefZ+65qaogIAuBmzE0nNuOwGh9siFwE1LBhct2TYcbYo6un8yCY6vVN5noy/bUPoSgdPQBZOqRwP44XERuScLJ6nc2UisZ2tzKU0gFwXDnvyE/XddG311X4Uf/91z/+WNZ3OoaYcFvJKvXOPXzflD0J0uRKVjYnt/tYkf0+2CoDZU2mg6Cux0iSnFHSw2ir7fr8c8LffZs9Reo4rACwrjwUXSAAb5kAjbv8yi01pILlFn146o/hEQS46GRAWRF/ZpM4vutBtxNePJ+Xed+NQ8lbOV3NR6Xb9WUXYIjBL1Ekv5SH6HRTYXQbUymshLXMeiSrrtTmcMadxmWFe+H+PFtIHz+jkUEgEUwQQXRhJRxUFUgWXiF8oVFPBxE9PyX/oKnOolxOx4NtIaLbtArDEXdMOnbzl/CUAe23H10bv+DYerrSPaVX4X4GMZ2zltOZcs6pjr9Gb7XPP5Lwc5J9EeWaXniNjvSWWCJvg8ht//McJapF6OJ6Cg3SgG3iqtU16caodQSZzsnr6A62OHsgzht6layX44rtrgdwVRRYqX+fOuc7UAcAwJ2MVRvh8bdYj9qXjROv+iMbtR2oioGCUcm318uO9tM8urqG+gNPplnxossirFyx20ynE0y0xHttf2P0YWvwmKMenhmx8lRnl+p4a4Rdt0rhNipNtyiQq7Wpk5Fpb8HUgrZnfRPH5AIp2fGJl90NSy+fOQfGgpf0Nn2uwZPBe2nBNYCl63qF618JDuT0JONtGQK73RTNAbpP6vxVNGLNK7O+C6QxETwW2W91DXxx+XMGVpfW9wUopsHIfO10JWTn5AkRMb+Ac4HCqcc5/B4JLBm9wLbZ7oYvz9FsKKq9JocEnYLHEH/79hq6/fWiby8/LUz1um35hEDJp062lxlKXO35ir9MJsm7VtoUn4H8/KDm92tPmMxps5ktsrjQZZ0s6MoVkQlDGZO5W6W7t0tf2jpVDO/snJ5Xj5HPlbNBNBj26K21Gxr+V01qUNkiVEREsEpyqEQ+Ubq/ekR2befHSCNzc0uMR7B7R2cdZaaCOo+jZwdJnTStd5cv/Ka6H7db+zkBMZ+l3kz/yjHp2/yfm04CAwboaIyQGh9mDs8L4coGM1seTH0U1Fdie3rWyv1Xp5V8BmecaWkYu3LdUaD4uaHmrJFR2ZGz8c/V8Tvom9PX5jiDgG5ss3N3UucnqVvl+qdL9sHwycqr+dMSyszeBnhg6dfR162E/IokzfevNoM8qzr24zp+ggZ0OO4/bnrzD/qDiUji+yE6p7cEZz5MCP49vtPvitnWY3l6/BcDEkJMr5pp0vG15MEqu4I4/k+yXz/3wj5kOqneGRE4SNoFmSGcGdrGSdPBc++6Ph6zS6vl6n2hXHuLkAesDsFCjJz4vnjcf6oetTsaqtjvAFA9CgL5wC9GnwQjwbmPnMOnQiR02TG6YSwSuGbqmY+sbjKApdHLGxwnVTwloMpscw+LXQUBLfukSgOj+ERE8EZW766ElYkuCsicHsyd9GD0BuncvnbNItyRCsgAv0dtp84AM5sj3ka2lX6p5YiI3uQ8oWtrXdvnzkkEr5ToeqoDp1ezdop6HeU8IJGQb2ONIuNFRnFVBuSF17wY69M6Za5cdM7IedJoaj6h8SmhPkCn5yiy3Hgftq0GDLWu3q0jbFK/HfL2KV21pb6uoWtHzht0Ulsm1eigKUbDdytuosou8LW4raB0PX0XueNcMcNRs+P6Rf3zj6jln3ATM5PcajeumZ8JtSdrfxajHNoTfQYq5W70SvgdeKeCwl4v/VmO34rWM9AYnAzgWRF4pmLhMC8DAy3sWK+OPK3upsyaK8zj4DTnYVSdwbYwDcTCTHJ7oPRiRxwdLTa/Ep8dGf268YIWnBfmLgBietk4xyyKN8fWqcpDGZOaHRfAUGkqPg16Z12Lzgw6Yj8D21e8E57XI5XhyXvoxAjUsRAnrSpIqOSVa5xfbPks/fTD4Ji6CKARJRK2nfA1hycxOREbOH/qxlM0b7XcHPPtJ0Hz8DYPntAw+zUNEarzwdwn7RF1ELeMblYu6gW3AHhT7iFPiJBmmsIcQJSO8ti7MBDTeEM41PGoNIGPLE9rzGpZWx4HpwWrLKP1AegTpUmmu6JWuAHmla6uQVWMbEojGnT9kI/o9DbXhZ6iPTvZanJT4EUAMu6MLp6Fqb0mnJ+Vw9TRsAqAjDK6rS22hnvZgyzpn8udVeT50be+P3h/uXKHkaXdPEHezNta/gjcQML35qCxHPWf6YzQl0U7nXGGwvF3Q3e3mk7kugXXFLsXNWo7TymuCjV8ulSuRLfsn4UYfkXcUqmbZ4fZmFtE+LWmA0ChgrmWHBFimSt8YMSq6agOTb2uQCYG1BYNB7oXt7Y0bLqV6o76Npc5i2KveS3S1NjWBmiepk8j7L3Tu96y6PR2eil+ajInNJp2D8xJXNV5WmlucUsHYuGaoSmeb6+GE+guDIgwkch7q+exvkAD2KFBxQkuuttghNYp4lvYSR2xzoneOJCx3vUzId63ltD4Pch+sjvBoc822697a58Djy87Gp1H6CeypE6Cc2xCIRRfFjRrmC6YalCLUDOUhwZLik/wAy2NYrU6OTLdk5HGOkIZJusbKRC0rkCEzZwrd3Z8z72OROz3XuP6g0HWtwCQzkDCrp8KbmIUOOYZWTbjlcpgwnFfAdAsINUBimWuhaA/efglSsrNdaQDQDQa85EH27c3B4CBXPUXV7fmFDozLIm3M/chrtqC34Vh+tQJXdHh43DAexFnR6PxoSEe5VV+IkjLUa7RZwVQCPV6kOFgTe+f9c/0UFCLQTuNdqjeD5nsRUOOwJ7mK8p/5VEfi7HapqsBaCiJyJ4f7+TsNHVBn1MHpkt5Rc/7shlLpUVgXrRQqt1OXLkzUEGjq1yg4GteXUysmQdzFJyKotcyQCeyk41Kfw7k90RHn6QO2H61ntX10UY9tCEmJtLnQnmueEuvMqKORbkFOd84K0VPNjV9JcUghdeJX3ogGano9NYkmEgELE8z/7OugJy49osRkMJAO4qpqaO9Bdqh74ox/OFqhrKjeXGHZWGfOxocXGsZt635gJVTHJj7ZtWr05GcdaRpGwQydb+wsau250lsZu/IEUN1Mgju1uRj4AO2wme79NGpU1VRReIYWQ7fvkcy3yeEGrdhUJngCoUv51EANo1lYAaCNiQxTtMnNRBbBazzsQFkCIoUlLuyQElIVZdJxGaH8xHrWSVlpdW9NE85yripWekUhg1Hkh5ez7W1/ZxKiYfCusUf7Kpe/D5hfmexqlz6yDg57VHn2LcAiADMrOgTSry/TGAYxE+L6EDXTaBcC50xZeUrNN7MPsZgbcxPfu/nJoL506RA16PRcWtdohSmFpTn5Kk1EGG4jw935hOh2L7j9qlAQQ6GbEDykocbQKzR9y3fi8RxGdaiOE2rFCHVPEmrBc2RPnW/Pkk/C2BTZUdttNsHo+ZcAIYIEfVXC1LJ1YuE3F6I90NqtkFpuYmWvGu8mqpAvkGd9OhAQAfO8AGOl1UwWja99QvnmnpZytfrOInJLUuezaf6q4tQ5OLB1ufE6TquNj4GBAoPKwlMqXOlwBiHxtlo2i0ANwDNikO8uYlHpv1WnwMdFzwx0u7Na6rn7DTOxjZ7/uAWtU4Gydwhw0Svb/4SBbPC2G9OMzt1quo4Jjnfuspxm3knu0Sgc1O+sXo+vy8UTnSI45hmvKsrPtsVVFIz0vAiE6063/OsLPu+Sx+saEQwi14piFakeyqkEHm+5/MJzDZptyqwQb0x5uyWtSB8Ewk8KHMDdFOFr+XS79gPCsxCRMQXW/veG6JrNm9YWaC8teVGx4xzjp4EJIVK38fVN8sQjVfQ4x7w1Wkaa7Cjf6XJa8/MxG6FvrdsJlpnVX7j2k3jnUDs16xtJn2XwNglXCoAnsHxUXuOnDb/IQh0Vkn9VqUf+xZ4hVwQ8abrbFcgUajjWI9tE08COBoYenJ+T+MpNBT3NSuPnNMfskBE9vIjNhVKXviL2MBOo2Cf/2KkQzSFKY6yJAbjRMvCHQwvKozKTQHPia5T5apv+TV6NdonNyFn4Uqjjp/taA6gI/bdyqf2xW8B4Jt1c5sz3YhtMnZ8VaSngEByCGVSo4MKAohctgaQvkZwQCT0Q++H1lagUVv+UlTM5yQI74YJTut3EBSNfI6Ad7VFjTS1/8V06zClOcE6UL8VB0r6BzNtldXqw/JZJgddDOBAS5X3wWhxnV/TPuMzVs/9kMMUlb40qzOM9Uy9a6MseinbGZyf+TtsDatpFZlGm0DEMFdTNyywgtERBNslH/8qf9ouDvue5mrmv6AtNUVaTq9lOhKH+NU5KA3l2DD0UXEBOgE6H+z6WHGVYZo8pqCvYAxCe436UpJHn8XaWa0yv66LhGRuq5ryEoAZwW919CcRLMAzaLuwD9hPn1WrfqFfWPts+SHfPdoOGniOyY3zDryttJcdHDlgnMd+9pVNX7P3fw622UECfR9S1T/yhSOczh0NvlN0w9nLNkxJesBHiISuoDxe18vKO+95DOq6PPLjYzAAgr8XYQjCjxvOuiciktcswO51F8mEFQzy49ouYzax5weC1z8VvMB1NZpvrfPmKdgYC7RXtNQhRcU2s+gQD9G5yXosRLknu6TGXPdeq5BpNAAFx4/iHYLq47OKvLHTOgkXFo++QH8jjlLBIXrxC/qM+z1He3/5y1/sqLr3+02499rqVOBDUQHE1pV2JcGF/JoGdAgOE0+a1JhfchkPCZE/ZNqMNwJHSe8pyArSFBpYZtPZnpGI/Cx04zsAWJkOjRa9jInEOp6572nrQ414Ed3hiOEVNwrlB9U63tcuYrTLahCZfKTlMtAZK2G3YJ5o7LRVj+5Bo5ObRnQJTUEdUbK7FRx3b7Rnukp3I/AgIltZIKIrc66NQioD6Y7cLUQB0DaaZuhvGYELDcK4IWXj+YQbbP7HM0HOtxEgRF7vZxtkdOOkxNxeZxzj1Mkr6yOXYW1Cx0hXCjP8GkdnIn9DXXZseU2DMgHQzKTAl/h2oGWfgRsa3eD2SeO0qI8zGW8DIF0gynmrvMgrv+guBdhG0tN83gbWRlvhla8zpyfHAwqcoM/GZleYASa2YJ9M5/+WN6nKY6gH+SEcJf1x4qArvt/3kF8G0EpSdM/osIQ6VGx0vkUAOBq6IRL5MWwQ8KvblKGvTaYj21OY42hYPUBGNOOTc9RUf4M9iZwA0gBVkPic63i4JQE9gPYF7Sc5VlIwazYU7JL3wMeOJi8orrA8wYGBsRUe+A3GwORo6rp5Hqr1TzcUMdE4ujeVJSLn9WSXs8oqtouEGGzgeKbk0gx0Czs/C5G/nVeyKE5IFp/nUh1rWKY4zxBUNZ0jsR9aq7NG0cVqn0M/pT7Yf5J+6mHwsyYSABQpE9XVxTahPumv18s8OyGit9wuwiq4Box4rnKsaPIB03OXc7qJxqkHF8/VE5m6wGkSEXvo8M5z+XFChn1+uVIomYCjClp+M7aNE5/P33NS6yETOO0IFdot1akA/fjxw8/Crq2REC0Pfst1dmlALg4G5Sv1YBrivAKOZ0LpxipdXUTluvIFLGK9TfnHrRebsrmOWu7TDTjQIsP30fpjqc+37yQw91D+KRLvkeifSxbRasYvAJ9tUwpwJ0NMw+bA74xONVU3rbcifpICKNvl28ncOUtYXMU/v8aTT875ICs7r3sSO34LoPEgWfQ1+xIpCpop/Tx1rs7Uelx1RI2wwm4FpnmownjzuQHSme/1etH7/u54Acj9dDWsy4/jcpNMv4H1FVfTRM2ZlGc2QxLzaqXzu29d0T7l+bH75GU/Tao7eOmYnCR7WwaFjiwSBh86LILJTub6kKLVvJvOBQcnPHEijqZd912kkfl34/is0iPfsdYVx876yi960cB3lm8zEMxX4JPcPpr6zoapk/dif14167/Vip/+jm1+zbZ94Ggk4jfjE5fFMHICfgDUWZbaujoVHZMPxjWPl7TtTe9ZA0RQ/KQr3WqhESNxvfmK5+srTfctw9uUGVFld2o0jxCRvONKDjvBoX/ICL0BsIpNUPSgt5IzR4tMgT0bw1LjnBRUlImibQpRjVQg9HOhXAOjzzH9448/HkHtHsRWYa85onOJQpXifXY/j5srEAVhdcQ4KblufIG9w/VcRy6ff180I2zdyyxNLpMShu9xJYNIV1OIiPjq5YSafgcaZ+dWz4v0iYnwiL1UdAccuvupNBD2/JzDlsoUhY6qvytQs3RcI3P/OdM8SV2RiczDsfHcDfZqM28Jz+2fLSHUvSS8NTwZRKz7h9tXK09YFG51ItQXkwE3ItvSLh/h9Sijse76YOjaODN8qixVY9mBpq/wIdoad04zkK7UkbU/54F9dTfKrs8/T37M9Xvda93neSDXrYeM+MqPbb8lHUFXAK3M68oCjyj4Cojidxx7EZmbeJkiuMZ69rrED5Lwk9vAWxm0M0S4rysdIOKMKkRJ5jLI2+u9SFn+MXc1UNqGs8AMnc1BO2X4R72xh2BNkJl0D/k4gOCcr3FismURGLmijWHbkm4ZDY4h2mrAYTllxzh0RE9UJTHhM7m64zs/UFu7jvU652JtsjFOg4jYrhdS3drgS0nlsmO1DV4GXimWalkO07Gj8Xmk0Mw4KLeerrWnGvB6QwdEpFWZG8dQ5eZSvz0K5EaQ2d+K++1yoAWKQJnimvRofozA74zIMnq6AFUnI3+n42LXyoMmXkFD6eLY0r9xXvJyntKO1z82qqrAAPiW/sibsmnra6zLjljivvFB4TVNNlfobEhuHVfr1mCkzHsaM5WbryZTniKBFzDic5JQXAXKZ0PdQ+VaUzaZz63jpyzHMyeN8D6ln3Ewch2tcl/Vn73K9icaPKiTlOtdxyUJt3zd9UHXNGZW5zwTf0GvXQUau/HPBrSLaBvsuqcIAACMe0lEQVRtnXJvaA1XMb9UCWEeq9jMfh/xnvf5oP7NvdU46VwZYGgUenVMVw2SHem5DR6lQNNTCjlsQLDfFxF3QQpZDBuOqJ5ys5JTjkAvVC+gU9Z7wJfglzby9pAU9PtC+5jEz4IXi7rz76SLsd5uJescdzVOyKgA2iH4foBHStr3/2cc5+qQwrO7i3nw+efWO3E4GG+6fEa9be+eOhjzji5tWwgDxfXha87XWuA3n5WR6mSs6FtS3ehKxDGnwelY5Wey8NGpU5i6gxCIkiIgffbBl/AAbi3LGZzfRSfM65ewX9L2PMtsU6u1LT26D1RLj7L6Rlzz0rUZ0X3yBApyRD5kbrRUT3WXAiA/iBzoexSUcXPenaHv6rU8VBnSbf5i3FumqnmhitBIqE/IvPtoULRfSuP8bQ6kmbLEeKnBJL92QhaCeauLzNH0/ni97CxDMxSkFAxFAzyi/DD2DKvCin2zX1mwgfQs/CFfSid52uvYbGYGOK88q8JwGoikXBkoF97D03GUtkjnV4IZWD5docIbSO+W1nUbnUOh13hGZA1OS9R9QXUhIGU9/CAZGjVKymg3gDFyQxkSbF1k0jo7/qt9Xgd8ooxPdg/2W7wz3rEMmkKbFVQNeW0KWiPavjfgYGM8C2ht8HzhJUc+D04adaPwk4nhYfoQmZ4Ul/HtQIaWrdcyKKwHyusqYNIx0s85JrMDc7uGGJPCs2mmTyPd6yh2eu/AyEwqAOoUIsY32u/bJ6/jNeyR6WeKNw9ke4xrrZiT7LTywexHDpe5rW9Ck6QMVjYan2td5YNqhq7gnpe0Robx6G18Twv2oWh1himzrkVsULGd0MOrcItt3ObNAQ1CtpntDQWbnNOoyz/VBdkeiEjLmzm4aTdtzvzZVCs7MY86Gn6dy2fFxKnNFe8k+oaoj+/Xgk+83QUsXKQvPaPhwlIFYAmK8DsguLVnFJ/liPIJAwuRqyDQaoTgYTHNFwAdRc+OdTXj+kbX66L7fdP3H9/pft/GDGjgVWQQNKzG4TTq5B3tl+w7g9NXsQaZWOcu5XlrhaapZ91Lj7bnulTosn3wqPlsZ062oIECWmPb6ZfIfCg2NpIjPB4FVY4RnxOoGWqY2zMR4BKtHlZcRUOe0jKaYej9oI7UZl2h6NsLRh2uPTW5XtF6JvbTyMnauO3pOnXsunxocDQKN1oFBU5kAwhYyn+vHMWG9qDHOML3Ubc/VMsGPENPjC/NwWuiyGXeRoNAa26ZS57VcyD5+l0CCE2S83U+Gx8hfwdIAK3+kCcTjWM3HkCd1f3h/XiKz0h5tbbDBV07dTVUSvlhp8S+Kw1nUIp9HqzOqBvztZ1dyGnMiepTpTWPF+QlTroY6pLG7m9A2S5lXBBpGTzTRtfNHmWQqUEHlcGqY1tMtPAVunHPVOYUynBss9jXFXtk/VjoWjbfJ9h6c/qM2FPwoyGrwYQSjJXp0DSnZaVhgbdWfFbsycK+Ko5RVamrwKPV3h6v+PkJg69GuYwZ8OUYl76U6psDsbJ07mjYBLkCKxOFimlJhB8d1rPHonn0RlPdJ/01gA7WRZfcVMau66Lr9aJvv/1G3377nb59+0Y/3m/6xz/+Qd+/fyfRN1SK+ACQG/vsfXY0aP5V2oG+7GTo+cmfKFQiAobW+YxzcRLZXEFME5jGSOmAnYDHXYTeosfir6cjUqejCmEZzzSORHG53+hnmLPGjkYnR0ezV3k5ArDsX9CEdT47xWPfOydBKE541+aC3/SagVXT3AhiHirXHKoihFpwxBzb38sKU2LifLfyXzIQmcezbJ06OJj/vm/S537iKkBePs+0rCpv+pXmvMikKiLyoalgrnH8gLYnLbIytudOIWdWNfJ3STWVdUWf3LWi+jcFIYT8WZSmjdPo6cqgdyAkgJdVe4u0IqcDuvl6qdr6/CynXleWbaerx6Kndhyc3hv5U4JqsWvs8/kRmEUqTnk0NwF4p7OvAuWwbz5GQ/Eifjc9sJl+lMNV8KElv+3bkw2v9x5BLDnuI6L0AslcNn5qnk+2BZ/plBUorsmxqhT5dRsVdfdxMj7G4M6Y73P96Lox6+2VQ/SE+1Z6Y5m/fMExGhMuOcND+mBFQyOz722up+7I9Pw5ooFx7wCIj3zQWGCcUWfwML3hGV0Qwn1fTOPt4/ztRd9e3+j12zf69u03ev32G71eL3r99hv9/pe/0B9//EHvHz/oxx/f6fsff9CPHz+I7vcAvTKVyMkAKOkfRMX6aPCZEJZ24KeXhuN8wxGmfftPQjOmtt433dlEAE5SBoO1J/2YhjJCNI5t7OcAFWiIcE7HVB0KrBv7y7ke0n7X8axKPI1z2xtPdz6GGcuCXBjFT/PW3NctfL7Kg7T3dWVQ7c79tOZ3Xc3C+egcjtgnIpC42Ic0aqvuRnD2BPx65wSTzwXROJ8JIUZcebtzHaLQxAEXAyDxaKevQowxa4BBKxq8HF8oOf9m8By6sU3ZKO7Hte5d7uqJ84/gBUCoZyZ/z1Ijy3wBP8z+bUjsHIs8hi2vMqe5kcBDHXjYjddKHgKtpBKBeo5A9kmV77K/HkTsD8lAgFl1zn5LsBM1rl0XwQow3CYO8pFlXkDvdBgi8g5RZI813hjjtx9/nPs7yYTbCPKH3MHxVWdJKMp/sWnsOEK7l4MEuS81QDLDhxsdvepj1imZL7Ffs8Da+loHcmM+JkW1bOZrmTZC3M2dFtnhzSenvtNRTGPL0Tia2U9HHfrcZR9Ms7UvxqwM93p+feprrLP25cnZ1JZZ7RAkfUniJ7iN6CvPaDR6yge6ATyYj9aGv63vEAh4pa5ZrCxTaDQY85n3/X7T3/7f/5e+/+MfdH170b/827/R//V//z/0r//Hv5KI0D++f6e///3vY8/oXNW4eGw/YOJxUpKoQCWGfogQLK+LUrsuo8+VaHu7iLQpro1XXItXA/eJZ3ySjueYotCEiGXMgbVbmWcjeNR8qp96OoLxRO+/Apcnek4FuqMjGD+jwEFtlyqAc8C7A9xL52kg3KM+PKWNClqmEGzY1n2uODNodIV+E/MF6K43wfh8G88Leo3xvl7oHGsdVxvfTjEfdynkr6t7EWDH6VzwNcdpr4bzUA8WAhPQz7WJQFscihVelI761I+UdBV56RQQ6KjNBBTARg2o+zAQo2UCPQgymEGcu3rjc3NmLxCwQL1de/na0jETH6uYF1dU0hxM+5oDR/kUpQx9n2j9NOCAdBf7vqkfr2XnsQe1Kv57YFiAZJNvxUu7a9WBISLiqh8WdJGs3z9DhLxE5oRhTEoxWkdjDShVW7rDRHL7CU3e4NDhpcyGjlTxjGf0PKG61J0VfCEzWejMn/PEf5+lLhASf88TyB5xUXVWP1RJRPSJo2GvPFkbgnKnIejEx9bTm9wDjM6D5RO32OALmoSK3mFtF5iRfJBffNH/+W//J8m//duIOBDR3/7jP+hvf/9bOFEKI7GhPXYmKUNgSiDv1f8aA3XjsLoG5AFYvK3V7OXWCJGOu3yJuT5Jp8D/GLOmfOaccOVgCyYAHerC6Wgh5mvLY2QnRTSdY/7c1NEWVlzcNj+m1mmh3iCWsk8AqSiBtVbgaXFiVA1eRIky/XG765SdibN+X05vOC2jL2vHzs7P9mmeHb0TOGPtcsfxYCLaH1ORfZnUIESwfKumrqwMPX3xRdc8IlxfrsnoaQhRd3pIGFNODk4HEJQeqg5kjbpiO4thZIKXzztzrAJdp+BamteiEY3VQXwxLCmg5r6/HQ35t77Dacv3NzAaczoyPcPyAIsmYJTmPtn9Gc841+GDqNkfp98cQXRS4yQHPa3Re6NTf0XseOSwnTp0J+9E7vCK9m8J7FY8ethWuEZfq+u3334z7NUCVYEXXs52L9bDfb0DGmshPO4X0nVd82AzBL3RfjJf9KJrmi2Zx80v3Zojxw0TLwbJThwNDiiRrTqro9DW6gfPBBQ1eVr1lztYyr+X9oJcvs5ncRn0AKfivn+4XNiXeEpmHrKBGxzp6gs8hzN0RJqlLx9v200UnlKh6YIpWRmG7loFwUnpGxGJzkIW5A9tOQCPDKxbTSZn3GPLyO/ffht35zMaIkIs7+EZ33HwhRYKIPQhUpoFesVmO6VZV0V+1jvYz1FbojHGXZTudCkPkxdZCBZel0ZwSrTeDf6m1SPaCOUR2oIZPq/rMD0pU4z6EbSeR6+tx4aFixN2SpuCkDpbeW7i2Dy2w7VvRABWcrrO6+7ka8WrGAxRoyEKqiedffShwLXYjwdaS7UP4vM0axFortNf//pX+u233+gvf/kL/f777+Olau83/fjxg/744w/6448/6D//8z/Ds2Mhuq3zIMNJya7VJxH81YpGMJwa/GHn5TC21tZ9LJ4IIjMvGD1JF3h7e7u3sn9Pv5Hvn/RqHqei/uC6/QzObDdIkvKUu5H+QGuDbow4Bnqk2PvhSPtRLAoADV5txhOvHa8aoX5vHS6NSI/7T/MaVg7Merlea0f6oU9GXYEC1QbnpC8uXo5HUjzY39EG+ZdkM0L76FQsuAZXUGjKap8XxrCRgeUqlqK8jT3AVwbIzWXccskVXsMB8kAnOhS5XX08QQKNX9GPbWqAAJtNjc97xTG/iM3t+wzLHDsaFwxPD911WCaxk8gA/lQANX8ZDFWYTNe1nohfnbKNYRovybpBcN7ffzgjW4QHHvYyQFX34Fk7pb8uhDli23rlrHvkxiygMVhCkqmrUXAx0tPT1dRkdjkfS+t1dYY39wECZEEZ7qKFTa+IGBV5pPPThJyd988zc9gCqgYhuCwMtUy6BOYHS+/6xyOLgZVjA4gttOBCARdYioeqhVwuOrxswIlC9+1e4N/HbvjJMnHFsDcYpn9CtCU2Yr8Y4WUiNPdn8/t4LozBWRtv2orkGjjFPEJl6/FN/VYEPJ7ZXqo228DnamJkOlRA/STFa3/88V/0/fsf9F//9Z+mn4cxnrJz3zS2j2lZ0FGsWzNxuwAY8gUJYR7uPA9+OpwCXSGa7wSBvBMQ4Qs6YzUOjAL4m/OoRlgxQ/BR2rEalaEb1bIPzgfqTuvy589ttBFktEcIBhP9ONQDRIKeFwVMQ1bdl87Ws9K5k5z6UsUMGBVDTFuWVtdvpHHii6/YgH2az4YgkzbPBaCNtVMvc01gc7OOuWb1/YitAHmTL9MmsbTilhyruZsj+oteTHS7Bma6L6VJfJgAJNN0BNXhFkJ7HeetBHsKZaF7hdb1Dg+A+ZhFJAhsWdWRyxxZbNd1XaR2z4Ollnl1Yme7UznhY+eYiMYW//es82CMtkngBbDnO10+OHXKlbYPy76VuBR0gDeoMsvSuVa5b+Qq5BNKDO3lTX+5fiB/LGzGSiYBt9QlM+2/VuUACFuqGyJcySjTZAH3CtwkO6qTdHPX/136DMi6wX2qa6Vgh/COulb39xR4XqIokjXXmpbcruclSiw7QUilF7NlzCJExwKY6VwB+1V6HDc1XNzL6yOgVmPEvWLywEGc/2BQnztB5lgl52SlWF1k42iF8TjUo1vnbzO+tdwY42jUmxWSgZjCnBd6JxOd9CcHKax88ATXtPd63M2cP8t2E9HbVipsGwHHaF83nE7jWMkAc+/0bst1FEa5mW6B0S1qusGRSJUvBc15OBrTGBmOVeVkz0M1MmDOOPTFwA848RrcWaWPAMfhNb/nsmUOAfdTdRIxx3T76ND0IKCymUfA+UmOoLazsiWa9zSAtZXx4Fh2Wj/WcYpzEMi6Tdvry9q3OAa6OlLKBULJeLsT1iVglxhd97r1mmXr+8rsRxtblShc2R4fjKRioFSuBgz0ptPPkN96kYZjtypYri/4Pl6r9swCv6WB9bOQ+l1EbPtkpiVWp9IcD17J9T6u+JOalmS7HtIHp06NydDIjve3UTsA3FWXc85pwGUNEomeOp7NlcRPoKPaXE4T64w27JJAAEMaWj21TgDSxv49L72hcfS8GwOoZRfj0rWxSwgUtN7eUSBj0BPwLgul5L/RgLui2jG88ZFIKucmK4D+ETop9eSFv7IkG6tfpoALwRGPTaLSTnm7evDLQcThaS5ALS0VzE7GwpjuRfWjeq0a5sLTOQp6psxcPlfGNtf01MbTKkd3b9A+T1SBvrWz1OqltvIeLEP9msJvBTKpXKeLh6iI/24cxxgcIaihB3zrJK5Q2lRBp91ZGXNq5Cj3o29hcWEvW9kBRvnX0dCtCFhNr9VAN4zKUvtrcNvRVcFJba/vMFakf6RmkX0k8yhgxHNlZCGTCtlhWM3txd+nUdkT8N8RmmXH6muA1pjz6Sws6HoKyJX6nwJB2H5BrCVHyOefNPXQlCLOJWD8eFP9pE1XFInIXma7KpP7eWo3artAKciNzZIgZ1W9LhpYEb9mn1AEg7pOp6RrFdvU1F2X+JXj/JdVlnQt1AiYc2actlwlK7XcjDuOx6iLh36bevWTIMeHL+zTzjlxeN0fhhyXmDi+iEkI3qY9iUemTkryqSO61EgEykt8n6YtugrZcXQiAm8rnxf1beJQn9UZ1FumB64qg/nl2d74gy/1Uw+UBemmyVg0tNvi5AJtL4wT5gkC/nkqhpPOlbnm7ZwMnkdLojPR17+b/7xGRsZACsTumL1AoAEEJ3BCHgSFGOxtiNQ2DwUn3eAMgA6G1rqzzppZFUEFYqfAnSiCxidW0Plq5S3zsl6zrA+gojEgR44qqkTLvnqbLAJefTTRLWIctqRjGgPylPb8O+lgNjAteJ0UIKF9rCshpCBMnaYJYFfAB8spH/o0pc6hrqq9K/1U3riuV6sfqpQBO68CIskZfILSS3O9c5IZaJU5dhM4GI7+ENNYfYvfQwdLmvd1HW0ejbBe7D+1/kZ/tvXmQikVNZZZxL49vcEZ8h6MZQUz6V4Zt2DdfIvl/Hs1erLQeDjPZcdRBmtt5fF+tjWnOs8DuAe60RRHtrE7Sq9wn1PfhIRuAWBt15FGogtspNrRsKqoQQnsc6hPgxaP0/aY4qpgJTrC7y8IujWE9fuhvMugLLRWbcXYOtpP1cQIojiFKR7J3fMHjr/j7z5foOuqROQVJqNb8dHs3Kdz96U3gx8l5NeE3oIDSni9ox4NX9cMd1lrZplMrp/qbBDNB75B8Nhr1YnL+xcxWjlAxXBmHH9J+BTqFUFrpGgP+pbLvOSK3x25KBQZSBsdJpYVSGd4326hSYC8aYBs5aZxKJ8jN43gjIwwLtTzldJY6tcTmVyXKAisJdYAM1O2BT/S5BEi5s7ArttfOgZfUN4YFcGUeSfz9qkDmvdNo9w8kRuAzAeJFVQWqJ3GeWFUa2UxD/KUpLwKYkM/RbeBAM+w810myepFsKxGiObYz0wC+krUIASSOgUMfTvgGWaGB0XjM3TZqNq2hMAfU9/KM1iOvO999r54yytYqm2VmlUHZmCdeP3PTr1+x7alzVeDfLmK2g/RQW8JsZIgaE+bojepKMNMW+9ghlYnkLlAv65m+b77aPl6VXOVOvAHPJ74ouO9QGHrkFcaoYS1uKNag12iCoRAPwe5jt3YHQerKb8AuNplHGspeZSGHIXP+ifwI8xxAMp2a6OfZPE9pW5MS/91jLqIUxjW2Df87PudKdGxqh1A2GGjMh2OFfb4RF91Tn52UjMPXXSRB8Fuyqscp4DjS89oPGZ1Oi1KsSYLH54+31PZtcZE9kxGfcisNFtrYWD4lF3fWbHyKIUU6ELvjZkaIRdcFjbrAdQkBnoaD/GWEJyp8vBs1QDLpt9EOqa3devjpU2iAE47Z8PaWgoOAA+vlG69vrKjUCwrMqimBY5PSv9GZWJgbzU2OrpuNscVtsgrTxB0coTik5NxMrY/C6ielrkHqAOwbzww/lg/v+JJjBpdxLQeNGpJl4iWCKw0FOk7PVSqGaLsxE/vDFCkBMEbH3mubgTO1eiSjWFU9IAjSJk3B5ssj+MzKyNA21XNLPTFAWZwhJq5vfii9wy43O94fPPFF72uy8e4TepsnOj4qQOhpNVi7UbAGuZZWaCrWc5Ybrf9ZeeYl+vjpjd+mGobFZi27U2bq89PCevjv1h3bCdEsnfLe7Ne7CrDPwm8FWk32WAKKxMekWXnc/ZdCIHGlK4if2L/7kmcx6CfUwSLKLPZcTDtXXp6wt+rVXxz0kutsW5caSpOTW5WXFaegp1dnUUHAv9PFVpA9qreUI/pazL7HGkYN7gU9KRyH3XOBfa4LVZmzeyUxBKqpx3WGcqi/Gyt7wxA+qe+MR1/zcbviYMa6gKP1XEMOytE3CFPesmdiMHL2Z7VIIB3XbnrguCAxbp4Pv32wTaAX7aisV0izBG1X5h02vX7amuBnh2ejeAwAraZyq/ldh4MhDj/lfqXALek+mDtadrR7A/VPUeQ27qn4Top2ykcojG2GYiveGbnpSNwVYNXzHFjfFYsaMbNCU33iWhDT5P7KHWRnxZV/WRajW2nkA5q+2k6NJrl0PrrtZZyapgW3fnVWqgfN4RZa6BKU3F/MtU2dzh4O9omCc5W6uRfZL7Qh8m2fSbZNZ5qluO/mrYyp07RQwCsm/M/0RwtUtJHtNdxRHo0MGzvPW0pRIqfrUkFlL9mYDKIk3zzg245YItOOdG0bZRkkYdOz07Ip6kcZtPoTdzyeOJ81ij4Aw1LPY2Byq/bnXz9qa6bxE7dFFNgnb1VkKtOaVoRSvpnx3prKdndrXm7nGEFR9/WAfymLbyaPuJnnZv4LLPYcft6ciAe1yuhrNY7dPWLfjaZg3+QcKNkXr25bzj1MMnhUzp3NBoGrEwZBywI6uXeeowKEL2lOVaUzP9LnpnY7CnzmGlnCcoAmSsvEWnd6pNGr9U/9Yjb5uwoAzZ2P4WixzGAw/Pz7o2eoXziu1iHl9yBJQeieEvrUVHREVeAfIuQ6JsmG1BOs9/e/5jjEn8Q1cwFzh9TOHbSHoS73K1TWsbd2zx8nAurT2apG1ZQdCYbvvZXYNkIwtSM9o2HmKKym503UzHBWTAc1vdGOdM80pOJiC9/CA6cMp2LLnIht8qIzg1G6Dn2t5s4lBmI5mKkKJ7nPjlk3neScGwRoOA86ylsdRQqTUo7k9Btss3ExK85XwsAZbIrHhQQ+4cHJpApbGKqwRX47Qax68C7lSflIZ6OEYU8vOj62DNe9CI66SLeRupzagSacIPEHPkdaokFCYbYol9X5HcYX5t1BW6UVhMmn+gZ+L4apSGcC+TLNHKNfCtfTH53Xe7rLqutCKNG1UE864c8OBxwXW2OBYPmClOoW198d9+2FU3IVEKJumd+a6wjqYW5xYM9fvTwIEY1pJscBjn11c6yZSENrNL7xkyMc7dPSi1YDyLV1dZB189hr729R4qJr4vE3gPg46x/xzDerW2O1Iw02GnSxEIs6IA5DcSTJ5X9LuQVqNr4GFqa7b+pzqOu5AewZvRKKOFOUIp0szXr2YHHPPou9sLNjJFyukkMlNSVDC591hcuZ9nC4VV9rVWE/ojq32v0B/Xr4r05F8e3qEVncDyrgN2UZJ+7xCz20kCZMnTNFQwyfYJ6hUyeUf+MsRi0v2ddV8L0KAnWCxEbD4JxV+fKt9iP0lcJvNzLuY0999Zfhp1GvxSW2POFBAH0OW/x9D08khZaCDzSyAoJzTcrEtE43Urt8FHcFdJHL+x7jurX+wIMViMC/sVxAHjWyWtctaedz3njmEloZzbsmjgP+rQwPlk91Jy1+Oec/RuUGQFTjO5GQzdsiv7Wt2lK5XJsJ//mrohfKKADy6P+zDqLaAIlATQS87fgU7AsKH2rHbaiZbqzYViMg9MZgZNewaKRh4BH3NrND+1U7VONTsX7OwFEACZJqD0IyYGnKUWfyjB0kSmoS9uyejMPBusHzNokFcfHCJz9TcxiHQBh0P4LEV36DJGZ3LXEiRe06TKlm5oj6CZtWQnKxUjlSRnbCrWsE2gxNNSZMshdhhB51NvNVPa6mucY4UAlfoN6QnkAVqstqdVIdrXm3KCfaiW1Osqg9GRmUtnIenpjXDO9L20+D4wkpDXr0LsS5tW3CAqQLACckYZxWeq0P+jBED6FJHZvVSxqUGacO2fAdBhtQ9wsJZCj0Dt1UcMfWMBJyC1pcAQClpzAaioWgLUyWdIFjaZqbmAh0Ms4qVqsBCYwG8iuEwl6IUhyW19LJ6ZCE2KulHlpeOO1ar/RGCzqR5OSmh1gGfUDl953/O44z+/b9Cd8afdEYKV10C4wRhiIi8NTLZBtl2rgmToZYZUkOHYxEH6CKcZD/P6zs6wSeJPC97BTgqixC9gBCC1yXIV09YLPCJ2nP+9hcEhrR2F8DrXMbZCzbP0gZ+a8CpJTJ/ChblM6vSDHOa9bh7r9oYraOTFxrXkwUUunRmmw3iZZuRvug/DZVW4YUXQssR1yBZ6o7bogVTLd0LjlCnPmCuYmEQvJUG6xKsRqDhCUdikA9yDwbjStTgXkQTueSVNnsKI5iYa4U7DZ0AuSsWq3GXt73CePVQYb0+huMEhp42R/r415CCh4ufu+RwQqEDK0WDRbVe6Xd3qb2vbrdI/ySZ7d2Kwc2/B7iXBGHtOPybF4Infdn+7ZAn7QVVh65O+ILrp4giqheOJerCxaRnRmReaDviEAoPSS0VtWuRbJgjvcyGByzLotRLZ3vpmTpjWoEyU86en55usg+zoAQxHjoz6P7a6CgbvxQT3lMrYBplmfoaaRDjh14ypmf27QmMwrOTN8XyXJAimTlgCqOozLs6/s/VeT1QXhOJ6iaNchWBKeFWoxTCGiyYM2IfJ7l8J4IKi0+9ooW4Q7tAflUJ5WNOHaRB2nq2AWbwdX6U0tmGwoN60RWJrxENBBBC4hd3UQIg7AHI7jzux920CXhX2b8mrLmuaLtGFSnq66e29z4m/TQA91rBI6R3fZ8/acjh2N/Z60n0sqWPcSMi7KNYp1GwFOCUsulTRGhlPpxmbD16SgQuEoWpUJF+At05+UE/7webraCI/SaA4DmW2LbQSPpJkd6QXFvzpyqAZ8pWK2CKzk1C8ZQBCtx87vATVZUXPMu6pjFIZhIl+q3YG33SOKVs+KvgeeEMjn7bVEmMndyVJYGdmkZUSp5ozf508JvJvax5JPwp3u51WkXD9eWynssu3gKQCQG+xIXPDVii+/aii6sk6h+FHbT4ntT6jTNQgAyvnRgb1Owp287m6e0Ph1R7uvkn8EJWLrzESLE45mI5MvKyBTt/rOraduoh4mvfXQuTMn2Wp7CL5lMHbYJvTD9ESqE++tQGWxPQIRYno+Rar17YXmnMCoqvNKzhBm+xa2ckHygoakP3ihAsnnI+gdCaPW6ymlb8pjDmyMrgD2yGPb9LNfKdWyANCLU6ZOxjP/nMgq0tI9U1vLJ+W1mbZOf37BzdDCYWLRKV0FtD7R16O+9dEwO5tcAl3AUzjGebwfnZf0+Rj1mukDR6P/jXSdDGLspF8fDxnKXL5xpjYct+gwpjBwq/bXhLV0gnht60JQaUrx0UD4tEWv9Ukc17Q4MJ1CwKBn1PY7l0S4dwo2SttOr0UOQemgAzCEMJ6YodGXvLoSG+mJU2UruSOjsSU47AW0mkemNV9XQdU97FeqrZaz7yunSu3hVGYd+N0CXphjVIgP8K3QWFaFsh7Aep6EbgX+tZ3Oecf7J0pNzoMVneJfgvFDhfpJGjJZDZ9+ZkOCUSWXtyjPs5bQyp70aIR2jhjSCzPXgqKswQJlWXFmimTc4AJo/P4OLq+SA8m1zK1p2m+Ny8Qhb9lckm7Ja0Ym4zql8sG+njm/YBPTxJR5euJzQGWjj7muDNuUudjGxfuTsjZk22pG6gtpWzg+CKxX9TU3GT6VRzLQXrFGD/LuZq7WtOlq82pFZ+sIqKlT2q3OBb21+ZpsnMJTtjbfT8Hm1X3HctaI1Y7PE5SdCmuWxlzNTQ8urB1V6OGBx7HEuLPP11YO+zpEAPPiHK/JgAx7flkGozu6Lq72PYB0Xrb5lD5e0YArxVkg6gFBFxnNwJKI5oOULjABeBhzxn3F7wnrdN/sV4DyKj0NZ1gJgN+m0RMuE1GgrVSityqLT03cKxprjyiFKUgUgQsKQGW4HPVuVwWeDl0FHl0ufkzA/HrBcyhYpsmfCIv35wNurmyBiIfTb45X5lZjnsvqeBMRb8YqOOaUgWK89yTU+9USy9WAw0D2MpoR2lCw0FVArsyLIW/aLg+2HialT5/Zs73veV4+qPMsIox8+lw7OgTtConS6Mh3SU91MpSO+v1LvlCpX0FP49hxnkdUOb71UOQO4qpGNB/bEMloACD7WgDSGB6dfkSr2f7Ua4M26NOypk1inseAb/QFjQdXS7TR7ucr0SXaRoobp9mTP6DKxdE5Tz425RwpI17SCEYnhlCxkUg8ZKWTY9UpZVVR/8ChEdfkvxvmeDXPXXJAnWliovwsDXk/uhTsizhG63UwHKG6Yb5u/pncNIaeSnTkwipTcd76OlW+hkz7+IddHoArVsT7FiK/dlMMnqEcwwzbtbCyT4GNCJ8DjkXHICgficQjk1sneQ4mOle7JCL1IBJ10DZ2Feu+jbWS7hCh1dEfbj9SR5r6nxLuysByRR4FxmjhFK/SL3tGY7eMg0mPR8RyRP4gTV56ilG8+XuxrJYZsKTEWHhpGRE6GEsX4DZWNeudFMua8Ywg6YHwCoR4vijMZuzBWpVVnzRgkj5nrWt6mxTpuqJAi8T21WQlBVbnIWvSPkWF8yyAPs7rOk+j3PERYsvV/HQFsQUPBsinGkR9sFTs4DRyn+OraetobfLVDPZHa7LfzpMh85+UTGNUcr5cZSeAfk/s+nM9SzWWARTkRYPfTk8zN5JoRAJDbhiucI3qddfFAve9Al2JDC+6CanZDmI6IvfX9V+XcJXlsR8lo9NjVxeA7yTMtXIyxj3yCL7QdivxRoS6oUyAv6HfQBGySFMRKV/F8XawciL7VPllUwyBz337iVUasCTmYNeCx3AQGNC6h2w2+ZuAgKa8qt2B5y3gnO1mp8vqygJoVTzwY3AGQN4eyh0lmEOUydy25Qm6RKLaBdzYbjmSnqlNfRSiIJUVFQ0GoGOS9I+yTBCwTg9MrNU0a7zUpMwjAtf1n2HhRR2xrc1NBt4DytuteMwk8FLqztYHzbvSNYv0SxyNztv9NPlbZxtDukmrXBihwk9M3Uk1p/X/GWkcbEtEJE5/I8jVCGvmegnte+lLuYAKIRrnJLLtwBQhMr4YNfn8ruNKK6XdLZOUKCTStPPlDhzir6SzGj9pF/s/JrGBf5Dng6r/ySli7kS/vQTpC3X+HFnUo86frU9TdAbsqvTyc5r2RX+Bx/TBfHS5qraiXpGEZvJMZmAxpTwEmlYUpJoUwKM/1bQWoIckkh+acRz36Zg3jq419j4S9e57i08fgimR9NZieiXsD/k+9hjsbMCNB0M1gk63B58SiOPrVQ5lycfU71YxVuQaD+tKwIOiQaB4ttI806belQt+nobM3ELz3AF1h7+ga79ARF3Xz1u1I27M+PGEr6Jd2aV5KiS0XXBVO9H731Xcz8Kyhld0xQUwLzoHj3z3cN0dmXVdu63hbUOyb7tLx47GdV0tiHxKp3ugNa8y3Pv9bgdf65BJ07uJGMI0LYXVo708jcp+z/vKCyz9SpFGbC/6lbWdoRZq26eR5JwnRFfCvb4Metf43WjYRYgWqy0YOWBuHtZ+6EOgbmFQhPwWRvGHgerrzBEfpBnz6rL26n5IEudvtxoVeva0qkHDSGDddr3MhzTf1qlbBu/paK7h6lRjKHIbMbqdM1EYZ9b3GsizPLpskb1MKuc9Nf67MTuVOyIKfIMAtKvhS7r0oIxFCVM7WTbbaPCBFYk8nMBqAqCBhukzcAyfB57uVnRbmSn8248Ldi8/C6TRPCGwQaHQMzTTLTJIwZOt0x6ZbiVwijb80tYHE9etq2rl2ke/5MhfBG1w7YNo3xo5eA4yyhwfP2nIeMDaX83dfM7vjtBV+afwM9A7c5qj9bzaCjw4a7FzwxCPzInqIvHLiPGi7e7FgiJz2wwg6eBgJZXatbu1KxudijoUV1X8iBNS2PSQFs+HcbQd2H6+lgPGpBQgBm7YLshvaHNPb25rl9iHIl4/VZ4NFon1wzHObfsRn/SNTBa6V3gh2XGoO+ZXN+0zvaTp/BmN+6YBFml+MgB7eKQVx0TiQy6q5DWtIgA866RbSN80cjeKTJcDj7xtYAqhyYNMoJTtDrYQ24L+56HORm4F8lXhRsXKxlSrCfx0pUiZpzCxUBmwAr7pUFg2ae8lq0KL14vjVRy1/jruGG63XXnuMSZR/xypl9PtU929APYoPjDWLbXnsqcp13VSx0nwYMhpj21PjFs1HspnXYTJgd/Ik8YxA0+rem1Elv16CImZXsgO7zLNvI+g6ydTAeibJEJC8SVSfiuVRP4L5SGLZY2RXp3RIVsc9LKBIqg9Pmaaxwqj61rJ7UrbwyAF6AnoVtc1DaiadFlNhzJSbVYEmPEZBZQt/D2e1lhNnOkFCMWvgGqOBq/kue4SqDQqoZ3tCnOXdKiCcLcxvU7rPPpOtpd9uMZLUd3W8gxIZFAE6Zb50sO04vDobwi87kdIX3R5yRXlYQHc8v1PQf8gPYJIfPjdgwYotl/XOUxE9L6ToYX70/k0uRKx0Nc9achjgdKHelzr6/iVUW+MjM5P4HAhVtmlgHv2GS3TVsM389n1m6Bv7fyC+uvstgbTLcB491vLngLgS8PdlpFAF44wPqeDevM0nW+dMkUZ94pHQYDsuXOiKng9QcgUnXkwZQp5s38liRl1wtz9BAiddCBGd/qEhq5O+HlkUhVENLSxL59NpUUTkwKvkaZnIGhE4k+8tjDKT/0P/Z1DaL3dRFisyeJsiGMPFYunOehuT4e1XpYFTOlpfsq3cyS7OruI858KYL+YToxpyD/LhKMQNmBfmnxlleQLrrEQefQuKNec66MaPx+PDqyMCuI1MPIndbmxqnlOaQugKtfTytL4w03BtWZzq9Dzt28qRRukEcqs36Lu2w0Xz/dUoC35GigcNnoHVBCZ74IhTf5NykEiBCo5j3/fOOXU80t2bE9krcxl9TiXKQce9PvFeIjMRbTZhmu6IxGc59kgZvV3CaMZqre6wVvp5+eVnnUqeIqrzO2qdjkfHemcUatf2wueywCeK8faS8brlfd2K2kL2guBC36m+g6ffrwBXZnuaDDHlqoznX4Pj6zI5lNdbbCVeh2ey2F9yItdsHNZx2yoIvVI0Vds7cfPaJxEdreCJc50JXIxlbUyQ1eLOQ52Acr4JfDDyIxJaDO5ZSvvEycxqRDyqj5xMqpX2uN8jhlOtXtTvjvHwX/XY986kGP50fPFWg9oi86hl/9E4FFBGPQAI98UmBU6ZP0UOhII6zrTTB+Mw7ZOuH+y6tDVhaDjSdnldlqjEM7arHXk7yvDotui4joPm25InRgvfJvKW3M3PSEE+bnNfo6eOeGEV4o8n5SXxd0CCldFgScTCIyZEcRHmldyHuqB6hVodUZanei2tqavzM01COJkncXEtBQ/CBAVQ136h3qRJpCiYJdyuS76ukq4LasA/MDf+3HHrj4Bli6dgJusj1e9q0G9Hmg/Uic+qx15nQ3uI7iDR67rolvqeJ9gFGp7EZMFBG3FBK9X7JLHxkk3BJfuJQc5t3/hiVsQ5VbQ+MAPUf8pgDjgYdP3WDb2ydXOWi6xrn6+tdKqktFmBdV9IAMekJmVTyetNpxrN3ICwZ/YXK0TefITB6tvY/5p+7Ce02z/UL/1efGlnb82felh8Oy9o+F5VMg2XqhUQCHbT5kOxAMQW9HIRDKjH6hIXYiAZtsPDgL1VD8IxE6YrJ6G2Zyujtmb0wlkL2hZnlYdUCHkWUjafFGRmrErbWpFa7pK8NkclcXZ1qa44RJLeJkbEdH9AQBg+NI7Nptxfaxda/hAiVNUQp1MdZ9YdhW5+ErqHJIoD0zxsNG+jk/aG/WSfYr+W4DoXF4NbpSSM32hhr6LAnX5c4Dj1HicgqDc3u7eqeNZS1aapclleXT4mfx5qNKedRA/wu3iU8y3A1Z9KxQf3b3tDjo5gw5tVse1cuXTmKtzFOImB6lzJM4KFjenTxNYdIGCTwIPOX/MK+4cLHR7W8+BQ4GR8446H7ZnGRr9xhWsrCdr2yuasNxTJ1y3RB1IdDd0CNyP10q9RtD404Fpb5+bglj8OYCkn/YcyI7tlniOYKDzaw18VbFzEO3aHRs22SO0vdXmFayEDsiJ7kvghrErOx5o9OMqZVuAW9wynTpOTK5T74aOuBpFpDstFbM5cdHmFYmDrNb2AjNlft/1M/frKR07GtXmy1wiGt9nLirGXsd8gtuLrgbsOVOreN8N08a6pZwuQRxZNrJvTJmZO57LEamnaNkQOG/cFE8mYkeYtZXzSJiExp6vK4Q8TOT9xboPjuCKqySpOXTgQpkFVjSJR4n0m1l/av9WzL6K2ruDpApdbAyUQO6UMNc6tDNhSozeeCJUB1xPI214/Sgy2ebIBR5uHymNmmdVKke+LMAkRO/3G/Jx+Fyl5dxWpNGg3Y5ql83IxnXeTtIuCtul0/o7B/OTFVTUiaXuhp4O8IhI+3bjooNOxgAAXJfHVXp120HFLCiIdO9pifddB2jUOObpxjvwijES6i4EBGe0ImkINDKY6+xn7tM6yVpwn9IDSNs63QTDlIA2ppNVfxGBY0DPt3LsAjZ4raMJgS/Wh0G4/L4pDer19lkf3O8dPd2Ck6Iji76snZvnu119zf2AWsn7lSsPaJ7MTtbes+FDgztf4MudPkwIw/KPe2nem7JP7Yb8oA9WNJUgARORnkK4yL+W5a53i8sCOrc4KlCsg2MzYZWrAOgqnT8MTjLeHGgNURSCQCSAP2JH3yvbA61kEO5AREV1Kl9V6tC4q+VR6Q0K1WU1Ljt2qxhdyp41kNj2hiUZO+zaLZO+kccfjoUGEghHx6CLPO8iNcFAkTsbeoHhS+dy2Zg1yebY6g3D0ApKphWDkasdtwZUFzTskir7a9KnLxRTEsbqEdSHjab6a0txjqShZ6sIP3QyutxbI5teNNVF4vx3qheikoi70mvUCiEYGECe1jrkRjbPWxp7BR4cEpTF7GyYUdvwxFS6JEQ8ne7mfXExPchAU8AbC9VAPwj5oj+FZU3OKbSi3nov+tNhYowgcryxdTa0rMy8cBVbg2tJT9irGbH+luIvJRzDi3IEHp5FFFxVqJBJpq62Hli5LeG9zIXaO2di9duHeLVKioERA7isIvQ8jjnyXNtHO4Y2AXp0TWvXOKWZ3qI3JRw7E2z9ytl4cspR/vxaltMKrFrnEAEc8I7eJs7lhfCFg0aF1qWGUdKIt7a/B53m6NwOQKSjvysHfVO4551ROhXrQOFqEogW85M6li/s6VrnGv8maFrA8aX8ESVc+NBm4a8HEiNPD2kMY5bsZ8QCCdBC7xQjLh0EiVM3aIkZl4cuWUuOsj9Z0fjoiOk8+LuoUV4xyP9W9aBSX0Y7J9dz+o0/9fFB/Dcb+KTLha5PBndVD5LxaX1Kg7535FPP0uogKhz51a49RkKeKs7Tu+CZr4y/85DSca5A/menX8FvOLYlmrIqcujgfJmk3bAXnpT2c1dBBIzaaKf/E2D5QlrT8zx3Hcg5q/uD1EXJfr7WZeqi0f87poCzrE8Le0TAWwlgfirDvZPxeepWPH52WhzYf80BXgacPk5cB/wXp05X/irbH7+na2jrIMdXbf0oP+u7ZT7T8iFP/go79FFaz+lX7P8ph+R8X+Wsnx2v3UrISbVVrPqelNW5xoFY5fk0fekZDdzr9ZTn0zqXkVyIeFoZvL+q+NLynkmPzrzQQ1+0qd66rUgkA5TzY4Q/L+KUaJ97P6V9ZiaWvBC7SgCYpNKFh1tiGQt22zjkiGK9RoQeLjJkKlcLbQwUzO0itMwQ39SVoFV0Kf7WN86rx9/PD2skoHF6jMIdaFMGa8jv5ICZKW8rXw1PC5yhnlVhi7QuKhbtsEY1EzEy50wjJaVt0jiVHJ0gFcotnBmMyuyUmkbXrwkA35Y3Rne0L3ZRAxSwZ/g5jkYlkPGUtR9yDnmImPzZglxrF518ancxYiXi1ox9mv8pWWF1yJ5lQ2cd5Z451r3jW/gbCVkUSCW9zaf8z3WMZr3HndMw9A0GLrJ9u0wSavS7IeFDe/0JSC/tbyHT+gSqZdvwN3+VJr/k31THcQeualmadgL1rYw3qTPRq0UGe12itGBel+MaHLVPofJ+S10tfUqKFVB7DqcAgmPP1WCN8D0fN+zBxbyavaKtSwzjDU21ShS3WnkxtfVXKxj1yZjYGpPLI94r7JCJ7roTTcb4Ks6favO7ud+teMgc6C6IXklb4+TyBKLaLpXohMNNT1Ea2nmBoZ4yCBxb264CDhI+ChR88IzGesDyKkSnFLMwrxm5toOKyPdDRuYpsiOKWaPyCHQbyuz7ZkZHHByFWsSFd6fLVTjyNacjgiOrboTha33dBAf7Hh8y6x9SZmvQFv256YrkQfY2vHNN7WCtfQVF8s1I/4K3FeoP+xK3NIzqsqCjEoi1aFPhm8Sv0XmoAM7ebO6Sa10TuZey0l/P4JMc4C94Soeq3N4Auy09WpmWn3yXZaGjYxSPtD6tlozz4SffrZRv+t3lMdpDHjRAc/5mYMHLJJ7meG3HT7t+YdXrIh0IUp5qLF9pp9e/P5N2pRWqjrZxzCfTJFJXUdewIrCjARzbLuiUywan5zC4xcEujHRP0Of3un74g6/eJ8zjwF5I7AHc1qneRJBWDspX59ltQLW9Kx2qKexaaIgSuisDtfo9IPHS/knyiKuDe632BlBrTmPih6e+Znoynwx+vELdjkbY2OaGyd3hpqHnIp/5X3Vsaz1PGIpCAGOk62IA6VTnMem/Xn71+5gDdGT3cm9Yl/TZK8QDuOogInRPZ52Zy4ui+94+p9w/RIXRztUasW/XdS3tg2PTCth3jslTaud7gQ33ScK8eV1+KESHVVNmKi9IOkgfPaOBjTlGZ48GD5ojkKuWYW3YAAg08CNM5KwKAxqtIgynHRg27gcotykz1sDEM+I3W0zGZ0AEAEcG2ILJqv3UnwJGgCnEOMpIcGTkfjCHxxBWLLSQEjbLujLlyT8LsIoAx+rYMOTu1oaRbxstV+L+4qRMExdeKeymoQ7YC3uF3GCI7F9l0k55KAleHjmS4Zor2Fy+o3sowsq3RETCEltYDaW4clcgndvIjZuBUUcHqhdyZ8qNR9zT3tZd+sAEkKEYYgs+8VpOMRnAAK0QmhoVE5HuS6fhrAJQltCnZz7r9AzqpFbpwfcMTGMtMOqdypiDk7l+5WL24LBrXeUEyqW213TH5ADEKwiYTVAeqtEKep18BTK0ypFeU8swj5QAANYfqpqf9+QPc/mKnFZ+xDEZdPvzD+g6IoQZU/i8kpBbfdC4nreJsIrxllbkeonSN5yXVlcH1msADxLKFzTXaYsehCHYXa1sYD0KdjnlEaBPOlrBHupKeZdwC+4kitxKTQeUUPtUO4bNy+wXIpp+dLxvkewdJ6zvLftHUe7YFDFUOW/eSUlWLBJxmt92jBO7E22wPterwYkQXAEnAfmcYSdE7n3lH+iMgWuygGLUrGzBsVpXXf0cNmXopXbl4MCmqV033CPxlCqz54PBrW4co9BTJsN2BT927TMHeTWdYgFjvcon3SGijxwNfTBpqk/2h990yRyX6oLhXjgOXje0k702+3rFzCLBzkySrGaNiobTq2yiULDrA45AjANPuBZWaCi2KyGrRLDX9pgCs+hdCa/HxLwAeCwaWxrwfgkR8+RagVw2VRjrmoIVMhKFzR1BEndcpmN8l5zLJURrJwnMRCkmRwGxnHC6ArEGsFiL4NA0UsjBSEVl4/jQldeoJyq0vEUgR+XxOidCjEOKAlCSNG92o7zNi2BIkc2BPuePeowg8on+PlefM5ek7nIch52RKNFB/H03p73o96tS1x164KolUmH67b6NT9f8nGXRjYAD9hrx1Ei583ivMhwXwVGFj/DTGrO6bU6D/EzZz+InOtf31GfN2HVgsWaydlAuBh0ho5cXzc30luHaut5zXeAqiQE8SOGTSA+ID9Shh+quHIEWfE966vaGVE/QaX0D8ZjUkQ+NPdKw3lLFJrAO8BxUqTG8msc0AbrA35pHac33FfTFHQU+DrzpO/ZjZSeUgDG/QA/KCFHYsYAgLNhPMVdhvuEaApoiQSdmmky/BhcDbERhO6ZOp+K9wCrIlAlXBL3ZpHBL4kqcXvO8LjPhGmQLGM0ptm/+wWE7ZZgT1O/Z/oTr7MfxaksJPIeEcjzHpkbtc3uqY6Z2UflNjaCDycx20pnzoc+nOiUiASSVVFZA8jy6IXL9bnpwXEc8t+QC7NQUENUjUUNnXOTjgbrYvyUdc5COHQ0F7GHLgwrGQuk53cjEOY9TuotcELRjk9o1pczC47ud6NTWDQaNYDABzF+LPmnEyn8v3i8Ac9EJMnbNhLF95S4waH83t2AmAPeQBkEXH8vHU3dCO5iOC+5rBRASo+0ABTjn3dUTx9gUABOxxJm74zJcMQarlHsepzRF10xGYp7ul4g05+0UEbfPxhbVJD0fIn2rLTk2AxyBmdGVHQC4Hua1kqSFdpQv6/6ZVOg8yBsAtEV3EmAoIMqNTnA8KfPCWX8yQOm2hnj9ySkq4Gb8QlChkdncHY3SB0xB66j8tjc6DgkQ5G8O3xzS1VbStawGl+17fpuhCXKEtL+avY5rmyY5qm/BTkf9Mi9fl+uhXfT+KfX0KMJjs02M89XyQqa1bt8Un46DpM/05H6NrT0ItDKIv+9+b9lqfFwuUB5yJqCAqfBB/nFLF45oWycdKwsY4G2MNMrz0CF+WTk5P5u+oj/dWSMLhgVbqSxHUQRdtn5dwt0VhR1TYLvjr24sr2aMs5SYzAZ5NW047OgCv2ketYWr+VSdq/GUG/qEuwm6cj2iqFSMv6tJSQ480KqOyqfp/GFwE+T3HKqLLoPxNTFHM0FGYLck2gzag2BVo10pye0UozZn9FfI74guXkmgYAtVordGQXtTepQy+hMiDeLe6HQCbRipmAGNts4g0KpAEXn+ytR1Hg1iaS4ZQlAwXaTPloO/AI5UqRaelBr59wD94Wy6NHu1FKH5Th6EiIT7A+TUICBvfTJrGZDbyfVTlrMi6iKtGuHJyn/e3CqurxjYT43opzJnkrwA9kEQm9KtH62bNDtPriFAjUreqhGyAW929wxYJ91ktJnoV55HUOF9gTlva5z5aILeRA8GfoRweFPeSUNxBDRCPTHqTf1Dxgx965Ieg/1xysPUDACCtZVjn3+7Jd2nICsBQ9+k0jqiozh/qd4JwPuINjjaG5rLShusEuge94wcrAwEPJbj0QQ2gpPS6FOa/Tct2Qwniwy7meeR1ryMuQQmHJ3y8SUepPAVoI/+yll+xRUNtRvdkOvAh7qJKBxnm1d42jpIeW9U8gvgVmz7Qe6enHhcUQ9b9rrKQ8Vafk8n4gPV2YMj1pg1Kcd6n6CfRgc4IYhzbHkCnndZEu2WZdWXr9jk861TJQI4vTeJZ+SeCtDOyXhKecvJrs2TSFFWJF8WBJ4CBVFctWjjUgUmetN0/xPTbu9CT0KnvgIxnxJ3LnSf75epllRz052fjXT/WenPG4U/t+5P0q+MuP3vlP4UnvtoUr827kPn7M/hH6Q4MY0a+7xdmmBF3FganNHfASjntyQMWgW8kaxf0bHOoCqv2hBNH+XnuuX1817T4vNOo+2HoBqdRtZ/QWoGR8I3bsdPEzN71Pd62bYcdTYs4HP/ICKyY9p/Gfk/UXb3/ML/n74W9Inp1zkZu9SpztU2PNwq9ysizrsVh9Nk8iVfrKeo8rj6/mn6FatpH6xo4Hd99Fn3fL3mZQlKXWhYEy96mYHROlfgerc/U6Nx/iAoam03jOiR1oDvfuC+plzEDByz14LRunG1CVtatGLSnm7RRiDinsh7Agh9SF8jKJFSbeqcfeZ8h2jRNZYJQyVx69NHeEmlq7F0R46grl1/mK5ZaS6ZZHVea+ZnRuXtaDzyObt1DnjmmxU/8jc06lsMRruww98oWu3z7Ffz4qx0UZJu/2hUAU7bWDaPq0md0VYRfJqhELmUcQw1ltHxvRs1XLckSnsv58NnuU6Xidv6UmTe6sSNlSECrxfh0eF5fc3KqEue03o72wT8pA+zuuwx0KynMd0i+8nLEeh0G5856EZJxV/nV+m8iQfvG1N7ubCdDVsWiTU/zCmDzHnOpGftU0IdCC3Caiao+e1qdYkKa43rtNqu2OYtQMP10Kml060x2XIhP+HzE6z7PmDOxraS2UMZDsbO0ehWMFZ5hAJbhNQdTe8VoBbVPqUx1VXhhs66rc6+hQk8A4xdnrUFfdriewIOcz8rRbl/C9vM+5MHw2+LTi8cO+SbNeUeqG8qyPogD0VYZVA+yzazyR9wAMf8esC1bp0ynlz0RS1CgaauaELgmqFfAWc/TrOfQhZsWzP+YbWdIg7QnQnYs9N0frxt+m2GqVE0Yb9kKHgT0TVBGYMM7aajoUXbXOkfu+55cBmxKIdVccibl4zYHBpXoLo0Zk13Sg9AGC6j+/0F42BUrgg7gD6rTldJZALUKJW9ga793l9L9EuTb7dHIdWLQMRvokHPZ0RLUBRE8ZmaAoZn1eVpgTlojdgt6G3uWP1SlZJqRAbAEVHozKcKhKgKQwcS4IqkN2zj+nEltu1b1+yTMcvU2e8URUZj3irwhzbamRCAhQs6jyIxHfDctduRUsCiVy2SItJcT8gJczJXODfINOm12PfdmLZ0Aj/HQELt0KPK3aQog9D4og7U8xJ+R1AY2jihSeJ+5z4/6sqaZ6EZ/FnGD5dIKs/0+bYrH9mpFiZiAPIKmKHByvppFOZYOUCp98N3JvrxfjsNRIRQysHVXel96Nc+iODD3c5rkTe41/wOtn7R5llNX0/OQ7y1oyc6uotKn/FSb0+9XlJQdcTuAfItn0U9tzuZHi0fnFzy76gvPT/qoNi3aoZBlmBMDYdccctgFGxvw0F7UrVFDvotbrugWZdPac00f1pnkffD9IGjERkvkmHndCDemp0i12ZCEDmatXF6odzUsi3Whnw7pdMleci3Ms4ZrNo+0oc2V7Siw/KJMD3l69ii25WPTIa09NCTIG/X9j3nOwLKRIQJPi8z7RLMRYhoGnENrfsG8mOGaoiIfK70WYSUK33bJ1MmQhYDGMbjhooWfEfIQzo7e2WuUUevYQWH/G6VpTqeCFT6PiZDNsGggukMTtQGDCOlOgOOMdU5fDCEI+KeebwC70zril68hzWu2se8ORVjDG5c5NEeunZAvNWJRwGBjuMjPxuA/8B41OjmWdnOkUbd4KvCPKPRUybTPBH1/S/tYQOCegR4p5lGKBJ+P251Snx2b/I2Q9HqsE+MuueXaXOJhnyh/nSdQkwkzQMla5up+mD+Cfc7feZ208dCZVcDbwi6VgB0odt5ao90q7xMsuM5zsCv6o5HuxuwA7YZaQ/lljZKbAgROj2lT/kDWhv0NHWgDbJM83UBusr5iTNt1TA8K7Sia9efpKfQMXHK+7owUDwZJ9gnYXByaI+JjBxxG28iZo7OwwRKXNlYr5DVdkMl3mjix3nv8oObhNOzttr+xqEZKyKO1D/lt2NHw06IVAobRClSwRJJfORFpCnK8asewxdqb6ILq/SzihodAAPiDWjBS7sH//JWkk7pPK2ydGWXyqoZ4M6TzcK5AzKNjbdyodEycfC50Exbx2AzrqssuX9PSl7gYHBf8s96EMa9oaPdapT55uJYJ2gmG0Wu4yjhr4OFfrsU10uNASEA9l3K0Y9dMsc59UGBIgJsLANIhkSELjyGNjn1rTwfGuGTfpxU1fFT1jU9r/VHHu5ACZO/9dxk8JTQp34AnRwbjq517m+Zv2egUKLLwBNZGwwAcoer+fmELvCz6iOUCg11kBqd3Ew3OmKriODOTuS8uf4uiXRhoq8mf4vGCEa4UpYAwPctja0bGjx0wPYp1hS6U//3B7K0ehb+7M4kybfqbzz6NmbodAaC0NP0EfYA528O9HG9O2zwSEMjz0XfZHsoLjOdDuz05VdwWbdCZaW64tnhLPo/jiv4HG2VK10WA2nRPmvotpu9QEtUvy22wH7sU88vAvV1+n1f2u9+ggly+uhh8AHCwN2eKTOUGyai8WKiup1Ey+GDcdnoUVL2M9PW8GB6GpSnieuWm7zhArEtMiMbBbGiZ2WoTtKqF0EANkbwNK3GWhQ4gK5ynoi/idILeBbtPAuVpxXQOxUKPQtCt2ZVXyApTrxH/fivmh00XbQ4DBnKr5Xzskxq+LjcAshmBXsv5mUffXJjHoEl8uX4jRHQDM5rExI0M/LMo1PxaR+gHMpRW8ZUnwT9UfsQuSfUldSHg6tqLP5XSC04P9C9AfRO3YE86HxZx9vmIZkMrL+jEe8jv3RgqZX3xdx/RW+vUgcKlObu+7PdqzIklMfI+ZEZ1lBhHCyK3TiPAcCUiCds452/OT002dmnp9VCbpyxj6cBdY7qIfpsPtdA9NMyinkkrOSdtIXpE9v5VHcehxz17oKXK8wUxzVb2j0NS5rYNKj9iCd+PdgGe0kQWKdFXgymYZ8GLGZjIXwebxsMKYHCz/FfHBdagsHVPMV61vNhv6GJTyg9fxicdNAQIF1wHV50AwpaoOwoUc8OR8MSGK3z6tJvPIs814G0oKf4yQBVUO0vjDIlJ9qOvswlUnrOPDhi6+NK60Uqs65OXD4itatjp7xWUdyY9EGj5vkTIxDrioLYpRXQ3gHwU/pLukZcQkGO5Zw8qMJVVhskfRKNXVGW7er88nmte1MGpnd79XQs9E32rIqX+jEIdVBhozb/STRWP68ZBXWoQnSX/dn6DXVLBXRltaiRsxMn4qugcHW2f00ecIj6g1OeJiETpiy6Njxi/r3BWFRYrunqUQ0EnKWT6NZ1XcuxN46Yt2/Tnd53l0PtK5F5JESzDxlQD1k+CTI88UUB/KALVvXtQAU6qjZ+TX3F5jy0ieXatlPAiYj6d7ya/XmF4JlvdxLTiaukwQEMLI3+wsECNF58FuOKa/vCEFxEsnV2ODzH95yCTRCwtNzjg8+CXpO2UEn3PpJGF9NtzDYA7BWctmynTwMr2yTuWLUyHSZpXgJ1pjKedePWIfoKUt0la6JijtXYqL+sDrBPWLLxKcn0JrBf4aFutLddeZ1f0VX8y52z3IMHtkOdQkTEl/KvoPIctL0cqy8detVvO8eILyI6C+Bi+sjRwAaFKAKsxFiFkDmh9zhDBCpDYze+995WbMfoeDAWBZzkvmz6iXV04FzbuoVI3kL0Ig1IfCmhDu9PqeqTCJXok88HBY5VQ3CcppXzCGQmOjNmB6rUuDKlYMMxEXFaYxtZQW6FQOLYjmqcqM7I5MgmGmH9PcYfDA3mZTgHbceAgbevyQ+9kfHvycg2Bu3EOWhBD9c8ORV58zukaDFvf8FB6GT7yWEwBbuhaw/PgF7jmz5/x0vmb24MnE91Nd5Fty3ZNes2cLC+GLWMNHxWh+knZXSRBRmj7hi9DDVFZ55Ax4F8WunZHE8j59DZdRkC22BU1Lag4kEV+IVh/KqzoekIuHLU+hxv0ZMOD3J1e9ACSxVavwBcc33xO895U0CE98Rsfaa3CyCdTtPewZx82TmnnK9DffRVbNzohfwrO7MpQ3B20eFKc9Xpl4KzdpS2jk8kzKSv0dm7+XtyTldpW+dBesIDWz6RpDP0zu3zofbWgiY8xggDQV07+HNgKlNSUJfbpSyjiCmUlsf0vuEocUipnowjc/qqU/uRo/GZZ1/B1aDxTsqJ4AGQWUKYcGl11fFOqTwqefIBPe1NXmnRNnA1ZdR7GvE8ahVq/jPSWgl2WZmE8CTb7Fos2Q+42CJIGk39iM5GETaOVb5P9DUl9TMJx+PpTP22MNGvmfZsKSCtAO5KeZ2qFwMOIqQPvTdm75ekvgtrp2GfVlzcXVvVjQbYP/lp8eoxoQx8qr1+XfJXjomhfwkckwFcn5Qfwm4FiwIqOCDoIge50N4zdRsQfYx2kW50Yojj+vGJFl9pz9ZOHdT3ecp6ccMTFsHb1devoGvNo5qf7cmZFgnt/Ey0/oQGcNq2QHxz79fNb9S+v7rn25Z/gm9PwGc69NLA8qf47dPUBooeC20yXu405WyoN9b6adHWIq2CDVq0ODFN/lV3/pkW5PzUqRR5SHxjqYC7D6QlLus8F+y2MuTlpC6dDHCOEJxs0xm4Ts1ozHu2jI/RC4qC2ayoPCWrEejvlna3kWrRchcxO3i0su0SRTR6XdT71yjRegBBoeRg7EutD/lLpGWV30Qg38fQAkRdxM39Pd+H8rTdbd2JPd3j9yAiO9JYfLmMfkJDk9dWFRdC+Nlc1S0JeM++bXhgt8K3W01a1zO2O1ibXJ2eNT0r0L7K5/Wt6JWFs8msQZ1az2fpa5LsR0Dqhfj2o+pEcshOMh0e02fPgAKdGWg23P0U4nVOxjIaSOu5X63aYxueZ8+vHY08V22XGIrx6pq+T6PDT1ui9HNJ+8Eq6um9FmmVAYnvzPBdEHlue37TvG4W+rlczxQ17/yqKa9U9zyHQrSyUfUdIb6V51kf7AJ8Rpc6uVDdp7pmtcPlq2X3+tcKts5QMDpS7bvqpadFYw3Gdwd6ol3CKsy5eOgTsPN2Fo0fcx+zM7XRsyfpY0dDcaYQzWiti5edIS5UjrEt9WwJ1j2dAvsBq5a4s/PzCAT+PAaXEDFqogNHzgYRsq2b3gFgirGF5oKbAoBVA6DRgct04IPcnd9spo7Ci8Wm9hhxzZFPrK0ExnmeNpOEgQm9fhCuxrGrS6E7oNknvjj7Sk4Tx/GV7v7sg24J0ExqkHYnoEBnYhvSxBPnUshY3UPQSNQ9y1DmzXwZlU+JyovZa2GVV7C8yTHFllIT0A+hW+bea0kU6bUQBU9dDvznRteU60z37A+LGI5nwtXFZAjET91xYJraPuSjs20vnc7QsR8D4dXI5CtEPUrj1KsRzZLQbTzsJ3VdoUz+Pgunz8+SjSOCYmgnX8dmUbI0OIBbYkBbkG9XqWPS1B6SaqRwbRMkYqUH+P7EGchtOmliR4C2PMV9r57Md3RETkpg3ZzmYwFKnysyV811B9KV+QBb7VB+bxd968++/uftf66Edpyk8xS2Kf1UUjq1Zb3stj33RfvKQECXF2nT7+UB7SaMvjtiuUs86R3CO3GIYgnoTyiTsR3TckUfn0gIFmwRNNH7OAZ6rxzLivzHU+9a4PTq+f+EZRM9I4s/28ldPolzfLOXuxJXhjLW4aTTN7Tsgy0S9TATFdQBOKfWHV5CEfMfpI9OnRqfqmrIPLcgLHp3Q8OZVwTKZhQavy3i6kpGxB+qeUq7yDAKinn1W0Wa6h43kfzSxiq1kVXO99PtTEcTCWuVa1EQGeThWHTUcvklQvONmDGKWlbAONcwRLUY3sPIGc5Vpj3QaNca4Va50/nOyz4ZqBBWkR6uOsJwUvgkj4IfIxmBmd0N7RiMri0Zz1YQqlFOgjyBRop8UFoIXohMBTVWYq7MS9DlVaSsF6s5LsXjAf2QHKhcNndLo/mxp+u0jTZvghzx3TOSPnPmqM/cFDen8kH/BfrTiwzKRxwbpOfIgRJ4vwXXB5trn5CKaP/bvOJAwmco6zjyNz23mgNKPOp6J2jX+6fVBkl5DrqZGyi/ObX11UhiWz91/Tk56Q/sunVSmvpXZAQoltpftNjo91LvmtpcWS990n49aKGrq2/Dh2vRQnIkpVW4fZmn6Pxnx9/UOsBEmGuwPQ7aFf20+UxVOYFtRQdvM8+Z9dYZwxMS2c3u9VULlCjgWy0bUjZLVG9HrcsFb6zmZx1omfePgtca1BJQwkIk8fRPbGmPGx17fMJVx47GPfleA2+mnjqAJ0zjbdSVHJmWAscHOxAYoBtEGI24RaBXyierHViuFZiDcj6hRlxPN9S9ZrBuEiXl2CT+SP9vnZg6H5U6sFWED2gWWhcczF9Wihk8bXLa3FYDF5cuI9jvrhO5ogi3tKIHYGL0zLIJDkG++N4NPUVqrRWxhUTTQeqiNTgju9M0rAw6Q+SygXVqpG9ndO8kw1103qgBvjp36p+vdfdKoIKoCTAgj+lRnju6hOJKoRveVakTIzNzpo9IfyfnqwjaTtKWzkaTR1Q/hZuRPkF0E2shTpxYsG/vouRqEgKIZr30ZfJkbYuMz5V+LXohSzykXQCsarkzXkXaP4DKPQh7BOP1fna9toAt04D17ZwMlLfuJqhoDLqsWowmaoIxuFPqiEBmSedToLDtYzLiq0DnsCXRUTGqT0FAyhsDc/6tjVe02Ea/A52R6CP6PsFggabaYnMtC2jsnEw6Aw2BHD9w/ERPanCDl7rN8/GioswzGPRZ2gQpX2a61wGd2rL/ndV0L/hbpfMVjTmoO4Csqx1xHBNwotuO3swtjPcLAAN2CrKAWm177yScGOYdU3cTjMt7Iq7UHCSiMNW68wOQ0FjNHQaVrd0l/fz5cukWuAtSnLVLnAe9NoTA6VV0EZUivEyKqijkqE2cx3oa2LZ3Nl/1ngGXeTxtF03IK3c5GsDEJHzH+Qx+GhyVS8OC4eKlOi8GWTgCmo0ZKz3JnZOcLWfIcyheTvtmjkPThC1jT3SF/o3JSyJvCW6hjTZQDvPQ2LlS58dbYQ51RexPzI8O1niWrH8s0Gnwc5FjxIgLv2k5XFUIgCDJjEmYiPHmk67zZXxYO87zNQc/rwQr9cH2B5qaU/y0Da1DqE6+6Vhfp7qui95yhy22qvdWz+DrZs8ipitQZOMgFmhbj54fKq40+ahjdev3duC10aVP3IQu8QpdU5b7PM+zdLLpeLPWq3Jhes5qOUtX4t9tgmh4wSfL8WPKj+4OE33ZXbQViFdUX5dAntp+bninSV+Z09beW/8noZA3YJQFVavAbtY9XZkhik2AeKWzRXwbKMhQtyPhKXCMqfIJVF4F2YhUmhx7HMwJOFFwMQXTIp34/ZqKBm1HCfZsjLXKZ8cLpkPSPSE/yIOtYfF8fBUs3bXs4yWGX07TZ6dO6efCEAs+wFEKc7jlRhL50hUDtjXuCEzAYO5L0tFzCCxM2UR6EQAwM+xxjoyBEaqunDIoEdHrugajyj3BpMAYsH3E5cYoCZ0zIjK2oLj+kDC2ndNX5esAYIkqoh74ab3lpOeFXMZoyKqtRdlFpeGphiCYlebswIXf2s35OZYyx55jO9NfiC6KRtd63iDbMNW5a0n/Dn5HmlNW5vEiqqC42Qy3rRiZYcsCL7EcKYDojG3fD6tBJqBT/Qfgs5RT+bpHs7YCCkCAkw7YJRv1KfN5aHkcGj5zeWSpT/gMkhuawIcAFIgG2BFKY8dAF8U1iOJHyAoo7hgILz2MUnJyQ7+CUhWq/DE5KekSTNleCY34l5qkJ1sQ6kq8lp1Q74fuUZ8rdyCu3kMF8uqMgtMilWYcbXd2xm89/5CZJwDKWjDSyZTmPLUzfblBIY9n0jr3Mo8XAoSiPh4BaZ43tDGQw0CFCXNb27L/6dNvQDsYAHAlQpnngxw3daLOMPqb+0Sd2GVKvUfa9RD8oqlLptxE3eft+fexWyO/cND6Ms1TGafFPNZg5GB6PGRF9asBYsAybmnrSEY98IWk/TY64owwCmkoB1+SA8IUI+FgiotesT7AtVV3kLKg5ufVIV4LQlm1ylWeKYm7VdjmYhJk9gB3Swz+j/JmOiwR1zpRrDghOw572dV7UvLcdDPTRVeRvXH7JtG+sN/da/UTK+7p2NHQV/joOcK6BN41jtczuJARHgAmlcBcI5p6W+igKGoFh3MXOEPlKhS4fUfndeR1haOC7RN/B0OkgNAmGwfeQIRTx6/5sLbow4xKFM8x44WycTN60QuYGATwpjlOrsGYmS7WF2LBkZOhavFP9JalPgR0gcEWkvSANhnw1VFdgicjIT2cKjgDPZMy+aYIv+bwwtvSpqIwYDRVH7bS8bGhU0UCQAxNkuAwgWKzfkfiQlLFHi5nhUdKTuUF0T5AHVNcprG7QRPHOjzSNo+UnYbwmmermgMcEjjgJSLlx1Br2deMEV/N/AXHHvvGbLSkodDKXY7xNrKs+NyNKvVUFO95Fa07t5iMzZCuexrKcHjCzHNx3LrGBA8KQzVCFB5F1wl88WvyEZrQmGxFDwwQ8iB02/st6RoJzpaXusiVGUX5gM4S8gH2ltLMDADFhLyhKyvaF+8Y23iFJvFrAoxqElxGXJdHSoaTMeTzooteUwPGEUNHwnprSFDiNcjb0XeF4FPpEhHP9idNQZeAzgbxDcnVkdMVVjwI57x56e024eAnmTgobbO9ybyvZ9Gmjcu+/SwH2OfrmjIGPG3gz3RLGiMREr4MG4y4n9i92LKohvE22Hn1ml7FeJZqzj/HZ2y6GRKqc+fR5tRzkN88ButV2ZTvYusv0pZb9PI8AW+de7UxFzMVJc3Y3zgzVsZ0t5A+uT76hrOFeocp2na/HpxD7TjqbL60w5PU2+rRZm6bp/na0KDzMQm98HZyEvxnHNuoHzM3wGilsVa7EuZcqD5gn4NOwcaJlX2DPmaeD6OLELPYywaJOsuJMhg17Wn60gv7fmUy4wIDsBbPXLaC0s5waFovx0m5RhC7O1Lm73uIANIE4CFRjhn6PEtmhywPdOE4nhiUbV3IvKWyKHB9a2uw9WWaFvMzr4b25Bc1/7NBoq+09zMNrnikLNeWvKa25q8/r9dfHdNfz1GfpxW39zn7uSj9199gM39++8wuRSjn+vMC7TFXnz+ko9sStEuchmmlSdSgqvO404XlnriG2BQ6pPifl77K760j+D852THeH5Tp+n9vZ/GBJ8LKe80/TBkAXmLyYjOgIxyKhSDEQ8LtLn+mfvWV7Z/Tl1mDaZBE1cVFFJ2NLMwUcYQFx7ak/3M1fKaFy9Wenl8pW6h9fYwzroykrLY7uUO1f5nT2jp5kz8zEx87Gk/bH54YAw0PT4/4SoLKH5jvVLtTthk1n5T3UB73Yncej4hnVtTDwz6wRcGJ0j47cYE5pnDmtzdaDlCKvuKieTYKlcQqXkUu9OHM6If3IqeRjnwPIyh5aTpsWyOxZcV1NGbvHMYtEH3fx45331O9aifOQRNxxAjMoh6ft3Hq0sqw+9aCCvLbSichHulw1ewLgjPKQcqXcfVgRYN+X+9/dSeubs/aRWgO04FiXoFU5Kc76xMDAAd0yULuCcZirhiIzHc1zXtMlR/X3XpS41GRY26myic5OKMchc9fuGi4bHq6vZ5MRxvxRhl80yr1qyKLuZi6vwJHsgH4/9q70i3LbVYL7vd/5LLuDwnYDBp86nSSb12Tla4qWwOSGDZItjGbZ1zv+jwgRUfGivxSQ87UKxFZ5pxUVExP6qPFD4KhVe8nZWFx74Wc52r/fOg+y85Xa5GPnXVLX/FdHSeS9sSedxVZwCiFE4HHJv7MOBUvH19k4XgKvg1PEZhN8SPf+ZPVPfSVHO4z/F4d56v6TsGGAlky8KI2x44ipgCFfZBYwmTo2/rPOxhx5eJReWGP3G/R13XCzD6AL2xdkxszinLn8c8BBWz3g3ywn8+Kj3zaRG/YlWYyh8UMa9S6+Ck9/o6G0GqAq3O7leLppG4AqO87g5zGLbWxn6A5kI18ubOR7B24ZiXcHPie8Byfv+FBqM+2TFjmEGBsBooGzG26yHXG8VfGLRtju3e7exGAWpbHA9YVkFxl4WJwMKPSTlDt0JaGrm7mMVkQDX9P+c9ultXM+mebMOh4cqxi5lxivye8dT6+D1JmY5AjRPq72pxnwBOd7YQDmXGBAqmLvBN0Rk/XR48QTMyDCyKx/tG6RNsNbakuFt/h/jSTJ7a04mQIdGkGJ0OZBc3VHLahPOxvbNidjVOeGJG/yAUxT9s891snvBFJokRtGNeg/N+i6iHUr+3AMCV7G9u3eamYExn1ABFtDx51Nfs8p9mpilCK1FduQO0J7fxXxDc7Su0EB3q328D2Q1Ez21PvUs5Cwqj7cwwaQTi8qIRC0PKBmojt8s/jnmOW2K3Vg3ZFp1fBjmLNjNkACZJK+Gbp/7FAI3XsMSNc30yiy+7jluE6yPAK2n9el0zQ+AlA44azf+4ndXFCkZIINWd08acsXF+mCiRe7LfjWRrXVmZAqDb+GLW6TEquPhEEHGcoMRGsZJRYxlo3YxfRoM86GIYHMzHwSw3XFkccDhzmqdOayi04lXSLLH6qDNvM2LXCECUeZtGP3LT4sDa85NtNGZ5FNmxGeo6exhojjxN7QERP3rBb0uxjerb7xy7JQCRns3PF2ZpEOdGfZHOp9Zqv43gqgp3acWSXh2VOPyAoDInKHcu7dZbckQBntD9EsvZPQCC+ScsMiJ+j+UDtVAr828K8t9vWw1Xuo7qY6GeTwHL64TKkw4c0k3cVeWTBycUmYFne9fcvsPkucFy0t59VC4ZcUOSzT9O6Z0nAE/oMuuSEp/72EU+sVWUNfaggMs/DQaFdiGiheLcYyFXJGa0s+Cqorq5JgvKbYaQz8zNfNUr6oJFMX4KM9eBMX+kw7TUnvnJyt9olsETw+SvAI96Zj9PatwQqDE/EqA+8y0WzI1DE/dmhs+SP9ScBkf2N/e50Un8j/O3W33x7/Y18BY9N1gCfbT6jXzyjUW3Jr6lP0AUTRgCSJw8Vlm3UAYEYjf5QXivqEcn3GKOE1IvlwUvu04M1fe1XICYeD9jMBCSMt1CQdURcRxp9Pq7IalXK/ToFjDwT6mx0lkUqA5DioFaW/SQb93GQ0RmpnTHtcUXadpZs9IkrcMvNIHHdMTWSM65iwPJbUJbNF4HykkA2cGdO+ZoGas8hhXMQbLKt2hJ0QTlh1POircW1VabxmcxlWfum67fxFbaSz9ZVoI22BU7DBaCxz80w6rnG1jDIEGed29ntUOEYeanbdfS73HGfttR8kDMLWBMEBb4zI5PeRvnRvhwtnsDR0L/YpRqMjobBa2pnsfNcL/BV3TslTLacUg2wiWTU2T60QoYr8ET1RBI+l8TkjpoEwgRF9OtTCeXiZgDS2H4+DmVjkiBjXPBNVgFqAdAT/nJJ0s/I6Qi0a8eLuJ6HurWv2VJMfBDN9WC+q1z5iz6Qht9vaRBsEizvISZZfaJA1v3ktFHV9pyNwWloG7SewhRs6cF3NL5FeZvG44ZTQbJ2XCZTDA9PAAUaJOlTxD5EaTMjFaNlUdmrUALJtg6uNMJlDj2hE9uuIN6vzyhqO5PgDftevwsqVrI2gzkjNcwU1xRLr7f8UpcLxT+RlWXQOpiL4NRoh6z2/ZQ88pCLbUA9Z+GSzMgJn4faOzNA0SjLtdaeJxtO+49U70LM2xKjHncjfDaczM+F+07DouOOfTyxuIGWMpwwkYGi5XNZiR90ivnaqns4MHY0To+xKqDfwI/ZKsWet3219fpjIVesCJosoDEbRvJX8lWj45ZfubzkBMBGpOUum01X3W4IEGNZzYbGOXUBYMUUAdAwO4MBir/zECMMGeZKRKTNB1jg/OpK7uAqDGxl23tZb2PcCYANYbA9O9aGGfr5eOZ/j4tBhlYAVkoUuzswd1GcsOwqKEvXJ2AXg8iENng+hh2OOj6ad4Iv4DflUmX7mT/TbqHdyvcSjO9k18ZUuMYiElTQqlyrkOY5nQca04xpIzy7uzcOYtSJiC799RNnXTpUli1nDxhcVk6doXQ+LlaR/8yIgVGRj9CwO8N8DUN0kx7VauKogF9sq2ifyb9aseBklHOec1K2qglKsajWtwkLsBZak1eCYono5J4dC4F2wjzcMEdYZlZe+y8NcVavLitcyJAFWnHNnhxJivz58vNJMixnR+NiWywI2ulbdlax/5g1Q15Vp3Qe8BXGT94f4/suM3Swk1FRH2//EN7s2OGtU1CPkYjK50AVQEz6V/ltLdmvat7KnS3y9fIA68upGO/Ohc/kK/fljpMSwMpxef4YOBHRHYAHu01lWS8NWqBexcxqF6W/QJao3f7ZAyFXtzV49bAiOqfTPjNsRZ2rIJCd1lS/TiztKshYV/Q8YFuO2Mt1KtP6Y7dVEB2TJU43Rmmr15UlBhu9sICVA8Ft/lXE50dcMlW9eX5pvCo7lowf7LO5W70RK++IwHyqX/A1L+DHA/d+eCjOuDY9sSnzpOGEWiMauhd5cm0ofhV5DS1rGruR/9QsDZ3yeGa1tvaSVCb5JEA9mtim+TpxSRx5gfI8fo924ihpUlxrd/HBJMRzG1k+hT7cqCeo3TpZYFv5lbpfQwlM8HLfmMiU78llA62Xe30fYJ7q7V9/ve0aIN9EdBneH0afJyBDBZlMiJ71eXgffp9lGLBcDwoHwIaLcdsQYWBSpyIr8UQp6uBiAdb01lr0dft+ZAZPtumWkfykjVm7NeD1ZQqsOOXFAWsp05LZTGUratDxE0fpnw+aGCaGcgMwlQ4+8IpBEMqgTcNqtqJBr+7ncis+Tgm5Mof1qInjPk+dzF3I5SkfT/UikUyIM0aZydTLqFcFwfKTg/Oqml7RLFCKNgtbTnKloMWDwoqTXhWc62L5jnYJ5W/9J15ct28ZU6tUBTw7WiVFmJj+fALACz8SQSXem/LWmep2B4DjSeJtNwcVVHUnBA50Z+eH9LiTs/f56E2dQOl/X/INhqIf9D1tBDLM/IE2PaPHQcag6N9SUAnBt/oQiQOWa7r2J9heXb3XT+sHrcfeqNlrrZcY5xf0KElZ0FSGeb8vYAkaCQ0mjniLDw0vf+PIWWuffUOD6EuBhnxZE1gCQcBy42kFNNDtph/InMVsBBK+Sk12CM55fDjRW2kQbz4e+Lnv/tE7rSix4xWM3YI0ysxisT2B33LUH9FGxCwul6IRcm3sW/uOPouyrbZ749G0aVuD25kj/ZQ+zq4dsLEDSqmtD4cGL8ItPub2vGGdkynvzx8QU50E3PZk5sXsMRF8nDGUWcmtznHWt8r+rAJ/BSeXf+uXS55A3Z09MvjjzGWXeTbrImXQPjRBP/L3FXUaWh9r1hMAS5bSyy5WfAMMo2S9GhHdt0soWbs+0/xUplYka9N3Zz3PJ5qBa6vUQkML8h5yTfJK5W+QgDOiWoarawP+JZ6IuJTdZ4kWOjKWK13ZBTR2n8dn2Hpb9jUB1LB527vAtWlbwOeDdTvxq9Va7Xg769snCdJJg9BX3O1m3svoNIl4YnCINLkZgyA7RdNScC31KNTZ9vUBjihxzCYoPuMFEiFdYVwfaFWrObZAu96HrnD2z8/PwOj+ZUmz+k/G9YVAI3emyaqyNGvI1tfEoi2nRPe0gVG3OAM4gPLOACV+ii5W+oOCL4MVAKl8ua3AoGiLCNPAV1TOPNNuvsjO67mjPRi8QANxfaReBfCZ+s7aifDt7m2BSsiyIH9FYcCKmwfoC0JH1oimb0eabVHKNzowSNuC0XIYs3mD55CWI4Ea2G8juvtmZ+yRTMzOsqYOvBYfuMQg9Sm1Rh8epzvr8ys7DINO2pHgYlWvAlGVbarPOiOUB/upf5PTjeqjZvZcVrZPcxo9rORlOFpn/hZ9zHquMtK+m/r6Sp6nWdPAXsXTdMcVKpmKnMlkdQ39muYyQVaSfQE9nveTx11x6Nqo7BRVgK8K7kN/kTfZKQn3Tm1R7Gfen39odbWu08BroRrdnrP6akvGrPnx96ic6xgE+HbOCPn5oUZ/HiSXJAngWHPBgfBEFCepDMjrXrYl9jtkz+YEg6WVjf4kiHN8PlirMtAfNkmsvNkqz2MF+DmsEZZvZblOsm6SxJ/ZqNXfM3oQaHhn5hYCjQURtfHMQ//idjjTBooluIu1CTQc8v9EaEEJ9J3WVR5QbIX2dVm9xD8639AdCIMsGBrdtGvhDJcHf/IN+Rm4Gi42crkkc1IS+Mi4xRMZvw3+9b22ZJRtaZ+C5DltHdGmPHD0Uf9Y3/UjTkmNEbnzvYmPhJ/kuQG4wv5IQGuNrrH3lfj5Rbaqv+iiUYNcN+qUJzlPb/qS57EAy/ALWgPjX66tafY0B/LgPnoVOXP3ulyudPYezNWWxNuLBvK+6lfKyCtYr2mZc4rrf7xNT43gRSeuPf9QojiSus+TfpA/pItPVt5a6jaxUWuwKuzLWODu52X3uuSTjLvMjbwNUOwmUX8WhScY0yd3/Jx3XV/ztiNMElFrGmww1aBLNHC9Q4FgpC8UO50JL5kf/zS4E3W7Z6XNkdfQJs/hrJz+vciGlWtYBToU52XMIBtkq2SoHSbDsG/Pbg40YvLPnLDZG47zSnOAXYLhSofTvFzjoHqwd1AfWTQ5ICLRjSIq0sAa5k5wh7fTwqolM20qQjmHte5gC71sz3zOVDYeJi7KtmmGocSuEFFhv0+Au2/VMGxMOM1seNxBx5aWcj0K4HTGRKzYg1LmN3T+wb6JiUBQnSetUoCi7YJxl4kohMYpbnByOlmuDltgUyB8xV0THl3ZZmKWeEtN4yvyoAgoWiUU7IQln40thRaL4JqI8LtALtTl+LefjJVzn23tPqXddv6s/V0mbJqNhOyGXkdZDPdm2USsEceQdkEW6bXHILXICgbuHS+rfvI859Y0e9pk3nwfMfCY0k5EUPkn/PVmnveV3/bVecYdt+NTqKoizdmqJ/RZYNLSnwqu0DkEeRan7EAi1bJRZv7aem4ejf3Q1jqeoUoVBM70vKIqmxmDiFKrqjYnw17xs5upFSA6nWeXfMJrvSW73o2I8uVDjDCOiq/NuHYBm28Kfel6nPVaBMA7ruHvFWZ4ECVDVyOAQfk8XLc76FTcEZc6M0JAWekCkR+//qpA3Q1k2Y/U3FHDnwu/vd25gqBGYd7UH9RvPtztTux0yPBl1mFVFz59INs14Ezezp5EizQLMOq2QlDnfAHoPoHsin6EdrX8B0EG0S+/o1F5Cb0yU7giMqtOSaESzwOYpmyIYZFMlcysnVWX4n77VyK10PkYwmR8HA3LUys1Fl5eD+qUuYOA23IvRInLoYQZRRng0RqNYDo2woHGz9pRGcv4z1dFkShAuOc/3J0ZkhW7wQjNgpMnCuHHPZRULWgwnuKWy/YrmTVZidmwNX0evFXBlDf0Z46k6ynOs7RL2m4kATnRyTJRzx4GULG0HaXwHQY2yJOrwfZTHMVExvNaIVIGbXMKOHsrUtH+hN+nx0kqsiAIrhX9YjdRTlprmvGtOykaXJTZvlJb1qFw4P3FFNHBh+oV+Fiw9i3CwOhJoLPd1a07qu+2HA6mRNeiv1Q23NvJ4+OxHNBcTuahzQ5MR5E9cl2hm9ZCgQKoaTMF+PU+a4GnNlSuCepbtD9g554Er4m02ukzMwbWZ03xYBL/tgRRxFsZG53Yy9WY3e4flHf1YwlGLOCRG+5Slj5uMW/yFs+Kx32CVdba9EFwjfOn7Ww+fpNEPn+9LSiGPGfRHGx3heWXaXsMg/eCY4Py4+KwNkXYJ8dWFFUDBy6idswWRzmYeLxxAncvfOVGf35hMkV5fBOtP5vC/Wx9/YaMXo6J4cE25M1QRWs0nnWRB73yGdvUxAjeMCvCrR8JEqVh/uMAiEqBCnU1L+tAY01ZPkbn2+zzSTZjZvhs7bsgxaM3F4GuajDmVyVmz5mJ2v1DeMxircBdRjgEiboWi5pWcGZIsmt1MjYBx2C7CvIvh4wZVecWNhmZGDiqwRsGU54+Oc1ONWkLAiWioIdTkJDbk9rm/MSS3HZL+qVGOjfFMnxuwj2lzKFzzADuWfrFF3l4p52BUX8ZJ3MhSw3lBuow3jMXzFQ/SNrC1K4xA65jtasUo496eUstmpmxbZE5ONESFehdOHqcE9uRwB73fbr6zSf7on49pd8AkKqtNIadfSQ/7ogb+n1ZL+/PxYbjHEcoK+WQfjy46GWE94P5OLFZq4+1YRtTORv/t9bHzTxevKsAdMvmWaJDjjssHrRT20tEoKhuHMqzvAYbMMhFsi697N2zFdB6LznbWZjpXMmr6GLLNsp8iR2hN7rBrnYwz6FuwpO9wymPUHvLf1wrnyAF20+k3+BSGdHfWX9rVC+p7qQ90PvHOxpxO/4JSZAizmZuyTEIiQyQn5lTAgPgtgMlEg2975XLhL4SnoQlTrKSqodtZFbbAP7sZotHWce1wxIDYKguHgQYGHUHcJgTZqbM/RhGNeI5HW2bH9aZ0sF0r4rqtcLpJeNRZaJmAQ4GaAcZ4ovFqOUiHH7GBlrL771O/AC/2anEIKkwdtDWXmdYGUb1dWf/tbc8h+h4xHbK2fpVwLHf/m9LUDsbm11nwg9ysCle6H8/Twk8VGC8sH3lyMTmxbLOsXO4XoFWcN5aZrHWgiNigkBZmcvYY7u+IAnmbRddHg5eO2jmKKAz4HsG6hPV0c66uYf2r2ruO7tjJ5ngQ383oaldLBIr27dzwUSk48ckIDzTzmLMCjHXtSqZsx3z2n/waLACz6mHc3ihjK4witjTCFxxeIIFu1lAzfa269h3N0uLrHZ/9gk2tFufGZNWGVngoVq3apinOpGSn5SxWPM3tMN4WgFbcX1q8OTliJnpuuztqJXtmOGh07V9HmikKzsL6Rni8TiS8eud27RHeeqSGsnD1EUv2ldr9wFrtcP4+L3Dfo3rIltj75mWoXpgNgysq8WuBf2FcYaPTrWPYDAAnebhoDd+57NVZeTcvRLYP3ey1e/PPykH7VzQUmDxIgs2Gv3OyWaCN06EedA9xVapQ+vg1xkWy8tlA7ib4wDECtJsaditqdavEWm2xMUBaBdnnIzx4iMiMu97w5ftjZpXDjKPtWBs8rdeB7Aj4ABa1fnYxZVJbiWGSUA4goaC5wIEYSg0Jww8DJwxc382RwchP2/3V1rrZndTr/gE+6HDio6U+XJBcjr2APKhl2A+56CWQIYpzS+sbmAffdD8LXTZRlUyKQXO7Z8bm9T9qj36r9HcyTe2t7bxpuxTWn3U7xkJd7/nK0oJasKT1udlq4Cod6D2vHnTozzATlo8ghmBr5Zb6GgNtTDAOAoV13is8IuCu2IgxoWRWPmimQ2SnSzsOf7c5s2stcB7tmVmftmeYfgA+u7o8dGpyuhNjek0w4hlG3HxOrR5FnL0BWXUmSs8brqN2VJN6IMeKmDI9rZ4j3lr2JcgVJ0ihBTN9+Sy4nDNZyOa1vVASD1txZi2aAI92qB6nvwaDrMyHZ618iSj6zjFSGv0mR/u7WPBsEvfw/SJAmH2ZCA8accbSJPLfTB5jTZ8GawjbwfZxQC2ozTWPZRlZj3n6cB/MG6ZXVyv4aYv5HOnOeyMmq4rAt/JNs1F6+ajsURnvw82JjbpMJBaN8ukE80Srt/G8wE5GWAmvjg7tcuC9UpPMNM4P8rhr9238ImyAQ+p0jW+R1C7+J7QWDhWqMESPEEb8pX5fiW0qx7SLpqT9qC+PNZW6evJGivTJnDM7MxcFSTkoKcm9sNUatR14FMQW2VHI296r/m31Mx8+JPdkG8lWrbBIKHvnwDSiV0LcWHVOYkkXkUhffU0R13sb0o6IUvwGCQ/kVG8v9zlGBf1KyK/WhcBAsUO0hgGj6NDV+vSawHFTfJ2OcRtFH5XLdvweUMZfMU8UYRf6+M9lUxXqBPbuIPvc9/mIQmS5oFUbK+6XiNetj9agT0nFE9cuN12GIucoukl2DGh/Ba+5FTXH+xoDOdZvEO/S1kAZFgP6AeEoBflVBRBUTyzG6m/si0YpSZn+PyENeGNx8TeYGSZ6HJjum2MChy8w/yBtadrBDbgsGnwNnPADaxgPvNnNaNgRozKKR+qpehutwMO+IPbRQ2AnTbZSIUOO7ppzBn1j8D8UcDM1D8M059tkQ/5dIN7dWGXIEwQkHDp1t+YcD4+ZirkOYjbTYIbux49y+LlA6k+EZ6HQE1Ac3AG2SkMwK5j9eMSAEii/JB97c0z6bMNyPCgyxmMYLADz0zX0AN7SwbKZLcxNq+2HT2CEpaS2EOT2aDWNYyGhyF8ML43e+k9M2esA2MEpi2AS5iahrVZjDqyBlvLrYEsN+uz0h/pR35d+/RRcf4aT4Eul1iJRpqZ8mfsq3aLBmkkTgpBuG9gXK4pUIT2rj7Hf0g+2oh6RETc6Ja5H4egZZdMbd2wxXf76ef4EP4CG0OsbS1k/rVA1/uul0x0N7rRsbmRcxhyARicfNCY8mY61gBOtnKCA3WBumG+RaeZ72EDzJ84X12sj9sxlPFrnQFgJ3LZuWW6rsmZbgr+Lt4rRhcB3gxIVfV09i7b6TYdkufzFg+/MxGxHbPtYAxfaxwkoNlOhO/LUolSTwN54i5XEDRFbXXgjIjkK0Mox0TFa7ADsOs1hTGw11tisGFDH7Xv6KvGH+FNOeYymuIHTSxQASqL36WHOZdSIp8K6WbldmWZqudJbtDjm3jovt80Rp68L7/lEotduXxJF1FMZK81ovajvlUBNCSxnUXjq5dTHttY+6bBJsqfJgt5mMbxcWbZQ7OlU09Z2v94FEwDIGaSzzGwClyflAts5C1yoMM2Hq9rHNG7Rb7GPDTzj4LNZB9FTJokqBs1ulDu/CTnARV0Hmgo4CsMm8sgeyayAIQHItPMnzgFqToA4B2M7mH6UPyP/6qBKa8Dc4sMVT0rByR+sMnb3H1rdYYmGkZhuZ4zCTRcBruZcOPxE59hM3PTBi8XEd0AJqw8KrwENhU/9bhcRlJaCsYN4So5Q1ccxXIGmwC1RqMdzthPHCWC9Nk8Y0YgsSJK3HCiI3AyI0JE+sFKnvDuZLwUvsivn5S4Qqx9sNlizLAw7hfeTl+Y5Ox7ZDEuhO+vFfJm6y/r3f8vM83jruzySZLBj627RiSc/XNro4MqsmDQChMAW3EUM7marG3qK9/XVWUcidxhGKDMiT23JZdJrgUR0Y17DahhaI4/bzPEOSl/uE4SdEEPBrFEHia+oiAbf7jI/r5jdrXSbi38nOpYOJYTvAPSFgfuugi7CbIWNcP7bDW0W9WBAsu6VRbdr7PV73tacbz4S9E+mW1tIAFR50V/RXO0LCZEku7ZPePpcmzn0xhBp4ZocOFHY0bY1amutdpvY3vG5/AtWgfX205o+NaK8TvTiMGpTyBRqBkpnwwgk/vBML46AjodCR6ZqR9oQH7cNDILVomxrT5+Teg1P668yqTr2Xfsi1f6gH1SqXb2qvfRk+ew4zLWws19cKcaZBTNzgjbw51ENyvgy8y3oY0EfgoYkTtFf9B/r3ZxxD6rrISvvtvwpeO6rRl99jD45nq5fa335JpNtpW0shY0pJ5cPxxAiAlGX7DVthVuVUm0GzNU020uX0odjMdDcymQxcUxTUxaVdGEUC6H7HS/Ru4+AjGnyKV9qR0W+0IARszxmnXqlrQC4NYk288GjhvWP4MQj4ySAkLbPYtmsAZbycEDz9jcUlc9p6oqg7HtmI30zt6AmltfYP6UxThq24kpylaBNHpCimuQ6+NPDoYKGBp6FgyZbWFo3wZNrU2ooQBQckitNTv27xx3xffZLCa75kBlNZHyY6w3Syi8n8NjWrBe2iudCvROInuhbMvNV+BTbKZToWQ/vSO6xSRgv8egrLLJ8yw6J158u/VRIHCns6RSCipo+veMtrsQChTn5bfBxQc0O+4l1/VokLu5b7Pbkb1vs3FES133xUT+Q5XJfOUF6nbVytuualP/s2xjQqhiS78f7CQpSs96Zz7Ay4Pyq3XAh0764XyG7IyCX+3YgfON8Tu3luyENJOwA5aLgdZhspgI9Q6xHQGeiLopRg5xUjOsQb2CmagqGG9QPwY5HPzPU4pr3nm58S7gOVybiBsIo6CFTfM2HscKXGHQ3Zjw6acd/eI7GicEGq3R6r44p3+JRBCi3l8QGTujsDEQdaQfFmhRN6s+5/F9IGco3NpMC/3EbvT+7f9mAQN7pxl5iJk33QZFazEZnyn2paiiOrsYedCAgcPMchfoKuPicqNchkdpbPX1syCj26QF4B73EZSeA4EGjmG8PFlBPgX9OOBTZrywO0fmga2lpyTG2wcQsS0ZL+MluUP5lHp0blp4M8e3s5j6wUFo7WiUDbPys54k5zPsEqMwzx1pBvf4098VsIRZsRXZMQ90DGEO4Wp9x/guv5o9humPbsxJnrtYzeUqqXUCRJjXiaaiZTffs5Lp2LD/WtNnxKYiziM92I0Q3jLY8NyetKMy4IIekP4HQNCDHdor3OKlDMIv8mkg38t2lbnt10cfcNuv+ME6VmC5wt7a5+Sm+kffbVy/MkwLdsXGB75bg8T6uRFLSub23Wwk/gubHW157wDK5PnFZytmGjc37WPfSycPsc4My8FcaREvT5ignuvfKpsvY3ogT1Iyrt2o3cZ5Z/zYdMKgkAi2QNPmI70wKMpY9NkRN2ACmAQzzXedkc6/DB4EMmUgqSuDYhOOwosPJEsbxnKm/eK4Eygt/NSWQ9szcBzbTosA4+bwvEbDuckCurA/qc/WJiV1kauBLgaVmsqTVmWWW6hyj7d4xUNyKsYMztYZDZiHAiBUWUXGAKLMPEpPLajOTGZKyOQG/iAW8G1M+vBZwNBzsas2+zvoNvTWvFwN2YAYM7EoGYmY3HK7SksDuqa864Sdk7cVDUGgGAxZ9xxk7IBl2tUc/8i5cHcTDPIW88AatjS54w+Uo3D7bC456WlyIuFubjb0HMccS7cGWX9OClDzvZbViiwpA+viEkLYus3Dl5L0KWGjeplmuDSWjkogpQzveaky7NozB12hqPd5zX2W1ZfVhnYC/im5LnLGF/FCGxlwD+YPZcc5p/4PylPe3ToZsNkEtKLXJgt97CIOgtt8rdA/4If1mvwlx1U9MHVNsV0/sZ/VjrfBPCa6G/3w4kAjtCE+SZsCQGpDsJ1F3VUAfpb8qq1gosXD9wg5ZSeixDvF2PXCJjkxGgL5ZjcXJf9cJ4DR12Tb6Z8VJWrjKKMfA7ImEtRgcP4kBaW6Fddq+Rr1tVxi90wf72igQPlzcKQP4mI5IlmvG0CYgZvU7iwjAwFOfjvN0eGjRPLArKjCSsjbeGBoMDvKy59B4JloPJ4anmeIPF6qcLbVF4+E9fOpPdDBtqhoT6623JbzlRGNNBLTWwaSWBerXn+cMlorGx1N/FJavxVg90zIg0sRyPu2sHw/QS9v5agZreWxKsvDmPlOdwYz7VaBcxAbF3XpR9rFJWW/Pkzy1iP/Rhk8Lui4Bz2U3ZjsMJdDCeMVZwhrB/UvPUoh/PCYwqZ1Z20Xsak90yKtjbm7K9mRj09qWz6zXgV/fufNr1lkRx8PTQ4t7noOW8BZg70zhAchY+qzPjWtvFk/mSzIGPPfRAM/R6Y1OCR1xAIGq6SZcOrkuWj/t6Qyxu7iCfSlmWyKxu33vPa8DW0X+OACJC0XgL0pPuqag+TLfn2ywfpAsKNl+82yXuX3HYCUfwdgasHO7I6EyY6hfzMyw/qZEVSQ6foGrkoe13NlCeUvvNgW7XJx372KQ2MIk68KJEo9OYHA3J8Rm3Fb7YjhHFguqF9vzV48MT2mSUED0kIwxeO4MUmb5ejSe71JEwCeZNVFl5jsxQv9g7qN+lG+gH9abfsEGcUxd93wuCfvEAGALwLQat1jsIHl6cJ19z8rWbdHAgKQQzvdPHZp41JpE7Xhs50MoWelP6bhwArw8m8TitaOtVkUivfDFbiXrz2hXd+TWktBrvr4Fn2zrXkff70LpRO5/QYEsv7ytaf8VBTioNCeGbhscL+pt8WZVv2N07UZNRp8Nz9vmNmrjiZHff8NsP536HyOngvlfC4+0bcyWDgsLzYP//8K/ceX2zK89K/6zFlSYsdOtUv9TZKE0j9Nvx9FAI1A/zYsOpWzv6GDMXlSB6tf6Sr14cvt+9vxlHfqn/N2ck9pHusRM+tbp/5cVx3YtHlPTv8v7m9W5VVia06fP6OB0U4IDKlBNsbdoJ6Vd+00Yr4HuOGFNyti8oavyCtZtP4ZItOG1yx1VuWi/khbfFGbRKC9LSZql2Pfb3ORZS6bvKh0mmcgzMyUO7rokDHmbmPWNbNVvQU8K7NlXGNEHghet9cDYYb19tmISAIWnhoQOf6CD5rJ3MbtY+7oUxG1A5255efoiSVDQD2XLdNsLZrX+CAwtKyONIPnvzcGATKb+JpOySh5SSiCGu6vi5xnZevxlNv3sDb5Pr4CWp7ducIkIp+iC3+ooiZrnuqOmlfOyspdAS36qmlQNhutP4Pvg5dbk8c9PKttWLUzJjsKbtdNfhHbFCjuAG9JdKG8V90qrUW/03x2r8rQNbSlLK3Ba4lHFzxpI3Gzs0chA109lyH1/bL53UNZR/f+wVVyqMHuebg9B2O3ToJkmqWBfLylOh4378Pq86iLntf7uFVbs2M2w61THOzs7H/ekTuT2ZNjPkRmFXKmNMiClq7JudZmcosF8JXN03bSbuuwbR7saG+tZc7xYd8+3z++ANi5tBRRl0G2+393mNdndmR5yqOwbb4yOYGwB4pjoWwbT3gAs5J4kp83d32/Q+nW4gt8crupv2hLPJeD18on5nZGYd/ncP6ymyhy7o6lEchcFWwoVvX+bIlhoS05MGGy7xp3/ZzQrx4GFwcbEULGC8gYOWDaC8JT9QvrWm0YhGe6vNEEg8sCAKLjZdZtNS+cJeqZOlnPZwlp/UB2wrcgKeOBoxlDZnbf6NjxeJzNiHzoRTnmk7c8Z1vykY9VcOK2VV3nPVDQY2dwywH+Cf8Wse8fIkfScQcjBXeP6bpmx2Ji2zmjW5/xxN9hDRJbE5MaxL5at6nBP8j2lMT1fZsP1TpXQU0ooAUO/DGRvuNdt4OHzZCfDhtI8FnMIxHhrr/nldxLbqdUA6m1sX4y3xhYa9Owbv4YnR8L4Bjosxps/cCxsyN6xEEWV0dDEQivaGZPrK01v6kfWCQEhfYNpfq4EBW21sCKk6JsZ5Af91srSmfeS+C/DcB8OydvQnLlJ/4h83LSf/YNzJXtrPlJBPXct7DIu1bn/ydzKH5DjpiwBJDYx9EYs177QJbS+Ct+TDa9TGkZ5SlTBKCfUK97PcY3RHOf3yLmamt8sOPP+foA+rE9JxeX+QyIu53dwPmLfZzR4RjoQGuEr1E44pkeSFQvJTLqIjQO8lYQALu7WF9KrHILfQrP8lSIt317Og407jtGxBYdXsHwEtEAutVWjUT5lZEFM9yaMxpVecyeaTaCbKLcF4NH3y4aC717Z9Ub1Ag4nZMOC9dOxUz6IhKF7t/GuK0NFqdvypgXdHKeEATqRKArsHBSjnl8BEzXqY3sQJCR8AHDGkzmv2N5fJVmnUEP/EZ8wSOgqMoz25fkT9qujKLyjRdvwhcFpPOdbe4kT8jx6lB3LHgPca6PnzBYFnwIP5WT1sFRkM6rrJHz0KQPn7NZg5vI2YDWYuav39s5H/t+R4sTjyy4n3FA1RlWAWbRGVlf1qDfJucpH46nCsjRRK5SH8JTbMs7WAkw+t9VW7UFPslcViTuJ2fXil6KZnYn3neysLMrse8qGIgB6ny05tsayDWCk9pmVzbM6lrcI+uZOWji7Byn5gMrHxk/DPiE/M4I2QtYxuW74LEKRlqhLzWY5vGtDOukhtzCkf/X5qe5Sk11wYM1+SmJyFZ8DFNa1AB7dFfNKjPpS+7uZN9Z/WH/3pTwPeziuHeRvLRjA/bVPpFzHtin7GjwFeVCR5VsEXP/X8s0e2MRJjClS7HluMZxdw5/yrijP3SlQR/wyE8MejGgWNoy9w2rTKskXpzPwb0LWHzdFR8euDO0qT91fkh3kSuzOttR9XwaD2ifoJmi7hhDAx0JdewJyzPb8mhHwwnQDBS1Lowt1CPCBTAji8qvINsZ4QAAXLjlRVgOfeAEURDgSvylp2iI8sGvHc2zNFVZIjEYP+QClVY47ARGukWLhvMUp0bDWzvGwHHIEmBbwOZxvYqn+LvLeBTZqYrn0gEUVysDMqNZZr+Rt12FTSnbrgOaKJ3+79OgEJnhdhNTbr8a9zJz1+IOGrAJP5OBjuXcH3tlWcmMu6d+pJZntkr6dzwKhFPuzHSU3RbnvkENexfa+W4daTmzb1XwUelZlJMQbMCYU8nA1k6vdrT6Xk7stiz1OR52rU/ne1IDA7XDLqTikB+0SxnI7hIWTTCxACaVi4onuV7YM2u57Ot0Tauyan+b7Y5gsmHdVmhnGTrYsWvtw5Q3dZZf3+7bPhk3Jirs6AjnJBn0UK5MxCecr692VoTu5UoW1wf7EXOt/e1UCyl9dJfltaqNYiIKzJUlYsq+PF3XRucw69ayZ/JBYg2IF90X3a1tX42zvL5v++iVtT3k2+sSCyAN2ML7IPix7xfru7GQatxej0FmEIYe0O8/2OcCDohqCZahSbnJ8YJZ0LLjZfJ79bdeFwVsVkoEYLZdqWyyKNRnrwCdgfoY5OxaFqMfDV+agxaCpWWAsJrNzmUsj0Znxrk9P3IgkYUiaEAk6oBdhCbNIfhCTGvgJGPJRTrffqeryIpNhuaDwgmvcQ3UssQzvAuj5vhLN9V24RhOyPEYup9lBzNVmnnOg8+8xXtNMy/ASDCswUlBUKf6U8lGIQsDZwEQgEBKhbPhBdengK7OltcdXUFnF7JMmorM9DUDGkzkxJKz9nO7sdyTqCCvd5aKphd/G/A8JfNLnk/fdQHcFAQHr5/WqIVq3lqmN+2lvwuw8CUqZ3fiF54Eh2s+a3vFhY1T/QBFczIBgPN3sjLfzdZlhTFhSm8ab8F18UGVzUxBHUXZy/1X9KlstF45t+cSU6SJjxjYxeXodnJtO9Cul/xAWQq2TnPIBHgO6qKu4O4u1FpgIVjZgsc49uxhfLszr+0S4YpxeoVl0BTbqdoXH9jGsx082zGOvAqWMTmVabk18eVbOFW5jwMNmwz226cOk4mQ2HSkTD0WkUuo0BPl6S49ZxpdmVSVXTEP5dJBq9D3eGOxKAnjdl7J4t8lBoWdCIEBmg8MUNpitHbSMQVCZYuLMPwxX9TCglRrW8A0nxmHe3r2XhQV+PoZsnGVAUSke2EYI/i4nVEaC1GAi1GiOHKXeig8VW+Sg77pyLEQUSNifJiaUE8JlmSX5cI+gkOMGR2Vqwxs81ifK0jeBc22x66Fb4OAM3QODcrAvsOSB5s+a09gIhORPPTnsp4jABL9s/zX5QA16k2eoQb/I2VAhQkS5j9T0BXdoUsWF21V9AzMZNkXh5qO6OHaLLKxFcgMJT6xdi54HI3T3m72tcyZ3Dj/K/lvBJ+zdyt++VIfjSsDwzNa7cLgDjV++wTLxL/VxIFBcktJ+gLTFGildhY+f1ZvRvA9s74MmgmofZFRXJ2x49t8CWfaG5HhDP+Sj9a0FFrVwqcDw8TUH8bfTUIlywVmC7d8LeTTw9ZaX73vyveDX92MwLXMRHT3cTdmouLB+mQDAddXOAbtuh/FhAfle46Tdm1ox8ILC4Meb5RHHxlfp1335Hx/TGK3EKS4quPObFFc2bOVe/TBvno7dV9PJ3/zgPJvybkKFSwEHN+huKPwrfaWWRmuDv+sgzLvkw0Q1uDi75Co3SqTE7emH7Ufgo3eDirvXM3RaGew4Psog6IFIIJelm0vagUeax08auvX2b5Zm/92GyPzEgCzP6rgA7bnPVSOIoJST7PjEfKzCtQ/pb+xtn+f/hf4/RTa/2/Rb2zKb8uf9K3+atJd5c9+TRu/8W/Qk/leJfB+RY2o0c+YntUbJP+ZuZOkzqfd7eUvJEPqRlIS7gk1KrCB4Py2SpqIfZq/kEaCJzl7ci4DRUkY5yc2g9v/npd66aWXXnrppZdeeumll/7j9A99sO+ll1566aWXXnrppZde+v9Eb6Dx0ksvvfTSSy+99NJLL32d3kDjpZdeeumll1566aWXXvo6vYHGSy+99NJLL7300ksvvfR1egONl1566aWXXnrppZdeeunr9AYaL7300ksvvfTSSy+99NLX6Q00XnrppZdeeumll1566aWv0xtovPTSSy+99NJLL7300ktfpzfQeOmll1566aWXXnrppZe+Tv8HzwCdBJzqoasAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_images = sorted([p for p in (dataset_dir / \"images\" / \"train\").iterdir() if p.suffix.lower() in [\".jpg\", \".jpeg\", \".png\", \".bmp\"]])\n",
    "sample_img = random.choice(train_images)\n",
    "sample_lbl = dataset_dir / \"labels\" / \"train\" / f\"{sample_img.stem}.txt\"\n",
    "\n",
    "img = cv2.imread(str(sample_img))\n",
    "img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
    "h, w = img.shape[:2]\n",
    "\n",
    "if sample_lbl.exists():\n",
    "    for line in sample_lbl.read_text().splitlines():\n",
    "        cls_id, xc, yc, bw, bh = map(float, line.split())\n",
    "        x1 = int((xc - bw / 2) * w)\n",
    "        y1 = int((yc - bh / 2) * h)\n",
    "        x2 = int((xc + bw / 2) * w)\n",
    "        y2 = int((yc + bh / 2) * h)\n",
    "        cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 2)\n",
    "\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.imshow(img)\n",
    "plt.axis(\"off\")\n",
    "plt.title(sample_img.name)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfeb2c52",
   "metadata": {},
   "source": [
    "## 9. Подбор anchors под конкретный `imgsz`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1c155714",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{512: [[32.6, 43.7, 53.2, 42.3, 52.8, 65.8],\n",
       "  [71.8, 51.5, 86.8, 60.9, 100.7, 76.3],\n",
       "  [111.0, 105.6, 134.4, 88.5, 206.8, 146.5]],\n",
       " 640: [[40.7, 54.6, 66.5, 52.9, 66.0, 82.2],\n",
       "  [89.7, 64.3, 108.5, 76.1, 125.8, 95.3],\n",
       "  [138.8, 132.0, 168.0, 110.6, 258.5, 183.1]]}"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def collect_wh_from_yolo_labels(label_dir: Path, imgsz: int):\n",
    "    wh = []\n",
    "    for txt_path in label_dir.glob(\"*.txt\"):\n",
    "        for line in txt_path.read_text().splitlines():\n",
    "            parts = line.strip().split()\n",
    "            if len(parts) < 5:\n",
    "                continue\n",
    "            bw = float(parts[3])\n",
    "            bh = float(parts[4])\n",
    "            wh.append([bw * imgsz, bh * imgsz])\n",
    "    wh = np.asarray(wh, dtype=np.float32)\n",
    "    return wh[(wh[:, 0] > 2) & (wh[:, 1] > 2)]\n",
    "\n",
    "def make_anchor_groups(imgsz: int, label_dir: Path):\n",
    "    wh = collect_wh_from_yolo_labels(label_dir, imgsz)\n",
    "    if len(wh) < 9:\n",
    "        raise ValueError(\"Недостаточно bbox для подбора 9 anchors.\")\n",
    "    km = KMeans(n_clusters=9, random_state=SEED, n_init=20)\n",
    "    km.fit(wh)\n",
    "    anchors = km.cluster_centers_\n",
    "    anchors = anchors[np.argsort(np.prod(anchors, axis=1))]\n",
    "    groups = anchors.reshape(3, 3, 2)\n",
    "\n",
    "    # Формат для YOLOv5: [[w1,h1,w2,h2,w3,h3], ...]\n",
    "    groups_yolov5 = []\n",
    "    for group in groups:\n",
    "        flat = []\n",
    "        for w_, h_ in group:\n",
    "            flat.extend([round(float(w_), 1), round(float(h_), 1)])\n",
    "        groups_yolov5.append(flat)\n",
    "    return groups_yolov5\n",
    "\n",
    "anchor_candidates = {}\n",
    "for imgsz in IMG_SIZE_CANDIDATES:\n",
    "    anchor_candidates[imgsz] = make_anchor_groups(imgsz, dataset_dir / \"labels\" / \"train\")\n",
    "\n",
    "anchor_candidates"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33acc8f3",
   "metadata": {},
   "source": [
    "## 10. Конфигурационные файлы YOLOv5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b54c84d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/konnilol/Downloads/work_hf_yolov5n_car/car_data.yaml\n",
      "/home/konnilol/Downloads/work_hf_yolov5n_car/hyp_car_tuned.yaml\n"
     ]
    }
   ],
   "source": [
    "data_yaml = {\n",
    "    \"path\": str(dataset_dir),\n",
    "    \"train\": \"images/train\",\n",
    "    \"val\": \"images/val\",\n",
    "    \"nc\": 1,\n",
    "    \"names\": [\"car\"],\n",
    "}\n",
    "data_yaml_path = WORKDIR / \"car_data.yaml\"\n",
    "with open(data_yaml_path, \"w\", encoding=\"utf-8\") as f:\n",
    "    yaml.safe_dump(data_yaml, f, sort_keys=False, allow_unicode=True)\n",
    "\n",
    "base_hyp_path = Path(\"yolov5/data/hyps/hyp.scratch-low.yaml\")\n",
    "with open(base_hyp_path, \"r\", encoding=\"utf-8\") as f:\n",
    "    hyp_cfg = yaml.safe_load(f)\n",
    "\n",
    "hyp_cfg[\"lr0\"] = 0.003\n",
    "hyp_cfg[\"lrf\"] = 0.12\n",
    "hyp_cfg[\"warmup_epochs\"] = 3.0\n",
    "hyp_cfg[\"degrees\"] = 0.0\n",
    "hyp_cfg[\"scale\"] = 0.2\n",
    "hyp_cfg[\"translate\"] = 0.1\n",
    "\n",
    "hyp_path = WORKDIR / \"hyp_car_tuned.yaml\"\n",
    "with open(hyp_path, \"w\", encoding=\"utf-8\") as f:\n",
    "    yaml.safe_dump(hyp_cfg, f, sort_keys=False, allow_unicode=True)\n",
    "\n",
    "print(data_yaml_path)\n",
    "print(hyp_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "827f818e",
   "metadata": {},
   "source": [
    "## 11. Пилотный подбор размера входа"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9710c84d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Запуск: /home/konnilol/.pyenv/versions/3.12.12/bin/python yolov5/train.py --img 512 --batch 16 --epochs 5 --data /home/konnilol/Downloads/work_hf_yolov5n_car/car_data.yaml --cfg /home/konnilol/Downloads/work_hf_yolov5n_car/yolov5n_img512_custom.yaml --weights /home/konnilol/.cache/huggingface/hub/models--fcakyon--yolov5n-v7.0/snapshots/e63eb5a3061a09a639094279fd5082bc51d8a019/yolov5n.pt --hyp /home/konnilol/Downloads/work_hf_yolov5n_car/hyp_car_tuned.yaml --project /home/konnilol/Downloads/work_hf_yolov5n_car/runs/train --name pilot_img512 --exist-ok --workers 0 --device 0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[34m\u001b[1mtrain: \u001b[0mweights=/home/konnilol/.cache/huggingface/hub/models--fcakyon--yolov5n-v7.0/snapshots/e63eb5a3061a09a639094279fd5082bc51d8a019/yolov5n.pt, cfg=/home/konnilol/Downloads/work_hf_yolov5n_car/yolov5n_img512_custom.yaml, data=/home/konnilol/Downloads/work_hf_yolov5n_car/car_data.yaml, hyp=/home/konnilol/Downloads/work_hf_yolov5n_car/hyp_car_tuned.yaml, epochs=5, batch_size=16, imgsz=512, rect=False, resume=False, nosave=False, noval=False, noautoanchor=False, noplots=False, evolve=None, evolve_population=yolov5/data/hyps, resume_evolve=None, bucket=, cache=None, image_weights=False, device=0, multi_scale=False, single_cls=False, optimizer=SGD, sync_bn=False, workers=0, project=/home/konnilol/Downloads/work_hf_yolov5n_car/runs/train, name=pilot_img512, exist_ok=True, quad=False, cos_lr=False, label_smoothing=0.0, patience=100, freeze=[0], save_period=-1, seed=0, local_rank=-1, entity=None, upload_dataset=False, bbox_interval=-1, artifact_alias=latest, ndjson_console=False, ndjson_file=False\n",
      "\u001b[34m\u001b[1mgithub: \u001b[0mup to date with https://github.com/ultralytics/yolov5 ✅\n",
      "YOLOv5 🚀 v7.0-463-g88af13e3 Python-3.12.12 torch-2.10.0+cu128 CUDA:0 (NVIDIA GeForce RTX 3080, 9873MiB)\n",
      "\n",
      "\u001b[34m\u001b[1mhyperparameters: \u001b[0mlr0=0.003, lrf=0.12, momentum=0.937, weight_decay=0.0005, warmup_epochs=3.0, warmup_momentum=0.8, warmup_bias_lr=0.1, box=0.05, cls=0.5, cls_pw=1.0, obj=1.0, obj_pw=1.0, iou_t=0.2, anchor_t=4.0, fl_gamma=0.0, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, degrees=0.0, translate=0.1, scale=0.2, shear=0.0, perspective=0.0, flipud=0.0, fliplr=0.5, mosaic=1.0, mixup=0.0, copy_paste=0.0\n",
      "\u001b[34m\u001b[1mComet: \u001b[0mrun 'pip install comet_ml' to automatically track and visualize YOLOv5 🚀 runs in Comet\n",
      "\u001b[34m\u001b[1mTensorBoard: \u001b[0mStart with 'tensorboard --logdir /home/konnilol/Downloads/work_hf_yolov5n_car/runs/train', view at http://localhost:6006/\n",
      "\n",
      "                 from  n    params  module                                  arguments                     \n",
      "  0                -1  1      1760  models.common.Conv                      [3, 16, 6, 2, 2]              \n",
      "  1                -1  1      4672  models.common.Conv                      [16, 32, 3, 2]                \n",
      "  2                -1  1      4800  models.common.C3                        [32, 32, 1]                   \n",
      "  3                -1  1     18560  models.common.Conv                      [32, 64, 3, 2]                \n",
      "  4                -1  2     29184  models.common.C3                        [64, 64, 2]                   \n",
      "  5                -1  1     73984  models.common.Conv                      [64, 128, 3, 2]               \n",
      "  6                -1  3    156928  models.common.C3                        [128, 128, 3]                 \n",
      "  7                -1  1    295424  models.common.Conv                      [128, 256, 3, 2]              \n",
      "  8                -1  1    296448  models.common.C3                        [256, 256, 1]                 \n",
      "  9                -1  1    164608  models.common.SPPF                      [256, 256, 5]                 \n",
      " 10                -1  1     33024  models.common.Conv                      [256, 128, 1, 1]              \n",
      " 11                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          \n",
      " 12           [-1, 6]  1         0  models.common.Concat                    [1]                           \n",
      " 13                -1  1     90880  models.common.C3                        [256, 128, 1, False]          \n",
      " 14                -1  1      8320  models.common.Conv                      [128, 64, 1, 1]               \n",
      " 15                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          \n",
      " 16           [-1, 4]  1         0  models.common.Concat                    [1]                           \n",
      " 17                -1  1     22912  models.common.C3                        [128, 64, 1, False]           \n",
      " 18                -1  1     36992  models.common.Conv                      [64, 64, 3, 2]                \n",
      " 19          [-1, 14]  1         0  models.common.Concat                    [1]                           \n",
      " 20                -1  1     74496  models.common.C3                        [128, 128, 1, False]          \n",
      " 21                -1  1    147712  models.common.Conv                      [128, 128, 3, 2]              \n",
      " 22          [-1, 10]  1         0  models.common.Concat                    [1]                           \n",
      " 23                -1  1    296448  models.common.C3                        [256, 256, 1, False]          \n",
      " 24      [17, 20, 23]  1      8118  models.yolo.Detect                      [1, [[32.6, 43.7, 53.2, 42.3, 52.8, 65.8], [71.8, 51.5, 86.8, 60.9, 100.7, 76.3], [111.0, 105.6, 134.4, 88.5, 206.8, 146.5]], [64, 128, 256]]\n",
      "YOLOv5n_img512_custom summary: 214 layers, 1765270 parameters, 1765270 gradients, 4.2 GFLOPs\n",
      "\n",
      "Transferred 342/349 items from /home/konnilol/.cache/huggingface/hub/models--fcakyon--yolov5n-v7.0/snapshots/e63eb5a3061a09a639094279fd5082bc51d8a019/yolov5n.pt\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "\u001b[34m\u001b[1mAMP: \u001b[0mchecks passed ✅\n",
      "\u001b[34m\u001b[1moptimizer:\u001b[0m SGD(lr=0.003) with parameter groups 57 weight(decay=0.0), 60 weight(decay=0.0005), 60 bias\n",
      "\u001b[34m\u001b[1mtrain: \u001b[0mScanning /home/konnilol/Downloads/work_hf_yolov5n_car/dataset_yolo/labels/train... 284 images, 0 backgrounds, 0 corrupt: 100%|██████████| 284/284 [00:00<00:00, 19398.78it/s]\n",
      "\u001b[34m\u001b[1mtrain: \u001b[0mNew cache created: /home/konnilol/Downloads/work_hf_yolov5n_car/dataset_yolo/labels/train.cache\n",
      "\u001b[34m\u001b[1mval: \u001b[0mScanning /home/konnilol/Downloads/work_hf_yolov5n_car/dataset_yolo/labels/val... 71 images, 0 backgrounds, 0 corrupt: 100%|██████████| 71/71 [00:00<00:00, 11038.87it/s]\n",
      "\u001b[34m\u001b[1mval: \u001b[0mNew cache created: /home/konnilol/Downloads/work_hf_yolov5n_car/dataset_yolo/labels/val.cache\n",
      "\n",
      "\u001b[34m\u001b[1mAutoAnchor: \u001b[0m7.86 anchors/target, 1.000 Best Possible Recall (BPR). Current anchors are a good fit to dataset ✅\n",
      "Plotting labels to /home/konnilol/Downloads/work_hf_yolov5n_car/runs/train/pilot_img512/labels.jpg... \n",
      "/home/konnilol/Downloads/yolov5/train.py:357: FutureWarning: `torch.cuda.amp.GradScaler(args...)` is deprecated. Please use `torch.amp.GradScaler('cuda', args...)` instead.\n",
      "  scaler = torch.cuda.amp.GradScaler(enabled=amp)\n",
      "Image sizes 512 train, 512 val\n",
      "Using 0 dataloader workers\n",
      "Logging results to \u001b[1m/home/konnilol/Downloads/work_hf_yolov5n_car/runs/train/pilot_img512\u001b[0m\n",
      "Starting training for 5 epochs...\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.06G     0.1349    0.02872          0         39        512:   6%|▌         | 1/18 [00:01<00:31,  1.86s/it]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.09G     0.1343     0.0288          0         39        512:  11%|█         | 2/18 [00:02<00:16,  1.02s/it]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.09G     0.1343    0.02948          0         50        512:  17%|█▋        | 3/18 [00:02<00:09,  1.56it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.09G     0.1342    0.02938          0         40        512:  22%|██▏       | 4/18 [00:02<00:06,  2.17it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.09G     0.1342    0.02964          0         50        512:  28%|██▊       | 5/18 [00:02<00:04,  2.81it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.09G      0.134    0.02979          0         52        512:  33%|███▎      | 6/18 [00:03<00:03,  3.42it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.09G     0.1341    0.02929          0         39        512:  39%|███▉      | 7/18 [00:03<00:02,  3.96it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.09G     0.1339    0.02905          0         43        512:  44%|████▍     | 8/18 [00:03<00:02,  4.41it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.09G     0.1336     0.0288          0         43        512:  50%|█████     | 9/18 [00:03<00:01,  4.80it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.09G     0.1332    0.02889          0         44        512:  56%|█████▌    | 10/18 [00:03<00:01,  5.10it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.09G     0.1327    0.02881          0         40        512:  61%|██████    | 11/18 [00:03<00:01,  5.30it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.09G     0.1325    0.02848          0         36        512:  67%|██████▋   | 12/18 [00:04<00:01,  5.48it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.09G      0.132    0.02857          0         47        512:  72%|███████▏  | 13/18 [00:04<00:00,  5.61it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.09G     0.1318    0.02838          0         41        512:  78%|███████▊  | 14/18 [00:04<00:00,  5.68it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.09G     0.1314    0.02827          0         39        512:  83%|████████▎ | 15/18 [00:04<00:00,  5.75it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.09G      0.131    0.02804          0         32        512:  89%|████████▉ | 16/18 [00:04<00:00,  5.81it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.09G     0.1306    0.02806          0         45        512:  94%|█████████▍| 17/18 [00:04<00:00,  5.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.09G     0.1302    0.02808          0         32        512: 100%|██████████| 18/18 [00:05<00:00,  3.20it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.09it/s]\n",
      "                   all         71        117    0.00169      0.308    0.00118   0.000347\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.17G     0.1222    0.02929          0         47        512:   6%|▌         | 1/18 [00:00<00:02,  5.78it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.17G     0.1215    0.02947          0         43        512:  11%|█         | 2/18 [00:00<00:02,  6.01it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.17G      0.122    0.02795          0         34        512:  17%|█▋        | 3/18 [00:00<00:02,  5.98it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.17G      0.122     0.0269          0         34        512:  22%|██▏       | 4/18 [00:00<00:02,  6.09it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.17G     0.1217    0.02656          0         35        512:  28%|██▊       | 5/18 [00:00<00:02,  6.04it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.17G     0.1209    0.02636          0         39        512:  33%|███▎      | 6/18 [00:00<00:01,  6.15it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.17G     0.1207    0.02628          0         39        512:  39%|███▉      | 7/18 [00:01<00:01,  6.09it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.17G     0.1199    0.02703          0         47        512:  44%|████▍     | 8/18 [00:01<00:01,  6.18it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.17G     0.1191    0.02703          0         32        512:  50%|█████     | 9/18 [00:01<00:01,  6.10it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.17G     0.1183    0.02693          0         32        512:  56%|█████▌    | 10/18 [00:01<00:01,  6.17it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.17G     0.1178    0.02741          0         52        512:  61%|██████    | 11/18 [00:01<00:01,  6.08it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.17G     0.1169    0.02775          0         40        512:  67%|██████▋   | 12/18 [00:01<00:00,  6.15it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.17G     0.1164    0.02855          0         58        512:  72%|███████▏  | 13/18 [00:02<00:00,  6.07it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.17G     0.1157    0.02918          0         54        512:  78%|███████▊  | 14/18 [00:02<00:00,  6.12it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.17G      0.115    0.02981          0         48        512:  83%|████████▎ | 15/18 [00:02<00:00,  6.07it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.17G     0.1143    0.03064          0         58        512:  89%|████████▉ | 16/18 [00:02<00:00,  6.15it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.17G     0.1136    0.03051          0         32        512:  94%|█████████▍| 17/18 [00:02<00:00,  6.08it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.17G     0.1127    0.03082          0         31        512: 100%|██████████| 18/18 [00:02<00:00,  6.18it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.75it/s]\n",
      "                   all         71        117    0.00446      0.812     0.0193    0.00473\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.17G    0.09894     0.0369          0         45        512:   6%|▌         | 1/18 [00:00<00:02,  5.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.17G    0.09879    0.03712          0         46        512:  11%|█         | 2/18 [00:00<00:02,  6.13it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.17G    0.09859    0.03679          0         45        512:  17%|█▋        | 3/18 [00:00<00:02,  6.06it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.17G    0.09809    0.03807          0         54        512:  22%|██▏       | 4/18 [00:00<00:02,  6.14it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.17G    0.09731    0.03691          0         37        512:  28%|██▊       | 5/18 [00:00<00:02,  6.01it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.17G     0.0967    0.03573          0         33        512:  33%|███▎      | 6/18 [00:00<00:01,  6.10it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.17G    0.09621    0.03615          0         47        512:  39%|███▉      | 7/18 [00:01<00:01,  6.06it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.17G    0.09535    0.03555          0         34        512:  44%|████▍     | 8/18 [00:01<00:01,  6.13it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.17G    0.09444    0.03566          0         41        512:  50%|█████     | 9/18 [00:01<00:01,  6.08it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.17G    0.09391    0.03502          0         34        512:  56%|█████▌    | 10/18 [00:01<00:01,  6.11it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.17G    0.09331    0.03568          0         50        512:  61%|██████    | 11/18 [00:01<00:01,  6.03it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.17G    0.09208    0.03557          0         35        512:  67%|██████▋   | 12/18 [00:01<00:00,  6.09it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.17G    0.09159    0.03537          0         38        512:  72%|███████▏  | 13/18 [00:02<00:00,  6.05it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.17G    0.09089    0.03546          0         39        512:  78%|███████▊  | 14/18 [00:02<00:00,  6.12it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.17G    0.09027    0.03577          0         43        512:  83%|████████▎ | 15/18 [00:02<00:00,  6.06it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.17G    0.08959    0.03571          0         33        512:  89%|████████▉ | 16/18 [00:02<00:00,  6.13it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.17G    0.08908    0.03629          0         58        512:  94%|█████████▍| 17/18 [00:02<00:00,  6.13it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.17G    0.08875     0.0362          0         28        512: 100%|██████████| 18/18 [00:02<00:00,  6.15it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  6.01it/s]\n",
      "                   all         71        117      0.463      0.738      0.614      0.199\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.17G     0.0833    0.04773          0         63        512:   6%|▌         | 1/18 [00:00<00:02,  5.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.17G    0.08268    0.04509          0         53        512:  11%|█         | 2/18 [00:00<00:02,  6.10it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.17G    0.08032    0.04126          0         36        512:  17%|█▋        | 3/18 [00:00<00:02,  6.00it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.17G    0.08015    0.04011          0         40        512:  22%|██▏       | 4/18 [00:00<00:02,  6.06it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.17G    0.08008    0.04103          0         52        512:  28%|██▊       | 5/18 [00:00<00:02,  6.05it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.17G    0.07913    0.04065          0         40        512:  33%|███▎      | 6/18 [00:00<00:02,  5.99it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.17G    0.07801    0.04078          0         46        512:  39%|███▉      | 7/18 [00:01<00:01,  6.08it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.17G    0.07776    0.04102          0         48        512:  44%|████▍     | 8/18 [00:01<00:01,  6.11it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.17G    0.07756    0.04133          0         55        512:  50%|█████     | 9/18 [00:01<00:01,  6.06it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.17G    0.07687    0.04117          0         43        512:  56%|█████▌    | 10/18 [00:01<00:01,  6.12it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.17G    0.07626    0.04103          0         39        512:  61%|██████    | 11/18 [00:01<00:01,  6.17it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.17G    0.07575    0.04119          0         43        512:  67%|██████▋   | 12/18 [00:01<00:00,  6.07it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.17G     0.0752    0.04116          0         44        512:  72%|███████▏  | 13/18 [00:02<00:00,  6.15it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.17G     0.0751    0.04114          0         48        512:  78%|███████▊  | 14/18 [00:02<00:00,  6.15it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.17G    0.07518    0.04117          0         47        512:  83%|████████▎ | 15/18 [00:02<00:00,  6.07it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.17G    0.07497    0.04078          0         42        512:  89%|████████▉ | 16/18 [00:02<00:00,  6.10it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.17G    0.07436    0.04043          0         35        512:  94%|█████████▍| 17/18 [00:02<00:00,  6.11it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.17G    0.07427    0.03985          0         24        512: 100%|██████████| 18/18 [00:02<00:00,  6.15it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  6.05it/s]\n",
      "                   all         71        117      0.513      0.684      0.596       0.19\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.17G    0.06827    0.03798          0         44        512:   6%|▌         | 1/18 [00:00<00:02,  6.01it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.17G    0.06748    0.04061          0         44        512:  11%|█         | 2/18 [00:00<00:02,  6.15it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.17G    0.06682    0.03926          0         36        512:  17%|█▋        | 3/18 [00:00<00:02,  6.04it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.17G    0.06571    0.03803          0         36        512:  22%|██▏       | 4/18 [00:00<00:02,  6.11it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.17G    0.06593    0.03844          0         48        512:  28%|██▊       | 5/18 [00:00<00:02,  6.11it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.17G    0.06653    0.03796          0         45        512:  33%|███▎      | 6/18 [00:00<00:01,  6.04it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.17G    0.06657    0.03978          0         59        512:  39%|███▉      | 7/18 [00:01<00:01,  6.10it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.17G    0.06611    0.03934          0         38        512:  44%|████▍     | 8/18 [00:01<00:01,  6.13it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.17G    0.06573    0.03896          0         36        512:  50%|█████     | 9/18 [00:01<00:01,  6.03it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.17G    0.06525    0.03882          0         39        512:  56%|█████▌    | 10/18 [00:01<00:01,  6.05it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.17G    0.06525    0.03893          0         50        512:  61%|██████    | 11/18 [00:01<00:01,  6.10it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.17G    0.06471    0.03806          0         29        512:  67%|██████▋   | 12/18 [00:01<00:00,  6.03it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.17G    0.06447    0.03795          0         36        512:  72%|███████▏  | 13/18 [00:02<00:00,  6.09it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.17G    0.06461    0.03798          0         46        512:  78%|███████▊  | 14/18 [00:02<00:00,  6.02it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.17G    0.06456    0.03808          0         44        512:  83%|████████▎ | 15/18 [00:02<00:00,  5.96it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.17G    0.06437    0.03799          0         38        512:  89%|████████▉ | 16/18 [00:02<00:00,  5.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.17G    0.06437    0.03809          0         42        512:  94%|█████████▍| 17/18 [00:02<00:00,  5.97it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.17G    0.06438    0.03833          0         38        512: 100%|██████████| 18/18 [00:02<00:00,  6.12it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  6.09it/s]\n",
      "                   all         71        117      0.716      0.735      0.752      0.254\n",
      "\n",
      "5 epochs completed in 0.006 hours.\n",
      "Optimizer stripped from /home/konnilol/Downloads/work_hf_yolov5n_car/runs/train/pilot_img512/weights/last.pt, 3.8MB\n",
      "Optimizer stripped from /home/konnilol/Downloads/work_hf_yolov5n_car/runs/train/pilot_img512/weights/best.pt, 3.8MB\n",
      "\n",
      "Validating /home/konnilol/Downloads/work_hf_yolov5n_car/runs/train/pilot_img512/weights/best.pt...\n",
      "Fusing layers... \n",
      "YOLOv5n_img512_custom summary: 157 layers, 1760518 parameters, 0 gradients, 4.1 GFLOPs\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  4.48it/s]\n",
      "                   all         71        117       0.71      0.735      0.752      0.253\n",
      "Results saved to \u001b[1m/home/konnilol/Downloads/work_hf_yolov5n_car/runs/train/pilot_img512\u001b[0m\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Запуск: /home/konnilol/.pyenv/versions/3.12.12/bin/python yolov5/train.py --img 640 --batch 16 --epochs 5 --data /home/konnilol/Downloads/work_hf_yolov5n_car/car_data.yaml --cfg /home/konnilol/Downloads/work_hf_yolov5n_car/yolov5n_img640_custom.yaml --weights /home/konnilol/.cache/huggingface/hub/models--fcakyon--yolov5n-v7.0/snapshots/e63eb5a3061a09a639094279fd5082bc51d8a019/yolov5n.pt --hyp /home/konnilol/Downloads/work_hf_yolov5n_car/hyp_car_tuned.yaml --project /home/konnilol/Downloads/work_hf_yolov5n_car/runs/train --name pilot_img640 --exist-ok --workers 0 --device 0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[34m\u001b[1mtrain: \u001b[0mweights=/home/konnilol/.cache/huggingface/hub/models--fcakyon--yolov5n-v7.0/snapshots/e63eb5a3061a09a639094279fd5082bc51d8a019/yolov5n.pt, cfg=/home/konnilol/Downloads/work_hf_yolov5n_car/yolov5n_img640_custom.yaml, data=/home/konnilol/Downloads/work_hf_yolov5n_car/car_data.yaml, hyp=/home/konnilol/Downloads/work_hf_yolov5n_car/hyp_car_tuned.yaml, epochs=5, batch_size=16, imgsz=640, rect=False, resume=False, nosave=False, noval=False, noautoanchor=False, noplots=False, evolve=None, evolve_population=yolov5/data/hyps, resume_evolve=None, bucket=, cache=None, image_weights=False, device=0, multi_scale=False, single_cls=False, optimizer=SGD, sync_bn=False, workers=0, project=/home/konnilol/Downloads/work_hf_yolov5n_car/runs/train, name=pilot_img640, exist_ok=True, quad=False, cos_lr=False, label_smoothing=0.0, patience=100, freeze=[0], save_period=-1, seed=0, local_rank=-1, entity=None, upload_dataset=False, bbox_interval=-1, artifact_alias=latest, ndjson_console=False, ndjson_file=False\n",
      "\u001b[34m\u001b[1mgithub: \u001b[0mup to date with https://github.com/ultralytics/yolov5 ✅\n",
      "YOLOv5 🚀 v7.0-463-g88af13e3 Python-3.12.12 torch-2.10.0+cu128 CUDA:0 (NVIDIA GeForce RTX 3080, 9873MiB)\n",
      "\n",
      "\u001b[34m\u001b[1mhyperparameters: \u001b[0mlr0=0.003, lrf=0.12, momentum=0.937, weight_decay=0.0005, warmup_epochs=3.0, warmup_momentum=0.8, warmup_bias_lr=0.1, box=0.05, cls=0.5, cls_pw=1.0, obj=1.0, obj_pw=1.0, iou_t=0.2, anchor_t=4.0, fl_gamma=0.0, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, degrees=0.0, translate=0.1, scale=0.2, shear=0.0, perspective=0.0, flipud=0.0, fliplr=0.5, mosaic=1.0, mixup=0.0, copy_paste=0.0\n",
      "\u001b[34m\u001b[1mComet: \u001b[0mrun 'pip install comet_ml' to automatically track and visualize YOLOv5 🚀 runs in Comet\n",
      "\u001b[34m\u001b[1mTensorBoard: \u001b[0mStart with 'tensorboard --logdir /home/konnilol/Downloads/work_hf_yolov5n_car/runs/train', view at http://localhost:6006/\n",
      "\n",
      "                 from  n    params  module                                  arguments                     \n",
      "  0                -1  1      1760  models.common.Conv                      [3, 16, 6, 2, 2]              \n",
      "  1                -1  1      4672  models.common.Conv                      [16, 32, 3, 2]                \n",
      "  2                -1  1      4800  models.common.C3                        [32, 32, 1]                   \n",
      "  3                -1  1     18560  models.common.Conv                      [32, 64, 3, 2]                \n",
      "  4                -1  2     29184  models.common.C3                        [64, 64, 2]                   \n",
      "  5                -1  1     73984  models.common.Conv                      [64, 128, 3, 2]               \n",
      "  6                -1  3    156928  models.common.C3                        [128, 128, 3]                 \n",
      "  7                -1  1    295424  models.common.Conv                      [128, 256, 3, 2]              \n",
      "  8                -1  1    296448  models.common.C3                        [256, 256, 1]                 \n",
      "  9                -1  1    164608  models.common.SPPF                      [256, 256, 5]                 \n",
      " 10                -1  1     33024  models.common.Conv                      [256, 128, 1, 1]              \n",
      " 11                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          \n",
      " 12           [-1, 6]  1         0  models.common.Concat                    [1]                           \n",
      " 13                -1  1     90880  models.common.C3                        [256, 128, 1, False]          \n",
      " 14                -1  1      8320  models.common.Conv                      [128, 64, 1, 1]               \n",
      " 15                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          \n",
      " 16           [-1, 4]  1         0  models.common.Concat                    [1]                           \n",
      " 17                -1  1     22912  models.common.C3                        [128, 64, 1, False]           \n",
      " 18                -1  1     36992  models.common.Conv                      [64, 64, 3, 2]                \n",
      " 19          [-1, 14]  1         0  models.common.Concat                    [1]                           \n",
      " 20                -1  1     74496  models.common.C3                        [128, 128, 1, False]          \n",
      " 21                -1  1    147712  models.common.Conv                      [128, 128, 3, 2]              \n",
      " 22          [-1, 10]  1         0  models.common.Concat                    [1]                           \n",
      " 23                -1  1    296448  models.common.C3                        [256, 256, 1, False]          \n",
      " 24      [17, 20, 23]  1      8118  models.yolo.Detect                      [1, [[40.7, 54.6, 66.5, 52.9, 66.0, 82.2], [89.7, 64.3, 108.5, 76.1, 125.8, 95.3], [138.8, 132.0, 168.0, 110.6, 258.5, 183.1]], [64, 128, 256]]\n",
      "YOLOv5n_img640_custom summary: 214 layers, 1765270 parameters, 1765270 gradients, 4.2 GFLOPs\n",
      "\n",
      "Transferred 342/349 items from /home/konnilol/.cache/huggingface/hub/models--fcakyon--yolov5n-v7.0/snapshots/e63eb5a3061a09a639094279fd5082bc51d8a019/yolov5n.pt\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "\u001b[34m\u001b[1mAMP: \u001b[0mchecks passed ✅\n",
      "\u001b[34m\u001b[1moptimizer:\u001b[0m SGD(lr=0.003) with parameter groups 57 weight(decay=0.0), 60 weight(decay=0.0005), 60 bias\n",
      "\u001b[34m\u001b[1mtrain: \u001b[0mScanning /home/konnilol/Downloads/work_hf_yolov5n_car/dataset_yolo/labels/train.cache... 284 images, 0 backgrounds, 0 corrupt: 100%|██████████| 284/284 [00:00<?, ?it/s]\n",
      "\u001b[34m\u001b[1mval: \u001b[0mScanning /home/konnilol/Downloads/work_hf_yolov5n_car/dataset_yolo/labels/val.cache... 71 images, 0 backgrounds, 0 corrupt: 100%|██████████| 71/71 [00:00<?, ?it/s]\n",
      "\n",
      "\u001b[34m\u001b[1mAutoAnchor: \u001b[0m7.86 anchors/target, 1.000 Best Possible Recall (BPR). Current anchors are a good fit to dataset ✅\n",
      "Plotting labels to /home/konnilol/Downloads/work_hf_yolov5n_car/runs/train/pilot_img640/labels.jpg... \n",
      "/home/konnilol/Downloads/yolov5/train.py:357: FutureWarning: `torch.cuda.amp.GradScaler(args...)` is deprecated. Please use `torch.amp.GradScaler('cuda', args...)` instead.\n",
      "  scaler = torch.cuda.amp.GradScaler(enabled=amp)\n",
      "Image sizes 640 train, 640 val\n",
      "Using 0 dataloader workers\n",
      "Logging results to \u001b[1m/home/konnilol/Downloads/work_hf_yolov5n_car/runs/train/pilot_img640\u001b[0m\n",
      "Starting training for 5 epochs...\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.82G      0.131    0.04182          0         39        640:   6%|▌         | 1/18 [00:02<00:35,  2.09s/it]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.89G     0.1316    0.04104          0         39        640:  11%|█         | 2/18 [00:02<00:16,  1.01s/it]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.89G     0.1318    0.04174          0         50        640:  17%|█▋        | 3/18 [00:02<00:09,  1.52it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.89G     0.1319    0.04138          0         40        640:  22%|██▏       | 4/18 [00:02<00:06,  2.05it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.89G     0.1318    0.04145          0         50        640:  28%|██▊       | 5/18 [00:03<00:05,  2.58it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.89G     0.1318    0.04121          0         52        640:  33%|███▎      | 6/18 [00:03<00:03,  3.05it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.89G     0.1318    0.04054          0         39        640:  39%|███▉      | 7/18 [00:03<00:03,  3.46it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.89G     0.1316    0.04002          0         43        640:  44%|████▍     | 8/18 [00:03<00:02,  3.79it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.89G     0.1314    0.03951          0         43        640:  50%|█████     | 9/18 [00:03<00:02,  4.05it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.89G     0.1309    0.03931          0         44        640:  56%|█████▌    | 10/18 [00:04<00:01,  4.23it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.89G     0.1303    0.03907          0         40        640:  61%|██████    | 11/18 [00:04<00:01,  4.36it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.89G       0.13    0.03851          0         36        640:  67%|██████▋   | 12/18 [00:04<00:01,  4.37it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.89G     0.1297    0.03827          0         47        640:  72%|███████▏  | 13/18 [00:04<00:01,  4.38it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.89G     0.1295    0.03788          0         41        640:  78%|███████▊  | 14/18 [00:04<00:00,  4.48it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.89G     0.1289    0.03762          0         39        640:  83%|████████▎ | 15/18 [00:05<00:00,  4.57it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.89G     0.1282    0.03728          0         32        640:  89%|████████▉ | 16/18 [00:05<00:00,  4.64it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.89G     0.1276    0.03718          0         45        640:  94%|█████████▍| 17/18 [00:05<00:00,  4.68it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        0/4      1.89G     0.1271    0.03707          0         32        640: 100%|██████████| 18/18 [00:06<00:00,  2.83it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  3.93it/s]\n",
      "                   all         71        117    0.00324       0.59    0.00299   0.000665\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.89G     0.1161    0.03615          0         47        640:   6%|▌         | 1/18 [00:00<00:03,  4.39it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.89G     0.1151    0.03658          0         43        640:  11%|█         | 2/18 [00:00<00:03,  4.67it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.89G     0.1147    0.03519          0         34        640:  17%|█▋        | 3/18 [00:00<00:03,  4.67it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.89G     0.1144    0.03393          0         34        640:  22%|██▏       | 4/18 [00:00<00:02,  4.74it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.89G     0.1142    0.03354          0         35        640:  28%|██▊       | 5/18 [00:01<00:02,  4.73it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.89G     0.1132     0.0333          0         39        640:  33%|███▎      | 6/18 [00:01<00:02,  4.80it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.89G     0.1127    0.03326          0         39        640:  39%|███▉      | 7/18 [00:01<00:02,  4.71it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.89G     0.1118    0.03409          0         47        640:  44%|████▍     | 8/18 [00:01<00:02,  4.78it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.89G     0.1111    0.03393          0         32        640:  50%|█████     | 9/18 [00:01<00:01,  4.75it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.89G     0.1106    0.03358          0         32        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.81it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.89G     0.1102    0.03408          0         52        640:  61%|██████    | 11/18 [00:02<00:01,  4.74it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.89G     0.1092    0.03436          0         40        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.89G     0.1086    0.03534          0         58        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.78it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.89G     0.1078    0.03602          0         54        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.89G      0.107    0.03668          0         48        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.89G     0.1063     0.0375          0         58        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.89G     0.1055    0.03731          0         32        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        1/4      1.89G     0.1045     0.0376          0         31        640: 100%|██████████| 18/18 [00:03<00:00,  4.85it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.02it/s]\n",
      "                   all         71        117    0.00498      0.906     0.0868     0.0223\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.89G    0.09049    0.04317          0         45        640:   6%|▌         | 1/18 [00:00<00:03,  4.50it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.89G    0.09009    0.04305          0         46        640:  11%|█         | 2/18 [00:00<00:03,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.89G       0.09    0.04276          0         45        640:  17%|█▋        | 3/18 [00:00<00:03,  4.77it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.89G    0.08936    0.04416          0         54        640:  22%|██▏       | 4/18 [00:00<00:02,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.89G    0.08879    0.04272          0         37        640:  28%|██▊       | 5/18 [00:01<00:02,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.89G     0.0885    0.04124          0         33        640:  33%|███▎      | 6/18 [00:01<00:02,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.89G    0.08844    0.04133          0         47        640:  39%|███▉      | 7/18 [00:01<00:02,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.89G    0.08819    0.04036          0         33        640:  44%|████▍     | 8/18 [00:01<00:02,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.89G    0.08765    0.04023          0         41        640:  50%|█████     | 9/18 [00:01<00:01,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.89G    0.08719    0.03945          0         34        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.89G     0.0867    0.03999          0         50        640:  61%|██████    | 11/18 [00:02<00:01,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.89G    0.08623    0.03957          0         35        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.89G    0.08603    0.03928          0         38        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.79it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.89G    0.08552    0.03929          0         39        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.89G    0.08495    0.03957          0         43        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.89G    0.08451    0.03945          0         33        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.89G    0.08426    0.03994          0         58        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        2/4      1.89G    0.08404    0.03982          0         28        640: 100%|██████████| 18/18 [00:03<00:00,  4.89it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.03it/s]\n",
      "                   all         71        117       0.36      0.846       0.49      0.151\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.89G    0.07943    0.05121          0         64        640:   6%|▌         | 1/18 [00:00<00:03,  4.66it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.89G    0.07922    0.04844          0         53        640:  11%|█         | 2/18 [00:00<00:03,  4.71it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.89G    0.07764    0.04434          0         36        640:  17%|█▋        | 3/18 [00:00<00:03,  4.74it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.89G    0.07702    0.04342          0         40        640:  22%|██▏       | 4/18 [00:00<00:02,  4.81it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.89G    0.07681    0.04438          0         53        640:  28%|██▊       | 5/18 [00:01<00:02,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.89G    0.07619    0.04384          0         40        640:  33%|███▎      | 6/18 [00:01<00:02,  4.80it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.89G    0.07521    0.04398          0         46        640:  39%|███▉      | 7/18 [00:01<00:02,  4.81it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.89G    0.07481    0.04429          0         48        640:  44%|████▍     | 8/18 [00:01<00:02,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.89G     0.0745    0.04466          0         55        640:  50%|█████     | 9/18 [00:01<00:01,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.89G    0.07393    0.04446          0         43        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.89G    0.07334    0.04433          0         39        640:  61%|██████    | 11/18 [00:02<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.89G    0.07288    0.04452          0         43        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.89G    0.07246    0.04443          0         44        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.89G    0.07236    0.04443          0         48        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.89G    0.07224    0.04458          0         47        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.74it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.89G    0.07198    0.04423          0         42        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.78it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.89G    0.07145    0.04384          0         35        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        3/4      1.89G    0.07137    0.04324          0         24        640: 100%|██████████| 18/18 [00:03<00:00,  4.86it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  4.95it/s]\n",
      "                   all         71        117      0.438      0.829      0.567      0.203\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.89G    0.06637    0.04098          0         44        640:   6%|▌         | 1/18 [00:00<00:03,  4.71it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.89G     0.0658    0.04368          0         44        640:  11%|█         | 2/18 [00:00<00:03,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.89G    0.06492    0.04227          0         36        640:  17%|█▋        | 3/18 [00:00<00:03,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.89G     0.0643    0.04094          0         36        640:  22%|██▏       | 4/18 [00:00<00:02,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.89G    0.06435    0.04138          0         48        640:  28%|██▊       | 5/18 [00:01<00:02,  4.98it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.89G    0.06448    0.04099          0         45        640:  33%|███▎      | 6/18 [00:01<00:02,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.89G    0.06441    0.04285          0         59        640:  39%|███▉      | 7/18 [00:01<00:02,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.89G    0.06391    0.04236          0         38        640:  44%|████▍     | 8/18 [00:01<00:02,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.89G    0.06387    0.04181          0         37        640:  50%|█████     | 9/18 [00:01<00:01,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.89G    0.06339    0.04161          0         39        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.89G    0.06326    0.04174          0         50        640:  61%|██████    | 11/18 [00:02<00:01,  4.97it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.89G    0.06279    0.04082          0         29        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.89G    0.06257    0.04067          0         36        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.89G    0.06274    0.04068          0         46        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.96it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.89G    0.06258    0.04083          0         44        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.96it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.89G    0.06232    0.04074          0         38        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.89G    0.06222    0.04083          0         42        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "        4/4      1.89G    0.06216    0.04106          0         38        640: 100%|██████████| 18/18 [00:03<00:00,  4.98it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.04it/s]\n",
      "                   all         71        117      0.699      0.846      0.807      0.325\n",
      "\n",
      "5 epochs completed in 0.007 hours.\n",
      "Optimizer stripped from /home/konnilol/Downloads/work_hf_yolov5n_car/runs/train/pilot_img640/weights/last.pt, 3.8MB\n",
      "Optimizer stripped from /home/konnilol/Downloads/work_hf_yolov5n_car/runs/train/pilot_img640/weights/best.pt, 3.8MB\n",
      "\n",
      "Validating /home/konnilol/Downloads/work_hf_yolov5n_car/runs/train/pilot_img640/weights/best.pt...\n",
      "Fusing layers... \n",
      "YOLOv5n_img640_custom summary: 157 layers, 1760518 parameters, 0 gradients, 4.1 GFLOPs\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  3.58it/s]\n",
      "                   all         71        117      0.696      0.846      0.807      0.322\n",
      "Results saved to \u001b[1m/home/konnilol/Downloads/work_hf_yolov5n_car/runs/train/pilot_img640\u001b[0m\n"
     ]
    },
    {
     "data": {
      "application/vnd.positron.dataexplorer+json": {
       "comm_id": "b5ee4d88-2cc8-4fb2-9eac-138a6eef065f",
       "shape": {
        "columns": 6,
        "rows": 2
       },
       "source": "pandas",
       "title": "pandas",
       "version": 1
      },
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>imgsz</th>\n",
       "      <th>precision</th>\n",
       "      <th>recall</th>\n",
       "      <th>mAP50</th>\n",
       "      <th>mAP50_95</th>\n",
       "      <th>results_csv</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>640</td>\n",
       "      <td>0.69859</td>\n",
       "      <td>0.84615</td>\n",
       "      <td>0.80746</td>\n",
       "      <td>0.32483</td>\n",
       "      <td>/home/konnilol/Downloads/work_hf_yolov5n_car/r...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>512</td>\n",
       "      <td>0.71633</td>\n",
       "      <td>0.73504</td>\n",
       "      <td>0.75244</td>\n",
       "      <td>0.25391</td>\n",
       "      <td>/home/konnilol/Downloads/work_hf_yolov5n_car/r...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   imgsz  precision   recall    mAP50  mAP50_95  \\\n",
       "0    640    0.69859  0.84615  0.80746   0.32483   \n",
       "1    512    0.71633  0.73504  0.75244   0.25391   \n",
       "\n",
       "                                         results_csv  \n",
       "0  /home/konnilol/Downloads/work_hf_yolov5n_car/r...  \n",
       "1  /home/konnilol/Downloads/work_hf_yolov5n_car/r...  "
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def build_model_cfg_for_imgsz(imgsz: int):\n",
    "    base_model_yaml = Path(\"yolov5/models/yolov5n.yaml\")\n",
    "    with open(base_model_yaml, \"r\", encoding=\"utf-8\") as f:\n",
    "        model_cfg = yaml.safe_load(f)\n",
    "    model_cfg[\"nc\"] = 1\n",
    "    model_cfg[\"anchors\"] = anchor_candidates[imgsz]\n",
    "    cfg_path = WORKDIR / f\"yolov5n_img{imgsz}_custom.yaml\"\n",
    "    with open(cfg_path, \"w\", encoding=\"utf-8\") as f:\n",
    "        yaml.safe_dump(model_cfg, f, sort_keys=False, allow_unicode=True)\n",
    "    return cfg_path\n",
    "\n",
    "def read_best_row(results_csv: Path):\n",
    "    df_res = pd.read_csv(results_csv)\n",
    "    df_res.columns = [c.strip() for c in df_res.columns]\n",
    "    map5095_col = [c for c in df_res.columns if \"metrics/mAP_0.5:0.95\" in c][0]\n",
    "    best_row = df_res.iloc[df_res[map5095_col].idxmax()]\n",
    "    return df_res, best_row\n",
    "\n",
    "pilot_rows = []\n",
    "\n",
    "for imgsz in IMG_SIZE_CANDIDATES:\n",
    "    cfg_path = build_model_cfg_for_imgsz(imgsz)\n",
    "    run_name = f\"pilot_img{imgsz}\"\n",
    "    run_dir = WORKDIR / \"runs\" / \"train\" / run_name\n",
    "    if run_dir.exists():\n",
    "        shutil.rmtree(run_dir)\n",
    "\n",
    "    cmd = [\n",
    "        sys.executable, \"yolov5/train.py\",\n",
    "        \"--img\", str(imgsz),\n",
    "        \"--batch\", str(BATCH_SIZE),\n",
    "        \"--epochs\", str(PILOT_EPOCHS),\n",
    "        \"--data\", str(data_yaml_path),\n",
    "        \"--cfg\", str(cfg_path),\n",
    "        \"--weights\", str(hf_weights_path),\n",
    "        \"--hyp\", str(hyp_path),\n",
    "        \"--project\", str(WORKDIR / \"runs\" / \"train\"),\n",
    "        \"--name\", run_name,\n",
    "        \"--exist-ok\",\n",
    "        \"--workers\", \"0\",\n",
    "        \"--device\", DEVICE,\n",
    "    ]\n",
    "    print(\"Запуск:\", \" \".join(cmd))\n",
    "    subprocess.run(cmd, check=True)\n",
    "\n",
    "    results_csv = run_dir / \"results.csv\"\n",
    "    df_res, best_row = read_best_row(results_csv)\n",
    "\n",
    "    p_col = [c for c in df_res.columns if \"metrics/precision\" in c][0]\n",
    "    r_col = [c for c in df_res.columns if \"metrics/recall\" in c][0]\n",
    "    map50_col = [c for c in df_res.columns if \"metrics/mAP_0.5\" in c and \"0.5:0.95\" not in c][0]\n",
    "    map5095_col = [c for c in df_res.columns if \"metrics/mAP_0.5:0.95\" in c][0]\n",
    "\n",
    "    pilot_rows.append({\n",
    "        \"imgsz\": imgsz,\n",
    "        \"precision\": float(best_row[p_col]),\n",
    "        \"recall\": float(best_row[r_col]),\n",
    "        \"mAP50\": float(best_row[map50_col]),\n",
    "        \"mAP50_95\": float(best_row[map5095_col]),\n",
    "        \"results_csv\": str(results_csv),\n",
    "    })\n",
    "\n",
    "pilot_df = pd.DataFrame(pilot_rows).sort_values(\"mAP50_95\", ascending=False).reset_index(drop=True)\n",
    "pilot_df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c13943fc",
   "metadata": {},
   "source": [
    "## 12. Выбор лучшего `imgsz` и финальное обучение"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d2ca8a96",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Финальный запуск: /home/konnilol/.pyenv/versions/3.12.12/bin/python yolov5/train.py --img 640 --batch 16 --epochs 40 --data /home/konnilol/Downloads/work_hf_yolov5n_car/car_data.yaml --cfg /home/konnilol/Downloads/work_hf_yolov5n_car/yolov5n_img640_custom.yaml --weights /home/konnilol/.cache/huggingface/hub/models--fcakyon--yolov5n-v7.0/snapshots/e63eb5a3061a09a639094279fd5082bc51d8a019/yolov5n.pt --hyp /home/konnilol/Downloads/work_hf_yolov5n_car/hyp_car_tuned.yaml --project /home/konnilol/Downloads/work_hf_yolov5n_car/runs/train --name hf_yolov5n_car_img640 --exist-ok --workers 0 --device 0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[34m\u001b[1mtrain: \u001b[0mweights=/home/konnilol/.cache/huggingface/hub/models--fcakyon--yolov5n-v7.0/snapshots/e63eb5a3061a09a639094279fd5082bc51d8a019/yolov5n.pt, cfg=/home/konnilol/Downloads/work_hf_yolov5n_car/yolov5n_img640_custom.yaml, data=/home/konnilol/Downloads/work_hf_yolov5n_car/car_data.yaml, hyp=/home/konnilol/Downloads/work_hf_yolov5n_car/hyp_car_tuned.yaml, epochs=40, batch_size=16, imgsz=640, rect=False, resume=False, nosave=False, noval=False, noautoanchor=False, noplots=False, evolve=None, evolve_population=yolov5/data/hyps, resume_evolve=None, bucket=, cache=None, image_weights=False, device=0, multi_scale=False, single_cls=False, optimizer=SGD, sync_bn=False, workers=0, project=/home/konnilol/Downloads/work_hf_yolov5n_car/runs/train, name=hf_yolov5n_car_img640, exist_ok=True, quad=False, cos_lr=False, label_smoothing=0.0, patience=100, freeze=[0], save_period=-1, seed=0, local_rank=-1, entity=None, upload_dataset=False, bbox_interval=-1, artifact_alias=latest, ndjson_console=False, ndjson_file=False\n",
      "\u001b[34m\u001b[1mgithub: \u001b[0mup to date with https://github.com/ultralytics/yolov5 ✅\n",
      "YOLOv5 🚀 v7.0-463-g88af13e3 Python-3.12.12 torch-2.10.0+cu128 CUDA:0 (NVIDIA GeForce RTX 3080, 9873MiB)\n",
      "\n",
      "\u001b[34m\u001b[1mhyperparameters: \u001b[0mlr0=0.003, lrf=0.12, momentum=0.937, weight_decay=0.0005, warmup_epochs=3.0, warmup_momentum=0.8, warmup_bias_lr=0.1, box=0.05, cls=0.5, cls_pw=1.0, obj=1.0, obj_pw=1.0, iou_t=0.2, anchor_t=4.0, fl_gamma=0.0, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, degrees=0.0, translate=0.1, scale=0.2, shear=0.0, perspective=0.0, flipud=0.0, fliplr=0.5, mosaic=1.0, mixup=0.0, copy_paste=0.0\n",
      "\u001b[34m\u001b[1mComet: \u001b[0mrun 'pip install comet_ml' to automatically track and visualize YOLOv5 🚀 runs in Comet\n",
      "\u001b[34m\u001b[1mTensorBoard: \u001b[0mStart with 'tensorboard --logdir /home/konnilol/Downloads/work_hf_yolov5n_car/runs/train', view at http://localhost:6006/\n",
      "\n",
      "                 from  n    params  module                                  arguments                     \n",
      "  0                -1  1      1760  models.common.Conv                      [3, 16, 6, 2, 2]              \n",
      "  1                -1  1      4672  models.common.Conv                      [16, 32, 3, 2]                \n",
      "  2                -1  1      4800  models.common.C3                        [32, 32, 1]                   \n",
      "  3                -1  1     18560  models.common.Conv                      [32, 64, 3, 2]                \n",
      "  4                -1  2     29184  models.common.C3                        [64, 64, 2]                   \n",
      "  5                -1  1     73984  models.common.Conv                      [64, 128, 3, 2]               \n",
      "  6                -1  3    156928  models.common.C3                        [128, 128, 3]                 \n",
      "  7                -1  1    295424  models.common.Conv                      [128, 256, 3, 2]              \n",
      "  8                -1  1    296448  models.common.C3                        [256, 256, 1]                 \n",
      "  9                -1  1    164608  models.common.SPPF                      [256, 256, 5]                 \n",
      " 10                -1  1     33024  models.common.Conv                      [256, 128, 1, 1]              \n",
      " 11                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          \n",
      " 12           [-1, 6]  1         0  models.common.Concat                    [1]                           \n",
      " 13                -1  1     90880  models.common.C3                        [256, 128, 1, False]          \n",
      " 14                -1  1      8320  models.common.Conv                      [128, 64, 1, 1]               \n",
      " 15                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          \n",
      " 16           [-1, 4]  1         0  models.common.Concat                    [1]                           \n",
      " 17                -1  1     22912  models.common.C3                        [128, 64, 1, False]           \n",
      " 18                -1  1     36992  models.common.Conv                      [64, 64, 3, 2]                \n",
      " 19          [-1, 14]  1         0  models.common.Concat                    [1]                           \n",
      " 20                -1  1     74496  models.common.C3                        [128, 128, 1, False]          \n",
      " 21                -1  1    147712  models.common.Conv                      [128, 128, 3, 2]              \n",
      " 22          [-1, 10]  1         0  models.common.Concat                    [1]                           \n",
      " 23                -1  1    296448  models.common.C3                        [256, 256, 1, False]          \n",
      " 24      [17, 20, 23]  1      8118  models.yolo.Detect                      [1, [[40.7, 54.6, 66.5, 52.9, 66.0, 82.2], [89.7, 64.3, 108.5, 76.1, 125.8, 95.3], [138.8, 132.0, 168.0, 110.6, 258.5, 183.1]], [64, 128, 256]]\n",
      "YOLOv5n_img640_custom summary: 214 layers, 1765270 parameters, 1765270 gradients, 4.2 GFLOPs\n",
      "\n",
      "Transferred 342/349 items from /home/konnilol/.cache/huggingface/hub/models--fcakyon--yolov5n-v7.0/snapshots/e63eb5a3061a09a639094279fd5082bc51d8a019/yolov5n.pt\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "\u001b[34m\u001b[1mAMP: \u001b[0mchecks passed ✅\n",
      "\u001b[34m\u001b[1moptimizer:\u001b[0m SGD(lr=0.003) with parameter groups 57 weight(decay=0.0), 60 weight(decay=0.0005), 60 bias\n",
      "\u001b[34m\u001b[1mtrain: \u001b[0mScanning /home/konnilol/Downloads/work_hf_yolov5n_car/dataset_yolo/labels/train.cache... 284 images, 0 backgrounds, 0 corrupt: 100%|██████████| 284/284 [00:00<?, ?it/s]\n",
      "\u001b[34m\u001b[1mval: \u001b[0mScanning /home/konnilol/Downloads/work_hf_yolov5n_car/dataset_yolo/labels/val.cache... 71 images, 0 backgrounds, 0 corrupt: 100%|██████████| 71/71 [00:00<?, ?it/s]\n",
      "\n",
      "\u001b[34m\u001b[1mAutoAnchor: \u001b[0m7.86 anchors/target, 1.000 Best Possible Recall (BPR). Current anchors are a good fit to dataset ✅\n",
      "Plotting labels to /home/konnilol/Downloads/work_hf_yolov5n_car/runs/train/hf_yolov5n_car_img640/labels.jpg... \n",
      "/home/konnilol/Downloads/yolov5/train.py:357: FutureWarning: `torch.cuda.amp.GradScaler(args...)` is deprecated. Please use `torch.amp.GradScaler('cuda', args...)` instead.\n",
      "  scaler = torch.cuda.amp.GradScaler(enabled=amp)\n",
      "Image sizes 640 train, 640 val\n",
      "Using 0 dataloader workers\n",
      "Logging results to \u001b[1m/home/konnilol/Downloads/work_hf_yolov5n_car/runs/train/hf_yolov5n_car_img640\u001b[0m\n",
      "Starting training for 40 epochs...\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       0/39      1.82G      0.131    0.04182          0         39        640:   6%|▌         | 1/18 [00:02<00:35,  2.10s/it]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       0/39      1.89G     0.1316    0.04104          0         39        640:  11%|█         | 2/18 [00:02<00:16,  1.03s/it]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       0/39      1.89G     0.1318    0.04174          0         50        640:  17%|█▋        | 3/18 [00:02<00:10,  1.47it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       0/39      1.89G     0.1319    0.04138          0         40        640:  22%|██▏       | 4/18 [00:02<00:07,  1.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       0/39      1.89G     0.1318    0.04145          0         50        640:  28%|██▊       | 5/18 [00:03<00:05,  2.44it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       0/39      1.89G     0.1318    0.04121          0         52        640:  33%|███▎      | 6/18 [00:03<00:04,  2.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       0/39      1.89G     0.1318    0.04054          0         39        640:  39%|███▉      | 7/18 [00:03<00:03,  3.24it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       0/39      1.89G     0.1316    0.04002          0         43        640:  44%|████▍     | 8/18 [00:03<00:02,  3.54it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       0/39      1.89G     0.1314    0.03951          0         43        640:  50%|█████     | 9/18 [00:04<00:02,  3.79it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       0/39      1.89G     0.1309    0.03931          0         44        640:  56%|█████▌    | 10/18 [00:04<00:02,  3.99it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       0/39      1.89G     0.1303    0.03907          0         40        640:  61%|██████    | 11/18 [00:04<00:01,  4.14it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       0/39      1.89G       0.13    0.03851          0         36        640:  67%|██████▋   | 12/18 [00:04<00:01,  4.22it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       0/39      1.89G     0.1297    0.03827          0         47        640:  72%|███████▏  | 13/18 [00:04<00:01,  4.30it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       0/39      1.89G     0.1295    0.03788          0         41        640:  78%|███████▊  | 14/18 [00:05<00:00,  4.36it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       0/39      1.89G     0.1289    0.03762          0         39        640:  83%|████████▎ | 15/18 [00:05<00:00,  4.40it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       0/39      1.89G     0.1282    0.03728          0         32        640:  89%|████████▉ | 16/18 [00:05<00:00,  4.38it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       0/39      1.89G     0.1276    0.03718          0         45        640:  94%|█████████▍| 17/18 [00:05<00:00,  4.40it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       0/39      1.89G     0.1271    0.03707          0         32        640: 100%|██████████| 18/18 [00:06<00:00,  2.70it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  4.10it/s]\n",
      "                   all         71        117    0.00324       0.59    0.00299   0.000665\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       1/39      1.89G     0.1161    0.03615          0         47        640:   6%|▌         | 1/18 [00:00<00:03,  4.68it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       1/39      1.89G      0.115    0.03661          0         43        640:  11%|█         | 2/18 [00:00<00:03,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       1/39      1.89G     0.1146    0.03522          0         34        640:  17%|█▋        | 3/18 [00:00<00:03,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       1/39      1.89G     0.1141    0.03399          0         34        640:  22%|██▏       | 4/18 [00:00<00:02,  4.74it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       1/39      1.89G     0.1138    0.03363          0         35        640:  28%|██▊       | 5/18 [00:01<00:02,  4.71it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       1/39      1.89G     0.1126     0.0334          0         39        640:  33%|███▎      | 6/18 [00:01<00:02,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       1/39      1.89G     0.1122    0.03339          0         39        640:  39%|███▉      | 7/18 [00:01<00:02,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       1/39      1.89G     0.1112    0.03422          0         47        640:  44%|████▍     | 8/18 [00:01<00:02,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       1/39      1.89G     0.1105    0.03405          0         32        640:  50%|█████     | 9/18 [00:01<00:01,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       1/39      1.89G     0.1099    0.03371          0         32        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       1/39      1.89G     0.1094    0.03423          0         52        640:  61%|██████    | 11/18 [00:02<00:01,  4.81it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       1/39      1.89G     0.1084    0.03452          0         40        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       1/39      1.89G     0.1076    0.03555          0         58        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       1/39      1.89G     0.1068    0.03625          0         54        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       1/39      1.89G      0.106    0.03693          0         48        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       1/39      1.89G     0.1052    0.03776          0         58        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       1/39      1.89G     0.1044    0.03756          0         32        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       1/39      1.89G     0.1034    0.03785          0         31        640: 100%|██████████| 18/18 [00:03<00:00,  4.90it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.06it/s]\n",
      "                   all         71        117    0.00793      0.906     0.0951      0.026\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       2/39      1.89G    0.08889    0.04338          0         45        640:   6%|▌         | 1/18 [00:00<00:03,  4.62it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       2/39      1.89G    0.08817    0.04333          0         46        640:  11%|█         | 2/18 [00:00<00:03,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       2/39      1.89G    0.08797    0.04301          0         45        640:  17%|█▋        | 3/18 [00:00<00:03,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       2/39      1.89G    0.08728    0.04441          0         54        640:  22%|██▏       | 4/18 [00:00<00:02,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       2/39      1.89G    0.08681    0.04283          0         37        640:  28%|██▊       | 5/18 [00:01<00:02,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       2/39      1.89G    0.08631    0.04134          0         33        640:  33%|███▎      | 6/18 [00:01<00:02,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       2/39      1.89G    0.08604    0.04148          0         47        640:  39%|███▉      | 7/18 [00:01<00:02,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       2/39      1.89G    0.08592    0.04044          0         33        640:  44%|████▍     | 8/18 [00:01<00:02,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       2/39      1.89G    0.08544    0.04027          0         41        640:  50%|█████     | 9/18 [00:01<00:01,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       2/39      1.89G    0.08487    0.03948          0         34        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       2/39      1.89G    0.08413    0.04011          0         50        640:  61%|██████    | 11/18 [00:02<00:01,  4.78it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       2/39      1.89G    0.08347    0.03971          0         35        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       2/39      1.89G    0.08326     0.0394          0         38        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.79it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       2/39      1.89G     0.0829    0.03935          0         39        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       2/39      1.89G    0.08238    0.03961          0         43        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       2/39      1.89G    0.08187    0.03949          0         33        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       2/39      1.89G    0.08152    0.04003          0         58        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       2/39      1.89G    0.08118    0.03994          0         28        640: 100%|██████████| 18/18 [00:03<00:00,  4.89it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.12it/s]\n",
      "                   all         71        117      0.347      0.803      0.467       0.15\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       3/39      1.89G    0.07684    0.05179          0         64        640:   6%|▌         | 1/18 [00:00<00:03,  4.79it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       3/39      1.89G    0.07646    0.04899          0         53        640:  11%|█         | 2/18 [00:00<00:03,  4.96it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       3/39      1.89G    0.07476    0.04468          0         36        640:  17%|█▋        | 3/18 [00:00<00:03,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       3/39      1.89G    0.07389    0.04373          0         40        640:  22%|██▏       | 4/18 [00:00<00:02,  4.96it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       3/39      1.89G    0.07364    0.04469          0         53        640:  28%|██▊       | 5/18 [00:01<00:02,  4.99it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       3/39      1.89G    0.07318    0.04403          0         40        640:  33%|███▎      | 6/18 [00:01<00:02,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       3/39      1.89G    0.07235    0.04396          0         46        640:  39%|███▉      | 7/18 [00:01<00:02,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       3/39      1.89G    0.07187    0.04424          0         48        640:  44%|████▍     | 8/18 [00:01<00:02,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       3/39      1.89G    0.07157    0.04456          0         55        640:  50%|█████     | 9/18 [00:01<00:01,  4.78it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       3/39      1.89G    0.07121    0.04417          0         43        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       3/39      1.89G    0.07071    0.04389          0         39        640:  61%|██████    | 11/18 [00:02<00:01,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       3/39      1.89G    0.07047     0.0439          0         43        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       3/39      1.89G    0.07006     0.0437          0         44        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       3/39      1.89G    0.06995    0.04364          0         48        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       3/39      1.89G    0.06986    0.04369          0         47        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       3/39      1.89G     0.0697    0.04326          0         42        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       3/39      1.89G    0.06929    0.04277          0         35        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       3/39      1.89G    0.06934     0.0421          0         24        640: 100%|██████████| 18/18 [00:03<00:00,  4.93it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.04it/s]\n",
      "                   all         71        117       0.56      0.795      0.636      0.239\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       4/39      1.89G     0.0637    0.03814          0         44        640:   6%|▌         | 1/18 [00:00<00:03,  4.77it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       4/39      1.89G    0.06249    0.04104          0         44        640:  11%|█         | 2/18 [00:00<00:03,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       4/39      1.89G    0.06196    0.03959          0         36        640:  17%|█▋        | 3/18 [00:00<00:03,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       4/39      1.89G    0.06251    0.03792          0         36        640:  22%|██▏       | 4/18 [00:00<00:02,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       4/39      1.89G     0.0631    0.03806          0         48        640:  28%|██▊       | 5/18 [00:01<00:02,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       4/39      1.89G    0.06367    0.03753          0         45        640:  33%|███▎      | 6/18 [00:01<00:02,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       4/39      1.89G     0.0634    0.03923          0         59        640:  39%|███▉      | 7/18 [00:01<00:02,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       4/39      1.89G    0.06258    0.03881          0         38        640:  44%|████▍     | 8/18 [00:01<00:02,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       4/39      1.89G     0.0623    0.03833          0         37        640:  50%|█████     | 9/18 [00:01<00:01,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       4/39      1.89G    0.06238    0.03786          0         39        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       4/39      1.89G    0.06249    0.03782          0         50        640:  61%|██████    | 11/18 [00:02<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       4/39      1.89G    0.06225    0.03687          0         29        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.79it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       4/39      1.89G    0.06192    0.03663          0         36        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.80it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       4/39      1.89G    0.06205    0.03655          0         46        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       4/39      1.89G    0.06188    0.03657          0         44        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       4/39      1.89G    0.06163    0.03638          0         38        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       4/39      1.89G    0.06159    0.03633          0         42        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.81it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       4/39      1.89G    0.06156    0.03642          0         38        640: 100%|██████████| 18/18 [00:03<00:00,  4.91it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.13it/s]\n",
      "                   all         71        117      0.393      0.761      0.439      0.156\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       5/39      1.89G    0.06083    0.03626          0         44        640:   6%|▌         | 1/18 [00:00<00:03,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       5/39      1.89G    0.06142    0.03517          0         45        640:  11%|█         | 2/18 [00:00<00:03,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       5/39      1.89G    0.06204    0.03381          0         39        640:  17%|█▋        | 3/18 [00:00<00:03,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       5/39      1.89G     0.0621    0.03512          0         56        640:  22%|██▏       | 4/18 [00:00<00:02,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       5/39      1.89G    0.06283     0.0346          0         44        640:  28%|██▊       | 5/18 [00:01<00:02,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       5/39      1.89G    0.06302    0.03355          0         36        640:  33%|███▎      | 6/18 [00:01<00:02,  4.65it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       5/39      1.89G    0.06284     0.0325          0         37        640:  39%|███▉      | 7/18 [00:01<00:02,  4.78it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       5/39      1.89G    0.06223    0.03208          0         35        640:  44%|████▍     | 8/18 [00:01<00:02,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       5/39      1.89G    0.06204    0.03134          0         29        640:  50%|█████     | 9/18 [00:01<00:01,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       5/39      1.89G    0.06187    0.03212          0         56        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       5/39      1.89G    0.06192    0.03271          0         57        640:  61%|██████    | 11/18 [00:02<00:01,  4.98it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       5/39      1.89G      0.062    0.03284          0         51        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.99it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       5/39      1.89G    0.06229    0.03251          0         40        640:  72%|███████▏  | 13/18 [00:02<00:00,  5.04it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       5/39      1.89G    0.06245    0.03235          0         42        640:  78%|███████▊  | 14/18 [00:02<00:00,  5.00it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       5/39      1.89G    0.06234    0.03201          0         41        640:  83%|████████▎ | 15/18 [00:03<00:00,  5.05it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       5/39      1.89G    0.06221    0.03177          0         39        640:  89%|████████▉ | 16/18 [00:03<00:00,  5.09it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       5/39      1.89G    0.06204     0.0317          0         45        640:  94%|█████████▍| 17/18 [00:03<00:00,  5.08it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       5/39      1.89G    0.06188    0.03172          0         33        640: 100%|██████████| 18/18 [00:03<00:00,  4.99it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.48it/s]\n",
      "                   all         71        117      0.323      0.701      0.357      0.108\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       6/39      1.89G    0.06059    0.03151          0         46        640:   6%|▌         | 1/18 [00:00<00:03,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       6/39      1.89G     0.0621    0.03065          0         44        640:  11%|█         | 2/18 [00:00<00:03,  5.03it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       6/39      1.89G    0.06092    0.02959          0         36        640:  17%|█▋        | 3/18 [00:00<00:02,  5.04it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       6/39      1.89G    0.06083    0.02901          0         41        640:  22%|██▏       | 4/18 [00:00<00:02,  5.00it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       6/39      1.89G    0.05996    0.02959          0         44        640:  28%|██▊       | 5/18 [00:00<00:02,  5.08it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       6/39      1.89G    0.05966    0.02922          0         36        640:  33%|███▎      | 6/18 [00:01<00:02,  5.08it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       6/39      1.89G    0.05968    0.02858          0         35        640:  39%|███▉      | 7/18 [00:01<00:02,  5.01it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       6/39      1.89G    0.05949    0.02832          0         37        640:  44%|████▍     | 8/18 [00:01<00:02,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       6/39      1.89G     0.0596    0.02833          0         48        640:  50%|█████     | 9/18 [00:01<00:01,  5.01it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       6/39      1.89G     0.0597    0.02795          0         38        640:  56%|█████▌    | 10/18 [00:01<00:01,  5.06it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       6/39      1.89G     0.0595    0.02778          0         39        640:  61%|██████    | 11/18 [00:02<00:01,  5.10it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       6/39      1.89G    0.05931    0.02789          0         48        640:  67%|██████▋   | 12/18 [00:02<00:01,  5.04it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       6/39      1.89G    0.05936    0.02776          0         37        640:  72%|███████▏  | 13/18 [00:02<00:00,  5.05it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       6/39      1.89G     0.0593    0.02775          0         43        640:  78%|███████▊  | 14/18 [00:02<00:00,  5.03it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       6/39      1.89G    0.05918    0.02756          0         37        640:  83%|████████▎ | 15/18 [00:02<00:00,  5.08it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       6/39      1.89G    0.05918     0.0274          0         40        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.79it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       6/39      1.89G    0.05885    0.02741          0         43        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.81it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       6/39      1.89G    0.05856    0.02743          0         30        640: 100%|██████████| 18/18 [00:03<00:00,  5.02it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.18it/s]\n",
      "                   all         71        117      0.405      0.684      0.426      0.159\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       7/39      1.89G    0.05776    0.03056          0         51        640:   6%|▌         | 1/18 [00:00<00:03,  4.67it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       7/39      1.89G    0.05417    0.02915          0         38        640:  11%|█         | 2/18 [00:00<00:03,  4.67it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       7/39      1.89G    0.05518    0.02728          0         39        640:  17%|█▋        | 3/18 [00:00<00:03,  4.73it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       7/39      1.89G    0.05581    0.02591          0         32        640:  22%|██▏       | 4/18 [00:00<00:02,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       7/39      1.89G    0.05623    0.02573          0         41        640:  28%|██▊       | 5/18 [00:01<00:02,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       7/39      1.89G    0.05568    0.02605          0         41        640:  33%|███▎      | 6/18 [00:01<00:02,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       7/39      1.89G     0.0559    0.02542          0         33        640:  39%|███▉      | 7/18 [00:01<00:02,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       7/39      1.89G    0.05643    0.02575          0         46        640:  44%|████▍     | 8/18 [00:01<00:02,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       7/39      1.89G    0.05642    0.02563          0         39        640:  50%|█████     | 9/18 [00:01<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       7/39      1.89G    0.05594    0.02531          0         37        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       7/39      1.89G    0.05589    0.02548          0         44        640:  61%|██████    | 11/18 [00:02<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       7/39      1.89G    0.05586    0.02512          0         32        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       7/39      1.89G    0.05597    0.02496          0         41        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       7/39      1.89G    0.05606    0.02512          0         46        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       7/39      1.89G    0.05622    0.02508          0         41        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       7/39      1.89G    0.05649    0.02484          0         34        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       7/39      1.89G    0.05653    0.02478          0         37        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       7/39      1.89G    0.05623    0.02467          0         24        640: 100%|██████████| 18/18 [00:03<00:00,  4.91it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.30it/s]\n",
      "                   all         71        117      0.812      0.726      0.802      0.366\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       8/39      1.89G     0.0526    0.02366          0         35        640:   6%|▌         | 1/18 [00:00<00:03,  4.68it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       8/39      1.89G    0.05247    0.02404          0         36        640:  11%|█         | 2/18 [00:00<00:03,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       8/39      1.89G    0.05238    0.02368          0         35        640:  17%|█▋        | 3/18 [00:00<00:03,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       8/39      1.89G    0.05354    0.02472          0         48        640:  22%|██▏       | 4/18 [00:00<00:02,  4.78it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       8/39      1.89G    0.05357    0.02459          0         38        640:  28%|██▊       | 5/18 [00:01<00:02,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       8/39      1.89G    0.05368    0.02492          0         44        640:  33%|███▎      | 6/18 [00:01<00:02,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       8/39      1.89G    0.05435    0.02479          0         40        640:  39%|███▉      | 7/18 [00:01<00:02,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       8/39      1.89G    0.05447    0.02423          0         33        640:  44%|████▍     | 8/18 [00:01<00:02,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       8/39      1.89G    0.05389    0.02427          0         42        640:  50%|█████     | 9/18 [00:01<00:01,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       8/39      1.89G     0.0538    0.02457          0         46        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       8/39      1.89G    0.05361    0.02472          0         47        640:  61%|██████    | 11/18 [00:02<00:01,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       8/39      1.89G    0.05367    0.02472          0         41        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       8/39      1.89G    0.05393    0.02432          0         37        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       8/39      1.89G      0.054    0.02457          0         47        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       8/39      1.89G    0.05415    0.02435          0         34        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       8/39      1.89G    0.05423    0.02411          0         33        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       8/39      1.89G    0.05462    0.02407          0         47        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.77it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       8/39      1.89G    0.05456    0.02433          0         38        640: 100%|██████████| 18/18 [00:03<00:00,  4.90it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.18it/s]\n",
      "                   all         71        117      0.941      0.821      0.909      0.502\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       9/39      1.89G    0.05226    0.02772          0         46        640:   6%|▌         | 1/18 [00:00<00:03,  4.76it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       9/39      1.89G    0.05083    0.02769          0         46        640:  11%|█         | 2/18 [00:00<00:03,  4.67it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       9/39      1.89G    0.05205    0.02637          0         44        640:  17%|█▋        | 3/18 [00:00<00:03,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       9/39      1.89G    0.05229    0.02626          0         43        640:  22%|██▏       | 4/18 [00:00<00:02,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       9/39      1.89G    0.05185    0.02649          0         47        640:  28%|██▊       | 5/18 [00:01<00:02,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       9/39      1.89G    0.05171    0.02594          0         38        640:  33%|███▎      | 6/18 [00:01<00:02,  4.79it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       9/39      1.89G     0.0515    0.02538          0         36        640:  39%|███▉      | 7/18 [00:01<00:02,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       9/39      1.89G    0.05198    0.02482          0         39        640:  44%|████▍     | 8/18 [00:01<00:02,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       9/39      1.89G     0.0527    0.02464          0         45        640:  50%|█████     | 9/18 [00:01<00:01,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       9/39      1.89G    0.05234    0.02488          0         46        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       9/39      1.89G    0.05229    0.02479          0         40        640:  61%|██████    | 11/18 [00:02<00:01,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       9/39      1.89G    0.05244    0.02482          0         45        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       9/39      1.89G    0.05226    0.02427          0         27        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.96it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       9/39      1.89G    0.05208    0.02439          0         45        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       9/39      1.89G    0.05174    0.02414          0         34        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       9/39      1.89G    0.05174    0.02383          0         33        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       9/39      1.89G    0.05154    0.02388          0         42        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "       9/39      1.89G    0.05126    0.02405          0         34        640: 100%|██████████| 18/18 [00:03<00:00,  4.93it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.59it/s]\n",
      "                   all         71        117      0.763      0.752      0.738        0.2\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      10/39      1.89G    0.05258    0.02438          0         45        640:   6%|▌         | 1/18 [00:00<00:03,  4.81it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      10/39      1.89G    0.05149    0.02441          0         44        640:  11%|█         | 2/18 [00:00<00:03,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      10/39      1.89G    0.05228     0.0238          0         36        640:  17%|█▋        | 3/18 [00:00<00:03,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      10/39      1.89G    0.05231    0.02382          0         44        640:  22%|██▏       | 4/18 [00:00<00:02,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      10/39      1.89G    0.05141    0.02451          0         52        640:  28%|██▊       | 5/18 [00:01<00:02,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      10/39      1.89G    0.05176    0.02385          0         37        640:  33%|███▎      | 6/18 [00:01<00:02,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      10/39      1.89G    0.05174    0.02413          0         49        640:  39%|███▉      | 7/18 [00:01<00:02,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      10/39      1.89G     0.0518    0.02415          0         49        640:  44%|████▍     | 8/18 [00:01<00:02,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      10/39      1.89G    0.05162    0.02435          0         48        640:  50%|█████     | 9/18 [00:01<00:01,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      10/39      1.89G    0.05138    0.02469          0         54        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      10/39      1.89G    0.05209    0.02427          0         32        640:  61%|██████    | 11/18 [00:02<00:01,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      10/39      1.89G    0.05203    0.02413          0         42        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      10/39      1.89G    0.05148    0.02377          0         33        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      10/39      1.89G    0.05125    0.02336          0         32        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      10/39      1.89G    0.05118    0.02333          0         45        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      10/39      1.89G    0.05107    0.02308          0         35        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      10/39      1.89G    0.05132    0.02271          0         31        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      10/39      1.89G    0.05145    0.02261          0         31        640: 100%|██████████| 18/18 [00:03<00:00,  4.93it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.42it/s]\n",
      "                   all         71        117      0.795      0.786      0.778      0.236\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      11/39      1.89G    0.05164    0.01913          0         34        640:   6%|▌         | 1/18 [00:00<00:03,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      11/39      1.89G    0.05226    0.01939          0         34        640:  11%|█         | 2/18 [00:00<00:03,  4.75it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      11/39      1.89G    0.05046    0.01989          0         40        640:  17%|█▋        | 3/18 [00:00<00:03,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      11/39      1.89G    0.04971    0.02135          0         50        640:  22%|██▏       | 4/18 [00:00<00:02,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      11/39      1.89G    0.04874    0.02092          0         38        640:  28%|██▊       | 5/18 [00:01<00:02,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      11/39      1.89G    0.04818    0.02151          0         49        640:  33%|███▎      | 6/18 [00:01<00:02,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      11/39      1.89G    0.04842    0.02169          0         46        640:  39%|███▉      | 7/18 [00:01<00:02,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      11/39      1.89G    0.04867    0.02175          0         42        640:  44%|████▍     | 8/18 [00:01<00:02,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      11/39      1.89G    0.04857     0.0216          0         37        640:  50%|█████     | 9/18 [00:01<00:01,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      11/39      1.89G    0.04907    0.02136          0         35        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      11/39      1.89G    0.04931    0.02138          0         43        640:  61%|██████    | 11/18 [00:02<00:01,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      11/39      1.89G     0.0496     0.0218          0         49        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      11/39      1.89G    0.04986    0.02146          0         32        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      11/39      1.89G    0.04988    0.02135          0         40        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      11/39      1.89G    0.04958    0.02138          0         41        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      11/39      1.89G    0.04937    0.02141          0         40        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      11/39      1.89G    0.04919    0.02157          0         47        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      11/39      1.89G    0.04897    0.02139          0         26        640: 100%|██████████| 18/18 [00:03<00:00,  4.94it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.55it/s]\n",
      "                   all         71        117      0.877      0.794      0.827      0.266\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      12/39      1.89G    0.04799    0.02014          0         39        640:   6%|▌         | 1/18 [00:00<00:03,  4.79it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      12/39      1.89G    0.05081    0.02066          0         45        640:  11%|█         | 2/18 [00:00<00:03,  4.80it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      12/39      1.89G    0.04996    0.02182          0         49        640:  17%|█▋        | 3/18 [00:00<00:03,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      12/39      1.89G     0.0501     0.0214          0         43        640:  22%|██▏       | 4/18 [00:00<00:02,  4.79it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      12/39      1.89G    0.04872    0.02119          0         40        640:  28%|██▊       | 5/18 [00:01<00:02,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      12/39      1.89G    0.04787    0.02112          0         44        640:  33%|███▎      | 6/18 [00:01<00:02,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      12/39      1.89G    0.04768    0.02069          0         36        640:  39%|███▉      | 7/18 [00:01<00:02,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      12/39      1.89G    0.04763    0.02072          0         44        640:  44%|████▍     | 8/18 [00:01<00:02,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      12/39      1.89G    0.04822    0.02083          0         42        640:  50%|█████     | 9/18 [00:01<00:01,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      12/39      1.89G    0.04822    0.02116          0         50        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      12/39      1.89G    0.04834    0.02109          0         38        640:  61%|██████    | 11/18 [00:02<00:01,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      12/39      1.89G    0.04884    0.02098          0         37        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      12/39      1.89G    0.04864    0.02096          0         41        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      12/39      1.89G    0.04826    0.02085          0         35        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.76it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      12/39      1.89G    0.04777    0.02089          0         39        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.81it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      12/39      1.89G    0.04774    0.02086          0         42        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.79it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      12/39      1.89G      0.048    0.02078          0         37        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      12/39      1.89G    0.04818    0.02074          0         28        640: 100%|██████████| 18/18 [00:03<00:00,  4.90it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.58it/s]\n",
      "                   all         71        117      0.906      0.821      0.909       0.32\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      13/39      1.89G    0.05086     0.0251          0         49        640:   6%|▌         | 1/18 [00:00<00:03,  4.80it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      13/39      1.89G    0.05124    0.02546          0         55        640:  11%|█         | 2/18 [00:00<00:03,  4.76it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      13/39      1.89G    0.04976    0.02411          0         47        640:  17%|█▋        | 3/18 [00:00<00:03,  4.81it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      13/39      1.89G    0.04807    0.02312          0         40        640:  22%|██▏       | 4/18 [00:00<00:02,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      13/39      1.89G    0.04679    0.02228          0         37        640:  28%|██▊       | 5/18 [00:01<00:02,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      13/39      1.89G    0.04547    0.02222          0         41        640:  33%|███▎      | 6/18 [00:01<00:02,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      13/39      1.89G     0.0456    0.02183          0         35        640:  39%|███▉      | 7/18 [00:01<00:02,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      13/39      1.89G    0.04615     0.0213          0         31        640:  44%|████▍     | 8/18 [00:01<00:02,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      13/39      1.89G    0.04654    0.02165          0         51        640:  50%|█████     | 9/18 [00:01<00:01,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      13/39      1.89G    0.04697    0.02113          0         36        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      13/39      1.89G     0.0471    0.02098          0         43        640:  61%|██████    | 11/18 [00:02<00:01,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      13/39      1.89G    0.04648    0.02085          0         39        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      13/39      1.89G    0.04608    0.02079          0         41        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      13/39      1.89G    0.04585    0.02114          0         51        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      13/39      1.89G     0.0462    0.02094          0         35        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      13/39      1.89G    0.04648    0.02121          0         54        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      13/39      1.89G    0.04652    0.02128          0         46        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      13/39      1.89G    0.04678    0.02132          0         37        640: 100%|██████████| 18/18 [00:03<00:00,  4.93it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.63it/s]\n",
      "                   all         71        117      0.962      0.861      0.945      0.529\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      14/39      1.89G    0.04086    0.02058          0         42        640:   6%|▌         | 1/18 [00:00<00:03,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      14/39      1.89G    0.04052    0.02177          0         45        640:  11%|█         | 2/18 [00:00<00:03,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      14/39      1.89G    0.04236    0.02236          0         51        640:  17%|█▋        | 3/18 [00:00<00:03,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      14/39      1.89G    0.04121     0.0222          0         44        640:  22%|██▏       | 4/18 [00:00<00:02,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      14/39      1.89G    0.04264    0.02177          0         40        640:  28%|██▊       | 5/18 [00:01<00:02,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      14/39      1.89G    0.04323    0.02156          0         44        640:  33%|███▎      | 6/18 [00:01<00:02,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      14/39      1.89G    0.04421    0.02119          0         40        640:  39%|███▉      | 7/18 [00:01<00:02,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      14/39      1.89G    0.04473    0.02093          0         41        640:  44%|████▍     | 8/18 [00:01<00:02,  4.81it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      14/39      1.89G    0.04451    0.02097          0         44        640:  50%|█████     | 9/18 [00:01<00:01,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      14/39      1.89G     0.0444    0.02052          0         32        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      14/39      1.89G    0.04398    0.02063          0         43        640:  61%|██████    | 11/18 [00:02<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      14/39      1.89G    0.04369    0.02101          0         51        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      14/39      1.89G    0.04381    0.02108          0         48        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      14/39      1.89G    0.04388    0.02085          0         37        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      14/39      1.89G    0.04406    0.02064          0         34        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      14/39      1.89G    0.04424    0.02034          0         30        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      14/39      1.89G    0.04414     0.0207          0         53        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      14/39      1.89G      0.044    0.02052          0         25        640: 100%|██████████| 18/18 [00:03<00:00,  4.93it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.63it/s]\n",
      "                   all         71        117        0.9      0.838      0.917      0.455\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      15/39      1.89G    0.04189    0.01632          0         32        640:   6%|▌         | 1/18 [00:00<00:03,  4.98it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      15/39      1.89G    0.04405    0.01909          0         47        640:  11%|█         | 2/18 [00:00<00:03,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      15/39      1.89G    0.04415    0.01954          0         40        640:  17%|█▋        | 3/18 [00:00<00:03,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      15/39      1.89G    0.04386    0.02043          0         51        640:  22%|██▏       | 4/18 [00:00<00:02,  4.96it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      15/39      1.89G    0.04365    0.02128          0         47        640:  28%|██▊       | 5/18 [00:01<00:02,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      15/39      1.89G    0.04362    0.02139          0         47        640:  33%|███▎      | 6/18 [00:01<00:02,  4.81it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      15/39      1.89G    0.04336    0.02077          0         33        640:  39%|███▉      | 7/18 [00:01<00:02,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      15/39      1.89G     0.0434    0.02038          0         39        640:  44%|████▍     | 8/18 [00:01<00:02,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      15/39      1.89G    0.04296    0.01994          0         33        640:  50%|█████     | 9/18 [00:01<00:01,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      15/39      1.89G    0.04322    0.01982          0         40        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      15/39      1.89G    0.04296    0.01989          0         43        640:  61%|██████    | 11/18 [00:02<00:01,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      15/39      1.89G    0.04306    0.01963          0         35        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      15/39      1.89G    0.04325    0.01943          0         36        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.98it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      15/39      1.89G    0.04329    0.01954          0         46        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      15/39      1.89G    0.04331    0.01951          0         41        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.96it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      15/39      1.89G     0.0432     0.0196          0         44        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.97it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      15/39      1.89G    0.04315    0.01972          0         45        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      15/39      1.89G    0.04314    0.01969          0         29        640: 100%|██████████| 18/18 [00:03<00:00,  4.96it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.94it/s]\n",
      "                   all         71        117      0.968      0.846       0.93      0.451\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      16/39      1.89G    0.04134    0.01598          0         33        640:   6%|▌         | 1/18 [00:00<00:03,  5.00it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      16/39      1.89G    0.04077    0.01575          0         32        640:  11%|█         | 2/18 [00:00<00:03,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      16/39      1.89G    0.04058    0.01592          0         33        640:  17%|█▋        | 3/18 [00:00<00:03,  4.96it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      16/39      1.89G    0.04139    0.01705          0         43        640:  22%|██▏       | 4/18 [00:00<00:02,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      16/39      1.89G    0.04141    0.01814          0         49        640:  28%|██▊       | 5/18 [00:01<00:02,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      16/39      1.89G    0.04157    0.01859          0         45        640:  33%|███▎      | 6/18 [00:01<00:02,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      16/39      1.89G    0.04172    0.01878          0         49        640:  39%|███▉      | 7/18 [00:01<00:02,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      16/39      1.89G    0.04161    0.01885          0         42        640:  44%|████▍     | 8/18 [00:01<00:02,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      16/39      1.89G    0.04195    0.01866          0         35        640:  50%|█████     | 9/18 [00:01<00:01,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      16/39      1.89G    0.04221    0.01894          0         46        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      16/39      1.89G    0.04237    0.01888          0         39        640:  61%|██████    | 11/18 [00:02<00:01,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      16/39      1.89G    0.04237    0.01868          0         38        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      16/39      1.89G    0.04216     0.0191          0         51        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      16/39      1.89G    0.04204    0.01927          0         45        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      16/39      1.89G    0.04198    0.01911          0         33        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      16/39      1.89G    0.04194    0.01883          0         33        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      16/39      1.89G    0.04186    0.01863          0         30        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      16/39      1.89G    0.04191    0.01871          0         32        640: 100%|██████████| 18/18 [00:03<00:00,  4.94it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.78it/s]\n",
      "                   all         71        117      0.987      0.846      0.947      0.485\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      17/39      1.89G    0.04382    0.01989          0         44        640:   6%|▌         | 1/18 [00:00<00:03,  4.74it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      17/39      1.89G    0.04037    0.02069          0         45        640:  11%|█         | 2/18 [00:00<00:03,  4.67it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      17/39      1.89G    0.03997     0.0206          0         40        640:  17%|█▋        | 3/18 [00:00<00:03,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      17/39      1.89G    0.03965    0.02027          0         43        640:  22%|██▏       | 4/18 [00:00<00:02,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      17/39      1.89G    0.04033    0.01989          0         38        640:  28%|██▊       | 5/18 [00:01<00:02,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      17/39      1.89G    0.03971    0.02003          0         44        640:  33%|███▎      | 6/18 [00:01<00:02,  4.78it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      17/39      1.89G    0.03995    0.01994          0         42        640:  39%|███▉      | 7/18 [00:01<00:02,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      17/39      1.89G    0.04013    0.01999          0         45        640:  44%|████▍     | 8/18 [00:01<00:02,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      17/39      1.89G    0.04033    0.01992          0         43        640:  50%|█████     | 9/18 [00:01<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      17/39      1.89G    0.04054    0.01968          0         40        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.76it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      17/39      1.89G    0.04054     0.0192          0         31        640:  61%|██████    | 11/18 [00:02<00:01,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      17/39      1.89G    0.04049    0.01955          0         52        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      17/39      1.89G    0.04045    0.01951          0         39        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      17/39      1.89G    0.04027    0.01919          0         29        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      17/39      1.89G     0.0404    0.01945          0         49        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      17/39      1.89G    0.04046    0.01952          0         44        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      17/39      1.89G    0.04051     0.0198          0         54        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      17/39      1.89G    0.04053    0.01961          0         30        640: 100%|██████████| 18/18 [00:03<00:00,  4.88it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.93it/s]\n",
      "                   all         71        117       0.91      0.846      0.927      0.527\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      18/39      1.89G    0.03971    0.01742          0         38        640:   6%|▌         | 1/18 [00:00<00:03,  4.98it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      18/39      1.89G    0.03904    0.01879          0         43        640:  11%|█         | 2/18 [00:00<00:03,  4.98it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      18/39      1.89G    0.03954    0.01774          0         34        640:  17%|█▋        | 3/18 [00:00<00:03,  4.96it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      18/39      1.89G    0.04127    0.01867          0         54        640:  22%|██▏       | 4/18 [00:00<00:02,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      18/39      1.89G    0.04141    0.01827          0         34        640:  28%|██▊       | 5/18 [00:01<00:02,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      18/39      1.89G    0.04177    0.01876          0         48        640:  33%|███▎      | 6/18 [00:01<00:02,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      18/39      1.89G    0.04153    0.01862          0         36        640:  39%|███▉      | 7/18 [00:01<00:02,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      18/39      1.89G    0.04144    0.01909          0         50        640:  44%|████▍     | 8/18 [00:01<00:02,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      18/39      1.89G    0.04085    0.01925          0         42        640:  50%|█████     | 9/18 [00:01<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      18/39      1.89G     0.0411    0.01905          0         43        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      18/39      1.89G     0.0408    0.01887          0         35        640:  61%|██████    | 11/18 [00:02<00:01,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      18/39      1.89G    0.04054    0.01903          0         51        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      18/39      1.89G    0.04057    0.01889          0         39        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      18/39      1.89G     0.0408    0.01867          0         29        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      18/39      1.89G    0.04071    0.01874          0         42        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.96it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      18/39      1.89G    0.04095    0.01893          0         45        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      18/39      1.89G    0.04091    0.01902          0         44        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      18/39      1.89G    0.04092    0.01909          0         35        640: 100%|██████████| 18/18 [00:03<00:00,  4.96it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.81it/s]\n",
      "                   all         71        117      0.972      0.904      0.962      0.566\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      19/39      1.89G    0.04213    0.02046          0         47        640:   6%|▌         | 1/18 [00:00<00:03,  5.05it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      19/39      1.89G    0.04083    0.02071          0         49        640:  11%|█         | 2/18 [00:00<00:03,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      19/39      1.89G    0.04057    0.02112          0         50        640:  17%|█▋        | 3/18 [00:00<00:03,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      19/39      1.89G    0.04002    0.02016          0         39        640:  22%|██▏       | 4/18 [00:00<00:02,  4.99it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      19/39      1.89G    0.04123    0.01954          0         36        640:  28%|██▊       | 5/18 [00:01<00:02,  4.98it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      19/39      1.89G    0.04094    0.01861          0         29        640:  33%|███▎      | 6/18 [00:01<00:02,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      19/39      1.89G    0.04038    0.01834          0         40        640:  39%|███▉      | 7/18 [00:01<00:02,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      19/39      1.89G    0.04041    0.01827          0         44        640:  44%|████▍     | 8/18 [00:01<00:02,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      19/39      1.89G       0.04      0.018          0         34        640:  50%|█████     | 9/18 [00:01<00:01,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      19/39      1.89G    0.03983    0.01773          0         33        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.81it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      19/39      1.89G    0.03982     0.0179          0         47        640:  61%|██████    | 11/18 [00:02<00:01,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      19/39      1.89G    0.03993    0.01802          0         39        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      19/39      1.89G    0.03999    0.01798          0         37        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      19/39      1.89G    0.04003    0.01802          0         44        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      19/39      1.89G    0.03995    0.01785          0         33        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      19/39      1.89G    0.03978    0.01782          0         37        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.79it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      19/39      1.89G    0.03959    0.01795          0         43        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.81it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      19/39      1.89G    0.03927    0.01789          0         26        640: 100%|██████████| 18/18 [00:03<00:00,  4.90it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.72it/s]\n",
      "                   all         71        117      0.981      0.902      0.961      0.505\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      20/39      1.89G    0.03668    0.02059          0         44        640:   6%|▌         | 1/18 [00:00<00:03,  5.03it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      20/39      1.89G    0.03715    0.02003          0         41        640:  11%|█         | 2/18 [00:00<00:03,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      20/39      1.89G    0.03879    0.01998          0         44        640:  17%|█▋        | 3/18 [00:00<00:03,  4.81it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      20/39      1.89G    0.03945    0.01892          0         36        640:  22%|██▏       | 4/18 [00:00<00:02,  4.73it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      20/39      1.89G    0.03916     0.0193          0         49        640:  28%|██▊       | 5/18 [00:01<00:02,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      20/39      1.89G    0.03949    0.01867          0         34        640:  33%|███▎      | 6/18 [00:01<00:02,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      20/39      1.89G     0.0393    0.01917          0         50        640:  39%|███▉      | 7/18 [00:01<00:02,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      20/39      1.89G    0.03907    0.01926          0         44        640:  44%|████▍     | 8/18 [00:01<00:02,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      20/39      1.89G    0.03902    0.01884          0         35        640:  50%|█████     | 9/18 [00:01<00:01,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      20/39      1.89G    0.03908    0.01878          0         48        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      20/39      1.89G     0.0393    0.01894          0         48        640:  61%|██████    | 11/18 [00:02<00:01,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      20/39      1.89G    0.03938    0.01869          0         35        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.79it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      20/39      1.89G    0.03919    0.01863          0         39        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      20/39      1.89G     0.0391    0.01878          0         45        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      20/39      1.89G    0.03888    0.01868          0         35        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      20/39      1.89G     0.0387    0.01868          0         39        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      20/39      1.89G    0.03873    0.01884          0         50        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      20/39      1.89G    0.03865    0.01892          0         44        640: 100%|██████████| 18/18 [00:03<00:00,  4.92it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.95it/s]\n",
      "                   all         71        117      0.972      0.892      0.961      0.516\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      21/39      1.89G    0.03786    0.01816          0         42        640:   6%|▌         | 1/18 [00:00<00:03,  5.03it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      21/39      1.89G     0.0377    0.01805          0         42        640:  11%|█         | 2/18 [00:00<00:03,  4.72it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      21/39      1.89G    0.03702    0.01811          0         41        640:  17%|█▋        | 3/18 [00:00<00:03,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      21/39      1.89G    0.03765    0.01841          0         43        640:  22%|██▏       | 4/18 [00:00<00:02,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      21/39      1.89G    0.03795    0.01871          0         46        640:  28%|██▊       | 5/18 [00:01<00:02,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      21/39      1.89G    0.03787    0.01816          0         34        640:  33%|███▎      | 6/18 [00:01<00:02,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      21/39      1.89G    0.03826     0.0178          0         34        640:  39%|███▉      | 7/18 [00:01<00:02,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      21/39      1.89G    0.03828    0.01799          0         46        640:  44%|████▍     | 8/18 [00:01<00:02,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      21/39      1.89G    0.03811    0.01799          0         41        640:  50%|█████     | 9/18 [00:01<00:01,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      21/39      1.89G    0.03822    0.01808          0         41        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      21/39      1.89G    0.03839    0.01813          0         45        640:  61%|██████    | 11/18 [00:02<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      21/39      1.89G     0.0382    0.01853          0         50        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      21/39      1.89G    0.03849    0.01818          0         34        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      21/39      1.89G    0.03827    0.01784          0         30        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      21/39      1.89G    0.03833     0.0181          0         52        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      21/39      1.89G    0.03822    0.01823          0         50        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      21/39      1.89G     0.0383    0.01834          0         48        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      21/39      1.89G    0.03828     0.0184          0         35        640: 100%|██████████| 18/18 [00:03<00:00,  4.92it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.91it/s]\n",
      "                   all         71        117      0.981      0.901      0.962      0.515\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      22/39      1.89G    0.03267    0.01939          0         42        640:   6%|▌         | 1/18 [00:00<00:03,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      22/39      1.89G    0.03578    0.01794          0         35        640:  11%|█         | 2/18 [00:00<00:03,  4.97it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      22/39      1.89G    0.03625     0.0167          0         34        640:  17%|█▋        | 3/18 [00:00<00:03,  4.99it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      22/39      1.89G    0.03654    0.01713          0         41        640:  22%|██▏       | 4/18 [00:00<00:02,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      22/39      1.89G    0.03652    0.01745          0         42        640:  28%|██▊       | 5/18 [00:01<00:02,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      22/39      1.89G    0.03711    0.01846          0         57        640:  33%|███▎      | 6/18 [00:01<00:02,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      22/39      1.89G    0.03674    0.01826          0         40        640:  39%|███▉      | 7/18 [00:01<00:02,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      22/39      1.89G    0.03668     0.0191          0         58        640:  44%|████▍     | 8/18 [00:01<00:02,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      22/39      1.89G    0.03659    0.01886          0         42        640:  50%|█████     | 9/18 [00:01<00:01,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      22/39      1.89G    0.03672    0.01901          0         46        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      22/39      1.89G    0.03654    0.01877          0         38        640:  61%|██████    | 11/18 [00:02<00:01,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      22/39      1.89G     0.0367    0.01876          0         47        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      22/39      1.89G    0.03673    0.01876          0         41        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      22/39      1.89G    0.03675    0.01861          0         37        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      22/39      1.89G    0.03676    0.01898          0         58        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      22/39      1.89G     0.0368    0.01935          0         55        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      22/39      1.89G    0.03679    0.01909          0         35        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      22/39      1.89G    0.03677     0.0189          0         28        640: 100%|██████████| 18/18 [00:03<00:00,  4.96it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.86it/s]\n",
      "                   all         71        117      0.954      0.895      0.946      0.554\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      23/39      1.89G    0.03463     0.0175          0         41        640:   6%|▌         | 1/18 [00:00<00:03,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      23/39      1.89G    0.03404    0.01855          0         43        640:  11%|█         | 2/18 [00:00<00:03,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      23/39      1.89G    0.03496     0.0174          0         35        640:  17%|█▋        | 3/18 [00:00<00:03,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      23/39      1.89G    0.03575    0.01752          0         43        640:  22%|██▏       | 4/18 [00:00<00:02,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      23/39      1.89G    0.03601    0.01659          0         33        640:  28%|██▊       | 5/18 [00:01<00:02,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      23/39      1.89G    0.03591    0.01683          0         39        640:  33%|███▎      | 6/18 [00:01<00:02,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      23/39      1.89G     0.0355    0.01712          0         47        640:  39%|███▉      | 7/18 [00:01<00:02,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      23/39      1.89G    0.03543    0.01721          0         39        640:  44%|████▍     | 8/18 [00:01<00:02,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      23/39      1.89G    0.03545     0.0177          0         49        640:  50%|█████     | 9/18 [00:01<00:01,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      23/39      1.89G     0.0358    0.01744          0         34        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      23/39      1.89G    0.03592    0.01782          0         49        640:  61%|██████    | 11/18 [00:02<00:01,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      23/39      1.89G    0.03589     0.0177          0         37        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      23/39      1.89G    0.03603     0.0175          0         38        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      23/39      1.89G    0.03594    0.01754          0         45        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      23/39      1.89G    0.03585    0.01732          0         33        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      23/39      1.89G    0.03587    0.01735          0         41        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      23/39      1.89G    0.03609     0.0173          0         42        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      23/39      1.89G    0.03618     0.0172          0         27        640: 100%|██████████| 18/18 [00:03<00:00,  4.94it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  6.04it/s]\n",
      "                   all         71        117      0.981      0.897      0.958      0.505\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      24/39      1.89G     0.0352    0.01832          0         43        640:   6%|▌         | 1/18 [00:00<00:03,  5.10it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      24/39      1.89G    0.03535    0.01727          0         39        640:  11%|█         | 2/18 [00:00<00:03,  4.97it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      24/39      1.89G    0.03535     0.0177          0         42        640:  17%|█▋        | 3/18 [00:00<00:03,  4.96it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      24/39      1.89G     0.0354    0.01833          0         52        640:  22%|██▏       | 4/18 [00:00<00:02,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      24/39      1.89G     0.0357    0.01837          0         45        640:  28%|██▊       | 5/18 [00:01<00:02,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      24/39      1.89G     0.0356    0.01849          0         49        640:  33%|███▎      | 6/18 [00:01<00:02,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      24/39      1.89G    0.03567    0.01848          0         46        640:  39%|███▉      | 7/18 [00:01<00:02,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      24/39      1.89G    0.03582    0.01831          0         39        640:  44%|████▍     | 8/18 [00:01<00:02,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      24/39      1.89G    0.03564    0.01822          0         40        640:  50%|█████     | 9/18 [00:01<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      24/39      1.89G    0.03591    0.01769          0         29        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      24/39      1.89G    0.03587    0.01766          0         44        640:  61%|██████    | 11/18 [00:02<00:01,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      24/39      1.89G    0.03589     0.0178          0         46        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      24/39      1.89G    0.03591    0.01738          0         31        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      24/39      1.89G    0.03582    0.01737          0         42        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      24/39      1.89G    0.03561    0.01739          0         41        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      24/39      1.89G    0.03558    0.01734          0         40        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      24/39      1.89G    0.03553    0.01731          0         41        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      24/39      1.89G    0.03541    0.01725          0         28        640: 100%|██████████| 18/18 [00:03<00:00,  4.96it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.96it/s]\n",
      "                   all         71        117      0.941      0.889      0.961      0.537\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      25/39      1.89G    0.03929    0.01895          0         43        640:   6%|▌         | 1/18 [00:00<00:03,  4.98it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      25/39      1.89G    0.03792    0.01872          0         42        640:  11%|█         | 2/18 [00:00<00:03,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      25/39      1.89G    0.03689    0.01911          0         49        640:  17%|█▋        | 3/18 [00:00<00:03,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      25/39      1.89G    0.03654     0.0196          0         50        640:  22%|██▏       | 4/18 [00:00<00:02,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      25/39      1.89G    0.03598    0.01909          0         39        640:  28%|██▊       | 5/18 [00:01<00:02,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      25/39      1.89G    0.03558    0.01893          0         43        640:  33%|███▎      | 6/18 [00:01<00:02,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      25/39      1.89G    0.03569    0.01849          0         36        640:  39%|███▉      | 7/18 [00:01<00:02,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      25/39      1.89G    0.03539      0.019          0         57        640:  44%|████▍     | 8/18 [00:01<00:02,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      25/39      1.89G    0.03548    0.01892          0         43        640:  50%|█████     | 9/18 [00:01<00:01,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      25/39      1.89G    0.03551    0.01901          0         48        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      25/39      1.89G    0.03526    0.01897          0         44        640:  61%|██████    | 11/18 [00:02<00:01,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      25/39      1.89G    0.03537    0.01866          0         39        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      25/39      1.89G    0.03558    0.01864          0         45        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.98it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      25/39      1.89G    0.03545     0.0185          0         42        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      25/39      1.89G    0.03544    0.01862          0         48        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      25/39      1.89G    0.03546    0.01836          0         31        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      25/39      1.89G     0.0355    0.01846          0         49        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      25/39      1.89G    0.03536    0.01867          0         41        640: 100%|██████████| 18/18 [00:03<00:00,  4.95it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.85it/s]\n",
      "                   all         71        117      0.955      0.912      0.963      0.575\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      26/39      1.89G    0.03479    0.01838          0         44        640:   6%|▌         | 1/18 [00:00<00:03,  5.03it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      26/39      1.89G      0.034    0.01608          0         30        640:  11%|█         | 2/18 [00:00<00:03,  5.03it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      26/39      1.89G    0.03424    0.01609          0         35        640:  17%|█▋        | 3/18 [00:00<00:03,  4.99it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      26/39      1.89G    0.03477    0.01668          0         45        640:  22%|██▏       | 4/18 [00:00<00:02,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      26/39      1.89G    0.03419    0.01631          0         39        640:  28%|██▊       | 5/18 [00:01<00:02,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      26/39      1.89G    0.03419    0.01694          0         50        640:  33%|███▎      | 6/18 [00:01<00:02,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      26/39      1.89G     0.0338    0.01695          0         41        640:  39%|███▉      | 7/18 [00:01<00:02,  4.97it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      26/39      1.89G    0.03412    0.01686          0         41        640:  44%|████▍     | 8/18 [00:01<00:02,  4.80it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      26/39      1.89G    0.03391    0.01664          0         35        640:  50%|█████     | 9/18 [00:01<00:01,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      26/39      1.89G     0.0343    0.01686          0         42        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      26/39      1.89G    0.03439    0.01725          0         51        640:  61%|██████    | 11/18 [00:02<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      26/39      1.89G    0.03431    0.01746          0         44        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      26/39      1.89G    0.03418    0.01776          0         56        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      26/39      1.89G    0.03422    0.01768          0         39        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      26/39      1.89G    0.03425    0.01791          0         57        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      26/39      1.89G    0.03419    0.01792          0         42        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      26/39      1.89G    0.03432    0.01784          0         43        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      26/39      1.89G    0.03437    0.01794          0         38        640: 100%|██████████| 18/18 [00:03<00:00,  4.96it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.94it/s]\n",
      "                   all         71        117      0.854       0.88      0.911      0.529\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      27/39      1.89G    0.03703    0.01903          0         48        640:   6%|▌         | 1/18 [00:00<00:03,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      27/39      1.89G     0.0349     0.0179          0         44        640:  11%|█         | 2/18 [00:00<00:03,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      27/39      1.89G    0.03452    0.01976          0         61        640:  17%|█▋        | 3/18 [00:00<00:03,  4.96it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      27/39      1.89G    0.03368     0.0211          0         59        640:  22%|██▏       | 4/18 [00:00<00:02,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      27/39      1.89G    0.03255    0.01905          0         30        640:  28%|██▊       | 5/18 [00:01<00:02,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      27/39      1.89G    0.03203    0.01819          0         33        640:  33%|███▎      | 6/18 [00:01<00:02,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      27/39      1.89G    0.03272    0.01784          0         37        640:  39%|███▉      | 7/18 [00:01<00:02,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      27/39      1.89G    0.03309    0.01778          0         40        640:  44%|████▍     | 8/18 [00:01<00:02,  4.96it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      27/39      1.89G    0.03381    0.01778          0         43        640:  50%|█████     | 9/18 [00:01<00:01,  4.98it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      27/39      1.89G    0.03403    0.01748          0         37        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      27/39      1.89G    0.03385    0.01784          0         53        640:  61%|██████    | 11/18 [00:02<00:01,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      27/39      1.89G     0.0336    0.01759          0         33        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.96it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      27/39      1.89G     0.0336     0.0173          0         35        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      27/39      1.89G    0.03358    0.01721          0         36        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      27/39      1.89G    0.03392    0.01691          0         32        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      27/39      1.89G    0.03391    0.01693          0         38        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      27/39      1.89G    0.03399    0.01688          0         39        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      27/39      1.89G    0.03401    0.01684          0         30        640: 100%|██████████| 18/18 [00:03<00:00,  4.97it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.94it/s]\n",
      "                   all         71        117      0.973      0.909      0.958      0.587\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      28/39      1.89G    0.03494    0.01893          0         47        640:   6%|▌         | 1/18 [00:00<00:03,  5.03it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      28/39      1.89G     0.0329    0.01802          0         41        640:  11%|█         | 2/18 [00:00<00:03,  4.99it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      28/39      1.89G     0.0328    0.01784          0         44        640:  17%|█▋        | 3/18 [00:00<00:02,  5.03it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      28/39      1.89G    0.03205    0.01722          0         35        640:  22%|██▏       | 4/18 [00:00<00:02,  4.81it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      28/39      1.89G    0.03192     0.0173          0         43        640:  28%|██▊       | 5/18 [00:01<00:02,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      28/39      1.89G    0.03261    0.01722          0         43        640:  33%|███▎      | 6/18 [00:01<00:02,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      28/39      1.89G    0.03253     0.0173          0         46        640:  39%|███▉      | 7/18 [00:01<00:02,  4.97it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      28/39      1.89G    0.03289    0.01774          0         48        640:  44%|████▍     | 8/18 [00:01<00:02,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      28/39      1.89G    0.03279    0.01793          0         47        640:  50%|█████     | 9/18 [00:01<00:01,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      28/39      1.89G    0.03309    0.01758          0         35        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      28/39      1.89G    0.03314    0.01769          0         50        640:  61%|██████    | 11/18 [00:02<00:01,  4.97it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      28/39      1.89G    0.03311    0.01772          0         45        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      28/39      1.89G    0.03309    0.01757          0         36        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      28/39      1.89G    0.03309    0.01757          0         46        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      28/39      1.89G    0.03322    0.01762          0         47        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      28/39      1.89G    0.03336    0.01728          0         26        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      28/39      1.89G    0.03332    0.01717          0         37        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      28/39      1.89G    0.03329    0.01706          0         30        640: 100%|██████████| 18/18 [00:03<00:00,  4.95it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.84it/s]\n",
      "                   all         71        117      0.973      0.912      0.968      0.612\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      29/39      1.89G    0.03154     0.0153          0         40        640:   6%|▌         | 1/18 [00:00<00:03,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      29/39      1.89G    0.03182    0.01829          0         53        640:  11%|█         | 2/18 [00:00<00:03,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      29/39      1.89G    0.03292     0.0174          0         42        640:  17%|█▋        | 3/18 [00:00<00:03,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      29/39      1.89G    0.03322    0.01724          0         43        640:  22%|██▏       | 4/18 [00:00<00:02,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      29/39      1.89G      0.033    0.01669          0         34        640:  28%|██▊       | 5/18 [00:01<00:02,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      29/39      1.89G    0.03323    0.01703          0         45        640:  33%|███▎      | 6/18 [00:01<00:02,  4.78it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      29/39      1.89G    0.03283    0.01738          0         47        640:  39%|███▉      | 7/18 [00:01<00:02,  4.64it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      29/39      1.89G    0.03309    0.01763          0         50        640:  44%|████▍     | 8/18 [00:01<00:02,  4.75it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      29/39      1.89G    0.03314    0.01781          0         50        640:  50%|█████     | 9/18 [00:01<00:01,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      29/39      1.89G    0.03293    0.01812          0         49        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      29/39      1.89G    0.03325    0.01788          0         38        640:  61%|██████    | 11/18 [00:02<00:01,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      29/39      1.89G    0.03326    0.01772          0         41        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      29/39      1.89G    0.03331    0.01762          0         41        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.97it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      29/39      1.89G    0.03344    0.01753          0         37        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      29/39      1.89G    0.03351    0.01733          0         35        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      29/39      1.89G    0.03351    0.01751          0         48        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      29/39      1.89G    0.03341    0.01738          0         38        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      29/39      1.89G    0.03337    0.01751          0         40        640: 100%|██████████| 18/18 [00:03<00:00,  4.90it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  6.04it/s]\n",
      "                   all         71        117      0.973      0.912      0.968      0.579\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      30/39      1.89G    0.03391    0.02019          0         50        640:   6%|▌         | 1/18 [00:00<00:03,  5.02it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      30/39      1.89G    0.03299     0.0204          0         49        640:  11%|█         | 2/18 [00:00<00:03,  5.01it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      30/39      1.89G    0.03425    0.02031          0         47        640:  17%|█▋        | 3/18 [00:00<00:03,  4.97it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      30/39      1.89G    0.03331    0.01843          0         29        640:  22%|██▏       | 4/18 [00:00<00:02,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      30/39      1.89G    0.03305     0.0197          0         59        640:  28%|██▊       | 5/18 [00:01<00:02,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      30/39      1.89G    0.03294    0.02001          0         53        640:  33%|███▎      | 6/18 [00:01<00:02,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      30/39      1.89G      0.033    0.02015          0         51        640:  39%|███▉      | 7/18 [00:01<00:02,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      30/39      1.89G    0.03266    0.01966          0         41        640:  44%|████▍     | 8/18 [00:01<00:02,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      30/39      1.89G    0.03263    0.01943          0         43        640:  50%|█████     | 9/18 [00:01<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      30/39      1.89G    0.03271    0.01891          0         34        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      30/39      1.89G    0.03287    0.01888          0         44        640:  61%|██████    | 11/18 [00:02<00:01,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      30/39      1.89G      0.033    0.01866          0         46        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      30/39      1.89G    0.03301    0.01854          0         47        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      30/39      1.89G    0.03292    0.01827          0         39        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      30/39      1.89G    0.03276    0.01807          0         36        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      30/39      1.89G    0.03254    0.01791          0         34        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.76it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      30/39      1.89G    0.03265    0.01768          0         41        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.80it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      30/39      1.89G    0.03272    0.01784          0         42        640: 100%|██████████| 18/18 [00:03<00:00,  4.92it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.90it/s]\n",
      "                   all         71        117      0.948       0.94      0.969      0.557\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      31/39      1.89G    0.03539    0.01348          0         33        640:   6%|▌         | 1/18 [00:00<00:03,  4.96it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      31/39      1.89G    0.03617    0.01568          0         43        640:  11%|█         | 2/18 [00:00<00:03,  4.80it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      31/39      1.89G    0.03338    0.01533          0         36        640:  17%|█▋        | 3/18 [00:00<00:03,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      31/39      1.89G    0.03238    0.01495          0         33        640:  22%|██▏       | 4/18 [00:00<00:02,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      31/39      1.89G    0.03232    0.01478          0         31        640:  28%|██▊       | 5/18 [00:01<00:02,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      31/39      1.89G    0.03251    0.01566          0         52        640:  33%|███▎      | 6/18 [00:01<00:02,  4.81it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      31/39      1.89G    0.03269    0.01636          0         52        640:  39%|███▉      | 7/18 [00:01<00:02,  4.80it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      31/39      1.89G    0.03298    0.01634          0         40        640:  44%|████▍     | 8/18 [00:01<00:02,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      31/39      1.89G    0.03303    0.01673          0         53        640:  50%|█████     | 9/18 [00:01<00:01,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      31/39      1.89G    0.03299    0.01662          0         39        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.77it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      31/39      1.89G    0.03272    0.01666          0         45        640:  61%|██████    | 11/18 [00:02<00:01,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      31/39      1.89G    0.03259    0.01623          0         26        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      31/39      1.89G    0.03267     0.0161          0         36        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      31/39      1.89G    0.03264    0.01616          0         39        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      31/39      1.89G    0.03278    0.01613          0         43        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      31/39      1.89G    0.03284    0.01625          0         45        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      31/39      1.89G    0.03287    0.01629          0         42        640:  94%|█████████▍| 17/18 [00:03<00:00,  5.00it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      31/39      1.89G     0.0329    0.01651          0         41        640: 100%|██████████| 18/18 [00:03<00:00,  4.92it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  6.00it/s]\n",
      "                   all         71        117      0.956      0.938       0.97      0.593\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      32/39      1.89G    0.03162    0.02049          0         51        640:   6%|▌         | 1/18 [00:00<00:03,  5.00it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      32/39      1.89G    0.03169    0.01781          0         38        640:  11%|█         | 2/18 [00:00<00:03,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      32/39      1.89G    0.03265    0.01905          0         52        640:  17%|█▋        | 3/18 [00:00<00:03,  4.96it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      32/39      1.89G    0.03193    0.01837          0         42        640:  22%|██▏       | 4/18 [00:00<00:02,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      32/39      1.89G    0.03232    0.01836          0         46        640:  28%|██▊       | 5/18 [00:01<00:02,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      32/39      1.89G    0.03224     0.0184          0         47        640:  33%|███▎      | 6/18 [00:01<00:02,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      32/39      1.89G    0.03211    0.01841          0         49        640:  39%|███▉      | 7/18 [00:01<00:02,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      32/39      1.89G    0.03204    0.01833          0         46        640:  44%|████▍     | 8/18 [00:01<00:02,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      32/39      1.89G    0.03216    0.01776          0         30        640:  50%|█████     | 9/18 [00:01<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      32/39      1.89G     0.0321    0.01783          0         47        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      32/39      1.89G    0.03201    0.01797          0         44        640:  61%|██████    | 11/18 [00:02<00:01,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      32/39      1.89G    0.03187     0.0183          0         53        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      32/39      1.89G    0.03181    0.01837          0         47        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      32/39      1.89G    0.03156    0.01811          0         45        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      32/39      1.89G     0.0317    0.01823          0         52        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      32/39      1.89G    0.03172    0.01816          0         44        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      32/39      1.89G    0.03166    0.01812          0         43        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      32/39      1.89G    0.03178    0.01811          0         34        640: 100%|██████████| 18/18 [00:03<00:00,  4.93it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.87it/s]\n",
      "                   all         71        117      0.948      0.939      0.969      0.579\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      33/39      1.89G    0.03202    0.01489          0         35        640:   6%|▌         | 1/18 [00:00<00:03,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      33/39      1.89G    0.03208    0.01546          0         43        640:  11%|█         | 2/18 [00:00<00:03,  4.78it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      33/39      1.89G    0.03187     0.0153          0         37        640:  17%|█▋        | 3/18 [00:00<00:03,  4.81it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      33/39      1.89G      0.031    0.01479          0         31        640:  22%|██▏       | 4/18 [00:00<00:02,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      33/39      1.89G    0.03054    0.01489          0         42        640:  28%|██▊       | 5/18 [00:01<00:02,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      33/39      1.89G    0.03065    0.01558          0         49        640:  33%|███▎      | 6/18 [00:01<00:02,  4.80it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      33/39      1.89G    0.03105    0.01587          0         44        640:  39%|███▉      | 7/18 [00:01<00:02,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      33/39      1.89G    0.03122    0.01595          0         41        640:  44%|████▍     | 8/18 [00:01<00:02,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      33/39      1.89G    0.03118    0.01629          0         46        640:  50%|█████     | 9/18 [00:01<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      33/39      1.89G    0.03127    0.01634          0         39        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      33/39      1.89G    0.03113    0.01645          0         46        640:  61%|██████    | 11/18 [00:02<00:01,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      33/39      1.89G    0.03122    0.01654          0         41        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      33/39      1.89G    0.03113    0.01659          0         44        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      33/39      1.89G    0.03133    0.01647          0         36        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      33/39      1.89G    0.03146     0.0166          0         51        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      33/39      1.89G    0.03159    0.01665          0         43        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      33/39      1.89G    0.03155    0.01657          0         38        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      33/39      1.89G    0.03188    0.01669          0         35        640: 100%|██████████| 18/18 [00:03<00:00,  4.91it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.98it/s]\n",
      "                   all         71        117      0.948      0.939      0.968      0.592\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      34/39      1.89G    0.02937    0.02043          0         55        640:   6%|▌         | 1/18 [00:00<00:03,  5.03it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      34/39      1.89G    0.03046    0.01759          0         36        640:  11%|█         | 2/18 [00:00<00:03,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      34/39      1.89G    0.03029    0.01794          0         49        640:  17%|█▋        | 3/18 [00:00<00:03,  4.97it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      34/39      1.89G    0.03085    0.01725          0         42        640:  22%|██▏       | 4/18 [00:00<00:02,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      34/39      1.89G    0.03168    0.01702          0         39        640:  28%|██▊       | 5/18 [00:01<00:02,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      34/39      1.89G    0.03186    0.01734          0         51        640:  33%|███▎      | 6/18 [00:01<00:02,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      34/39      1.89G    0.03151    0.01698          0         36        640:  39%|███▉      | 7/18 [00:01<00:02,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      34/39      1.89G    0.03131    0.01704          0         47        640:  44%|████▍     | 8/18 [00:01<00:02,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      34/39      1.89G    0.03156    0.01696          0         35        640:  50%|█████     | 9/18 [00:01<00:01,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      34/39      1.89G    0.03129    0.01687          0         47        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      34/39      1.89G    0.03087    0.01666          0         41        640:  61%|██████    | 11/18 [00:02<00:01,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      34/39      1.89G    0.03119    0.01713          0         56        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.80it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      34/39      1.89G    0.03107    0.01706          0         43        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      34/39      1.89G    0.03125    0.01705          0         45        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      34/39      1.89G    0.03128    0.01691          0         39        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      34/39      1.89G    0.03132    0.01702          0         44        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      34/39      1.89G    0.03116    0.01703          0         48        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      34/39      1.89G    0.03112    0.01693          0         28        640: 100%|██████████| 18/18 [00:03<00:00,  4.91it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.72it/s]\n",
      "                   all         71        117      0.948      0.936      0.968      0.606\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      35/39      1.89G    0.02922    0.01488          0         36        640:   6%|▌         | 1/18 [00:00<00:03,  4.80it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      35/39      1.89G    0.03065    0.01729          0         46        640:  11%|█         | 2/18 [00:00<00:03,  4.70it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      35/39      1.89G    0.03073    0.01656          0         38        640:  17%|█▋        | 3/18 [00:00<00:03,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      35/39      1.89G    0.03141     0.0158          0         37        640:  22%|██▏       | 4/18 [00:00<00:02,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      35/39      1.89G    0.03158    0.01639          0         48        640:  28%|██▊       | 5/18 [00:01<00:02,  4.81it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      35/39      1.89G    0.03124    0.01643          0         40        640:  33%|███▎      | 6/18 [00:01<00:02,  4.80it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      35/39      1.89G    0.03119    0.01657          0         42        640:  39%|███▉      | 7/18 [00:01<00:02,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      35/39      1.89G    0.03108    0.01701          0         52        640:  44%|████▍     | 8/18 [00:01<00:02,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      35/39      1.89G    0.03086    0.01725          0         49        640:  50%|█████     | 9/18 [00:01<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      35/39      1.89G    0.03072    0.01726          0         42        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      35/39      1.89G    0.03095    0.01755          0         51        640:  61%|██████    | 11/18 [00:02<00:01,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      35/39      1.89G    0.03091    0.01756          0         44        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      35/39      1.89G    0.03107    0.01753          0         45        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      35/39      1.89G    0.03079     0.0173          0         39        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      35/39      1.89G    0.03073    0.01698          0         33        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      35/39      1.89G    0.03061    0.01696          0         45        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      35/39      1.89G    0.03057    0.01691          0         42        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      35/39      1.89G    0.03036    0.01675          0         26        640: 100%|██████████| 18/18 [00:03<00:00,  4.90it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.87it/s]\n",
      "                   all         71        117      0.949      0.932      0.969      0.597\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      36/39      1.89G    0.03088    0.01932          0         49        640:   6%|▌         | 1/18 [00:00<00:03,  4.97it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      36/39      1.89G    0.03061    0.01748          0         39        640:  11%|█         | 2/18 [00:00<00:03,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      36/39      1.89G    0.03036    0.01716          0         39        640:  17%|█▋        | 3/18 [00:00<00:03,  4.90it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      36/39      1.89G    0.03006    0.01723          0         44        640:  22%|██▏       | 4/18 [00:00<00:02,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      36/39      1.89G    0.03007    0.01779          0         51        640:  28%|██▊       | 5/18 [00:01<00:02,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      36/39      1.89G    0.03022    0.01773          0         46        640:  33%|███▎      | 6/18 [00:01<00:02,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      36/39      1.89G    0.03037    0.01745          0         43        640:  39%|███▉      | 7/18 [00:01<00:02,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      36/39      1.89G    0.03007    0.01737          0         39        640:  44%|████▍     | 8/18 [00:01<00:02,  4.69it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      36/39      1.89G    0.03029    0.01717          0         43        640:  50%|█████     | 9/18 [00:01<00:01,  4.68it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      36/39      1.89G     0.0304    0.01704          0         40        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.70it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      36/39      1.89G    0.03051    0.01711          0         44        640:  61%|██████    | 11/18 [00:02<00:01,  4.63it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      36/39      1.89G    0.03071    0.01713          0         48        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.60it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      36/39      1.89G    0.03053    0.01695          0         38        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.71it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      36/39      1.89G    0.03041    0.01679          0         38        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      36/39      1.89G    0.03038    0.01702          0         55        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.92it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      36/39      1.89G    0.03028    0.01706          0         41        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      36/39      1.89G    0.03033    0.01698          0         36        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.94it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      36/39      1.89G    0.03042    0.01677          0         25        640: 100%|██████████| 18/18 [00:03<00:00,  4.88it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.92it/s]\n",
      "                   all         71        117      0.963      0.932      0.968      0.563\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      37/39      1.89G    0.03292    0.01282          0         29        640:   6%|▌         | 1/18 [00:00<00:03,  5.19it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      37/39      1.89G    0.03156     0.0161          0         51        640:  11%|█         | 2/18 [00:00<00:03,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      37/39      1.89G    0.03123    0.01765          0         52        640:  17%|█▋        | 3/18 [00:00<00:03,  4.61it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      37/39      1.89G    0.02991    0.01677          0         38        640:  22%|██▏       | 4/18 [00:00<00:02,  4.75it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      37/39      1.89G     0.0305    0.01621          0         34        640:  28%|██▊       | 5/18 [00:01<00:02,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      37/39      1.89G    0.03036    0.01692          0         54        640:  33%|███▎      | 6/18 [00:01<00:02,  4.73it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      37/39      1.89G    0.03065    0.01653          0         40        640:  39%|███▉      | 7/18 [00:01<00:02,  4.77it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      37/39      1.89G    0.03063    0.01778          0         66        640:  44%|████▍     | 8/18 [00:01<00:02,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      37/39      1.89G    0.03055    0.01772          0         45        640:  50%|█████     | 9/18 [00:01<00:01,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      37/39      1.89G    0.03067    0.01758          0         41        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.81it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      37/39      1.89G    0.03071    0.01776          0         50        640:  61%|██████    | 11/18 [00:02<00:01,  4.73it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      37/39      1.89G    0.03061    0.01761          0         42        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.80it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      37/39      1.89G    0.03062    0.01743          0         41        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      37/39      1.89G    0.03038    0.01714          0         34        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.81it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      37/39      1.89G    0.03037    0.01739          0         57        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.84it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      37/39      1.89G    0.03042    0.01736          0         44        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      37/39      1.89G    0.03034    0.01734          0         45        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      37/39      1.89G     0.0303    0.01733          0         32        640: 100%|██████████| 18/18 [00:03<00:00,  4.86it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.85it/s]\n",
      "                   all         71        117      0.946       0.94       0.97      0.604\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      38/39      1.89G    0.02943    0.01791          0         49        640:   6%|▌         | 1/18 [00:00<00:03,  4.95it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      38/39      1.89G    0.02986    0.01717          0         43        640:  11%|█         | 2/18 [00:00<00:03,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      38/39      1.89G    0.02938    0.01612          0         39        640:  17%|█▋        | 3/18 [00:00<00:03,  4.96it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      38/39      1.89G     0.0294    0.01689          0         47        640:  22%|██▏       | 4/18 [00:00<00:02,  4.77it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      38/39      1.89G    0.02992    0.01661          0         44        640:  28%|██▊       | 5/18 [00:01<00:02,  4.81it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      38/39      1.89G    0.03002    0.01633          0         39        640:  33%|███▎      | 6/18 [00:01<00:02,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      38/39      1.89G    0.03041    0.01566          0         30        640:  39%|███▉      | 7/18 [00:01<00:02,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      38/39      1.89G     0.0303    0.01613          0         51        640:  44%|████▍     | 8/18 [00:01<00:02,  4.82it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      38/39      1.89G    0.03003    0.01611          0         43        640:  50%|█████     | 9/18 [00:01<00:01,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      38/39      1.89G    0.02994    0.01631          0         48        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.86it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      38/39      1.89G    0.02982    0.01602          0         34        640:  61%|██████    | 11/18 [00:02<00:01,  4.89it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      38/39      1.89G    0.02981    0.01584          0         38        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.77it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      38/39      1.89G    0.02986     0.0156          0         30        640:  72%|███████▏  | 13/18 [00:02<00:01,  4.76it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      38/39      1.89G    0.02987    0.01569          0         42        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.80it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      38/39      1.89G    0.02986    0.01596          0         50        640:  83%|████████▎ | 15/18 [00:03<00:00,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      38/39      1.89G    0.02987    0.01627          0         58        640:  89%|████████▉ | 16/18 [00:03<00:00,  4.83it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      38/39      1.89G    0.02986    0.01645          0         52        640:  94%|█████████▍| 17/18 [00:03<00:00,  4.85it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      38/39      1.89G    0.02988    0.01654          0         33        640: 100%|██████████| 18/18 [00:03<00:00,  4.90it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  5.77it/s]\n",
      "                   all         71        117      0.947       0.94      0.977      0.623\n",
      "\n",
      "      Epoch    GPU_mem   box_loss   obj_loss   cls_loss  Instances       Size\n",
      "  0%|          | 0/18 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      39/39      1.89G    0.03069    0.01509          0         38        640:   6%|▌         | 1/18 [00:00<00:03,  4.65it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      39/39      1.89G    0.02909    0.01299          0         28        640:  11%|█         | 2/18 [00:00<00:03,  4.50it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      39/39      1.89G     0.0293    0.01314          0         37        640:  17%|█▋        | 3/18 [00:00<00:03,  4.42it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      39/39      1.89G    0.02897    0.01393          0         46        640:  22%|██▏       | 4/18 [00:00<00:03,  4.62it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      39/39      1.89G    0.02905    0.01425          0         40        640:  28%|██▊       | 5/18 [00:01<00:02,  4.50it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      39/39      1.89G    0.02886    0.01496          0         50        640:  33%|███▎      | 6/18 [00:01<00:02,  4.48it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      39/39      1.89G    0.02887    0.01526          0         46        640:  39%|███▉      | 7/18 [00:01<00:02,  4.63it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      39/39      1.89G    0.02874    0.01529          0         42        640:  44%|████▍     | 8/18 [00:01<00:02,  4.75it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      39/39      1.89G    0.02888    0.01539          0         41        640:  50%|█████     | 9/18 [00:01<00:01,  4.88it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      39/39      1.89G    0.02886    0.01569          0         45        640:  56%|█████▌    | 10/18 [00:02<00:01,  4.87it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      39/39      1.89G    0.02889    0.01615          0         56        640:  61%|██████    | 11/18 [00:02<00:01,  4.91it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      39/39      1.89G    0.02861    0.01587          0         35        640:  67%|██████▋   | 12/18 [00:02<00:01,  4.93it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      39/39      1.89G    0.02866    0.01614          0         49        640:  72%|███████▏  | 13/18 [00:02<00:00,  5.01it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      39/39      1.89G    0.02869    0.01596          0         35        640:  78%|███████▊  | 14/18 [00:02<00:00,  4.98it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      39/39      1.89G    0.02884    0.01589          0         45        640:  83%|████████▎ | 15/18 [00:03<00:00,  5.01it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      39/39      1.89G     0.0287    0.01589          0         41        640:  89%|████████▉ | 16/18 [00:03<00:00,  5.06it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      39/39      1.89G    0.02884    0.01607          0         48        640:  94%|█████████▍| 17/18 [00:03<00:00,  5.03it/s]/home/konnilol/Downloads/yolov5/train.py:414: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with torch.cuda.amp.autocast(amp):\n",
      "      39/39      1.89G    0.02888    0.01631          0         39        640: 100%|██████████| 18/18 [00:03<00:00,  4.89it/s]\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  6.16it/s]\n",
      "                   all         71        117      0.968      0.923      0.972      0.608\n",
      "\n",
      "40 epochs completed in 0.050 hours.\n",
      "Optimizer stripped from /home/konnilol/Downloads/work_hf_yolov5n_car/runs/train/hf_yolov5n_car_img640/weights/last.pt, 3.8MB\n",
      "Optimizer stripped from /home/konnilol/Downloads/work_hf_yolov5n_car/runs/train/hf_yolov5n_car_img640/weights/best.pt, 3.8MB\n",
      "\n",
      "Validating /home/konnilol/Downloads/work_hf_yolov5n_car/runs/train/hf_yolov5n_car_img640/weights/best.pt...\n",
      "Fusing layers... \n",
      "YOLOv5n_img640_custom summary: 157 layers, 1760518 parameters, 0 gradients, 4.1 GFLOPs\n",
      "                 Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 3/3 [00:00<00:00,  4.12it/s]\n",
      "                   all         71        117      0.947       0.94      0.973      0.623\n",
      "Results saved to \u001b[1m/home/konnilol/Downloads/work_hf_yolov5n_car/runs/train/hf_yolov5n_car_img640\u001b[0m\n"
     ]
    },
    {
     "data": {
      "application/vnd.positron.dataexplorer+json": {
       "comm_id": "54ab5126-c2d2-4729-b8d5-0ec1e18c425d",
       "shape": {
        "columns": 14,
        "rows": 5
       },
       "source": "pandas",
       "title": "pandas",
       "version": 1
      },
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>epoch</th>\n",
       "      <th>train/box_loss</th>\n",
       "      <th>train/obj_loss</th>\n",
       "      <th>train/cls_loss</th>\n",
       "      <th>metrics/precision</th>\n",
       "      <th>metrics/recall</th>\n",
       "      <th>metrics/mAP_0.5</th>\n",
       "      <th>metrics/mAP_0.5:0.95</th>\n",
       "      <th>val/box_loss</th>\n",
       "      <th>val/obj_loss</th>\n",
       "      <th>val/cls_loss</th>\n",
       "      <th>x/lr0</th>\n",
       "      <th>x/lr1</th>\n",
       "      <th>x/lr2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>35</th>\n",
       "      <td>35</td>\n",
       "      <td>0.030358</td>\n",
       "      <td>0.016747</td>\n",
       "      <td>0</td>\n",
       "      <td>0.94870</td>\n",
       "      <td>0.93162</td>\n",
       "      <td>0.96856</td>\n",
       "      <td>0.59745</td>\n",
       "      <td>0.028469</td>\n",
       "      <td>0.016424</td>\n",
       "      <td>0</td>\n",
       "      <td>0.000756</td>\n",
       "      <td>0.000756</td>\n",
       "      <td>0.000756</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>36</th>\n",
       "      <td>36</td>\n",
       "      <td>0.030420</td>\n",
       "      <td>0.016772</td>\n",
       "      <td>0</td>\n",
       "      <td>0.96310</td>\n",
       "      <td>0.93162</td>\n",
       "      <td>0.96807</td>\n",
       "      <td>0.56348</td>\n",
       "      <td>0.029352</td>\n",
       "      <td>0.016553</td>\n",
       "      <td>0</td>\n",
       "      <td>0.000690</td>\n",
       "      <td>0.000690</td>\n",
       "      <td>0.000690</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>37</th>\n",
       "      <td>37</td>\n",
       "      <td>0.030297</td>\n",
       "      <td>0.017334</td>\n",
       "      <td>0</td>\n",
       "      <td>0.94628</td>\n",
       "      <td>0.94017</td>\n",
       "      <td>0.96999</td>\n",
       "      <td>0.60376</td>\n",
       "      <td>0.028141</td>\n",
       "      <td>0.016425</td>\n",
       "      <td>0</td>\n",
       "      <td>0.000624</td>\n",
       "      <td>0.000624</td>\n",
       "      <td>0.000624</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>38</th>\n",
       "      <td>38</td>\n",
       "      <td>0.029882</td>\n",
       "      <td>0.016544</td>\n",
       "      <td>0</td>\n",
       "      <td>0.94723</td>\n",
       "      <td>0.94017</td>\n",
       "      <td>0.97664</td>\n",
       "      <td>0.62331</td>\n",
       "      <td>0.027333</td>\n",
       "      <td>0.016317</td>\n",
       "      <td>0</td>\n",
       "      <td>0.000558</td>\n",
       "      <td>0.000558</td>\n",
       "      <td>0.000558</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>39</th>\n",
       "      <td>39</td>\n",
       "      <td>0.028877</td>\n",
       "      <td>0.016305</td>\n",
       "      <td>0</td>\n",
       "      <td>0.96781</td>\n",
       "      <td>0.92308</td>\n",
       "      <td>0.97214</td>\n",
       "      <td>0.60830</td>\n",
       "      <td>0.027250</td>\n",
       "      <td>0.016127</td>\n",
       "      <td>0</td>\n",
       "      <td>0.000492</td>\n",
       "      <td>0.000492</td>\n",
       "      <td>0.000492</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    epoch  train/box_loss  train/obj_loss  train/cls_loss  metrics/precision  \\\n",
       "35     35        0.030358        0.016747               0            0.94870   \n",
       "36     36        0.030420        0.016772               0            0.96310   \n",
       "37     37        0.030297        0.017334               0            0.94628   \n",
       "38     38        0.029882        0.016544               0            0.94723   \n",
       "39     39        0.028877        0.016305               0            0.96781   \n",
       "\n",
       "    metrics/recall  metrics/mAP_0.5  metrics/mAP_0.5:0.95  val/box_loss  \\\n",
       "35         0.93162          0.96856               0.59745      0.028469   \n",
       "36         0.93162          0.96807               0.56348      0.029352   \n",
       "37         0.94017          0.96999               0.60376      0.028141   \n",
       "38         0.94017          0.97664               0.62331      0.027333   \n",
       "39         0.92308          0.97214               0.60830      0.027250   \n",
       "\n",
       "    val/obj_loss  val/cls_loss     x/lr0     x/lr1     x/lr2  \n",
       "35      0.016424             0  0.000756  0.000756  0.000756  \n",
       "36      0.016553             0  0.000690  0.000690  0.000690  \n",
       "37      0.016425             0  0.000624  0.000624  0.000624  \n",
       "38      0.016317             0  0.000558  0.000558  0.000558  \n",
       "39      0.016127             0  0.000492  0.000492  0.000492  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "BEST_IMG_SIZE = int(pilot_df.iloc[0][\"imgsz\"])\n",
    "BEST_CFG_PATH = build_model_cfg_for_imgsz(BEST_IMG_SIZE)\n",
    "\n",
    "FINAL_RUN_NAME = f\"hf_yolov5n_car_img{BEST_IMG_SIZE}\"\n",
    "FINAL_RUN_DIR = WORKDIR / \"runs\" / \"train\" / FINAL_RUN_NAME\n",
    "if FINAL_RUN_DIR.exists():\n",
    "    shutil.rmtree(FINAL_RUN_DIR)\n",
    "\n",
    "final_cmd = [\n",
    "    sys.executable, \"yolov5/train.py\",\n",
    "    \"--img\", str(BEST_IMG_SIZE),\n",
    "    \"--batch\", str(BATCH_SIZE),\n",
    "    \"--epochs\", str(FINAL_EPOCHS),\n",
    "    \"--data\", str(data_yaml_path),\n",
    "    \"--cfg\", str(BEST_CFG_PATH),\n",
    "    \"--weights\", str(hf_weights_path),\n",
    "    \"--hyp\", str(hyp_path),\n",
    "    \"--project\", str(WORKDIR / \"runs\" / \"train\"),\n",
    "    \"--name\", FINAL_RUN_NAME,\n",
    "    \"--exist-ok\",\n",
    "    \"--workers\", \"0\",\n",
    "    \"--device\", DEVICE,\n",
    "]\n",
    "print(\"Финальный запуск:\", \" \".join(final_cmd))\n",
    "subprocess.run(final_cmd, check=True)\n",
    "\n",
    "final_results_csv = FINAL_RUN_DIR / \"results.csv\"\n",
    "results_df, best_row = read_best_row(final_results_csv)\n",
    "display(results_df.tail())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35fc5356",
   "metadata": {},
   "source": [
    "## 13. Извлечение метрик качества"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b9422171",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.positron.dataexplorer+json": {
       "comm_id": "5f74fdcd-740f-4716-9263-dd94e27e50a1",
       "shape": {
        "columns": 2,
        "rows": 4
       },
       "source": "pandas",
       "title": "pandas",
       "version": 1
      },
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Метрика</th>\n",
       "      <th>Значение</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Precision</td>\n",
       "      <td>0.94723</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Recall</td>\n",
       "      <td>0.94017</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>mAP@0.50</td>\n",
       "      <td>0.97664</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>mAP@0.50:0.95</td>\n",
       "      <td>0.62331</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Метрика  Значение\n",
       "0      Precision   0.94723\n",
       "1         Recall   0.94017\n",
       "2       mAP@0.50   0.97664\n",
       "3  mAP@0.50:0.95   0.62331"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results_df.columns = [c.strip() for c in results_df.columns]\n",
    "\n",
    "epoch_col = [c for c in results_df.columns if \"epoch\" in c][0]\n",
    "p_col = [c for c in results_df.columns if \"metrics/precision\" in c][0]\n",
    "r_col = [c for c in results_df.columns if \"metrics/recall\" in c][0]\n",
    "map50_col = [c for c in results_df.columns if \"metrics/mAP_0.5\" in c and \"0.5:0.95\" not in c][0]\n",
    "map5095_col = [c for c in results_df.columns if \"metrics/mAP_0.5:0.95\" in c][0]\n",
    "\n",
    "summary_df = pd.DataFrame({\n",
    "    \"Метрика\": [\"Precision\", \"Recall\", \"mAP@0.50\", \"mAP@0.50:0.95\"],\n",
    "    \"Значение\": [\n",
    "        float(best_row[p_col]),\n",
    "        float(best_row[r_col]),\n",
    "        float(best_row[map50_col]),\n",
    "        float(best_row[map5095_col]),\n",
    "    ],\n",
    "})\n",
    "summary_df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b93653d0",
   "metadata": {},
   "source": [
    "## 14. Графики обучения"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1723bce6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "box_train_col = [c for c in results_df.columns if \"train/box_loss\" in c][0]\n",
    "box_val_col = [c for c in results_df.columns if \"val/box_loss\" in c][0]\n",
    "\n",
    "plt.figure(figsize=(12, 4))\n",
    "\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(results_df[epoch_col], results_df[box_train_col], label=\"train/box_loss\")\n",
    "plt.plot(results_df[epoch_col], results_df[box_val_col], label=\"val/box_loss\")\n",
    "plt.legend()\n",
    "plt.title(\"Потери bbox\")\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(results_df[epoch_col], results_df[map50_col], label=\"mAP@0.50\")\n",
    "plt.plot(results_df[epoch_col], results_df[map5095_col], label=\"mAP@0.50:0.95\")\n",
    "plt.legend()\n",
    "plt.title(\"Качество на валидации\")\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2152cfc6",
   "metadata": {},
   "source": [
    "## 15. Измерение скорости инференса на CPU/GPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "85a25213",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Число изображений для бенчмарка: 50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "YOLOv5 🚀 v7.0-463-g88af13e3 Python-3.12.12 torch-2.10.0+cu128 CPU\n",
      "\n",
      "Fusing layers... \n",
      "YOLOv5n_img640_custom summary: 157 layers, 1760518 parameters, 0 gradients, 4.1 GFLOPs\n",
      "Adding AutoShape... \n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "Benchmark cpu:   0%|          | 0/50 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "Benchmark cpu:   8%|▊         | 4/50 [00:00<00:01, 39.68it/s]/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "Benchmark cpu:  18%|█▊        | 9/50 [00:00<00:01, 40.51it/s]/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "Benchmark cpu:  28%|██▊       | 14/50 [00:00<00:00, 42.27it/s]/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "Benchmark cpu:  40%|████      | 20/50 [00:00<00:00, 46.02it/s]/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "Benchmark cpu:  52%|█████▏    | 26/50 [00:00<00:00, 49.16it/s]/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "Benchmark cpu:  64%|██████▍   | 32/50 [00:00<00:00, 49.73it/s]/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "Benchmark cpu:  76%|███████▌  | 38/50 [00:00<00:00, 51.90it/s]/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "Benchmark cpu:  88%|████████▊ | 44/50 [00:00<00:00, 51.71it/s]/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "Benchmark cpu: 100%|██████████| 50/50 [00:01<00:00, 48.64it/s]\n",
      "YOLOv5 🚀 v7.0-463-g88af13e3 Python-3.12.12 torch-2.10.0+cu128 CUDA:0 (NVIDIA GeForce RTX 3080, 9873MiB)\n",
      "\n",
      "Fusing layers... \n",
      "YOLOv5n_img640_custom summary: 157 layers, 1760518 parameters, 0 gradients, 4.1 GFLOPs\n",
      "Adding AutoShape... \n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "Benchmark cuda:   0%|          | 0/50 [00:00<?, ?it/s]/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "Benchmark cuda:  22%|██▏       | 11/50 [00:00<00:00, 105.62it/s]/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "Benchmark cuda:  52%|█████▏    | 26/50 [00:00<00:00, 129.12it/s]/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "Benchmark cuda:  80%|████████  | 40/50 [00:00<00:00, 133.73it/s]/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "/home/konnilol/Downloads/yolov5/models/common.py:899: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
      "  with amp.autocast(autocast):\n",
      "Benchmark cuda: 100%|██████████| 50/50 [00:00<00:00, 132.18it/s]\n"
     ]
    },
    {
     "data": {
      "application/vnd.positron.dataexplorer+json": {
       "comm_id": "feb98e79-10c6-47d6-90b8-b6e5b9aae05f",
       "shape": {
        "columns": 5,
        "rows": 2
       },
       "source": "pandas",
       "title": "pandas",
       "version": 1
      },
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>device</th>\n",
       "      <th>mean_latency_ms</th>\n",
       "      <th>p95_latency_ms</th>\n",
       "      <th>fps_mean</th>\n",
       "      <th>n_images</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>cpu</td>\n",
       "      <td>20.463707</td>\n",
       "      <td>25.308060</td>\n",
       "      <td>48.867001</td>\n",
       "      <td>50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>cuda</td>\n",
       "      <td>7.530323</td>\n",
       "      <td>8.014856</td>\n",
       "      <td>132.796421</td>\n",
       "      <td>50</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  device  mean_latency_ms  p95_latency_ms    fps_mean  n_images\n",
       "0    cpu        20.463707       25.308060   48.867001        50\n",
       "1   cuda         7.530323        8.014856  132.796421        50"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "best_weights = FINAL_RUN_DIR / \"weights\" / \"best.pt\"\n",
    "if not best_weights.exists():\n",
    "    raise FileNotFoundError(f\"Не найдены веса лучшей модели: {best_weights}\")\n",
    "\n",
    "val_image_paths = sorted([p for p in (dataset_dir / \"images\" / \"val\").iterdir() if p.suffix.lower() in [\".jpg\", \".jpeg\", \".png\", \".bmp\"]])\n",
    "bench_images = val_image_paths[: min(50, len(val_image_paths))]\n",
    "print(\"Число изображений для бенчмарка:\", len(bench_images))\n",
    "\n",
    "def load_local_model(device):\n",
    "    dev = 0 if device == \"cuda\" else \"cpu\"\n",
    "    model = torch.hub.load(\n",
    "        str(Path(\"yolov5\").resolve()),\n",
    "        \"custom\",\n",
    "        path=str(best_weights),\n",
    "        source=\"local\",\n",
    "        device=dev,\n",
    "        force_reload=False\n",
    "    )\n",
    "    model.conf = 0.25\n",
    "    model.iou = 0.45\n",
    "    return model\n",
    "\n",
    "def benchmark(device):\n",
    "    if device == \"cuda\" and not torch.cuda.is_available():\n",
    "        return None\n",
    "\n",
    "    model = load_local_model(device)\n",
    "\n",
    "    # warm-up\n",
    "    for p in bench_images[:5]:\n",
    "        _ = model(str(p), size=BEST_IMG_SIZE)\n",
    "        if device == \"cuda\":\n",
    "            torch.cuda.synchronize()\n",
    "\n",
    "    latencies = []\n",
    "    for p in tqdm(bench_images, desc=f\"Benchmark {device}\"):\n",
    "        t0 = time.perf_counter()\n",
    "        _ = model(str(p), size=BEST_IMG_SIZE)\n",
    "        if device == \"cuda\":\n",
    "            torch.cuda.synchronize()\n",
    "        latencies.append((time.perf_counter() - t0) * 1000.0)\n",
    "\n",
    "    latencies = np.array(latencies, dtype=float)\n",
    "    return {\n",
    "        \"device\": device,\n",
    "        \"mean_latency_ms\": float(latencies.mean()),\n",
    "        \"p95_latency_ms\": float(np.percentile(latencies, 95)),\n",
    "        \"fps_mean\": float(1000.0 / latencies.mean()),\n",
    "        \"n_images\": int(len(latencies)),\n",
    "    }\n",
    "\n",
    "speed_rows = []\n",
    "cpu_stats = benchmark(\"cpu\")\n",
    "if cpu_stats is not None:\n",
    "    speed_rows.append(cpu_stats)\n",
    "\n",
    "gpu_stats = benchmark(\"cuda\")\n",
    "if gpu_stats is not None:\n",
    "    speed_rows.append(gpu_stats)\n",
    "\n",
    "speed_df = pd.DataFrame(speed_rows)\n",
    "speed_df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63c15a7c",
   "metadata": {},
   "source": [
    "## 16. Сохранение метрик"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "8ba2b3fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/konnilol/Downloads/work_hf_yolov5n_car/pilot_imgsz_search.csv\n",
      "/home/konnilol/Downloads/work_hf_yolov5n_car/hf_yolov5n_car_metrics.csv\n",
      "/home/konnilol/Downloads/work_hf_yolov5n_car/hf_yolov5n_car_speed.csv\n"
     ]
    }
   ],
   "source": [
    "pilot_path = WORKDIR / \"pilot_imgsz_search.csv\"\n",
    "summary_path = WORKDIR / \"hf_yolov5n_car_metrics.csv\"\n",
    "speed_path = WORKDIR / \"hf_yolov5n_car_speed.csv\"\n",
    "\n",
    "pilot_df.to_csv(pilot_path, index=False)\n",
    "summary_df.to_csv(summary_path, index=False)\n",
    "speed_df.to_csv(speed_path, index=False)\n",
    "\n",
    "print(pilot_path)\n",
    "print(summary_path)\n",
    "print(speed_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63b78725",
   "metadata": {},
   "source": [
    "Использована модель Hugging Face fcakyon/yolov5n-v7.0, дообученная на датасете car-object-detection.\n",
    "В ходе пилотного подбора лучшим оказался размер входа 640×640: он дал mAP@0.50:0.95 = 0.3248 против 0.2539 при 512×512. Для модели также были подобраны anchors по статистике bbox датасета и уменьшен learning rate до 0.003.\n",
    "\n",
    "После финального обучения получены метрики:\n",
    "\n",
    "Precision = 0.947\n",
    "\n",
    "Recall = 0.940\n",
    "\n",
    "mAP@0.50 = 0.977\n",
    "\n",
    "mAP@0.50:0.95 = 0.623\n",
    "\n",
    "Скорость инференса:\n",
    "\n",
    "CPU: 20.46 ms на изображение, около 48.87 FPS\n",
    "\n",
    "GPU: 7.53 ms на изображение, около 132.80 FPS\n",
    "\n",
    "Вывод:\n",
    "YOLOv5n показала удачный компромисс между точностью и скоростью. Модель остаётся очень быстрой даже на CPU, а на GPU работает в реальном времени с большим запасом. При этом качество детекции высокое по mAP@0.50, хотя по более строгой метрике mAP@0.50:0.95 видно, что локализация ещё не идеальна. В целом выбранную конфигурацию можно считать практичной для быстрых систем детекции автомобилей."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}