From ca11e24e3b0ac41c4a9342104d5b0753d16287dc Mon Sep 17 00:00:00 2001 From: pinb Date: Tue, 12 Sep 2023 07:17:12 +0000 Subject: [PATCH] =?UTF-8?q?=ED=8C=8C=EC=9D=BC=20=EC=97=85=EB=A1=9C?= =?UTF-8?q?=EB=93=9C=20''?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- val_dduk.ipynb | 836 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 836 insertions(+) create mode 100644 val_dduk.ipynb diff --git a/val_dduk.ipynb b/val_dduk.ipynb new file mode 100644 index 0000000..8e8eb4a --- /dev/null +++ b/val_dduk.ipynb @@ -0,0 +1,836 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Class\n", + "\n", + "0: head\n", + "\n", + "1: helmet\n", + "\n", + "2: face\n", + "\n", + "3: mask\n", + "\n", + "4: helmet & mask" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Validation" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import time\n", + "import cv2\n", + "import math\n", + "import numpy as np\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn.functional as F\n", + "from torchvision import transforms\n", + "from sklearn.metrics import accuracy_score\n", + "import yaml\n", + "\n", + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Classfication" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def crop_and_classify(img, boxes, classification_model, transform):\n", + " # classification_model.to(device)\n", + " # classification_model.eval()\n", + " \n", + " for box in boxes:\n", + " x1, y1, x2, y2 = box\n", + " # Expand the bounding box by 10%\n", + " width = x2 - x1\n", + " height = y2 - y1\n", + " x1 = max(int(x1 - 0.1 * width), 0)\n", + " y1 = max(int(y1 - 0.1 * height), 0)\n", + " x2 = min(int(x2 + 0.1 * width), img.shape[1] - 1)\n", + " y2 = min(int(y2 + 0.1 * height), img.shape[0] - 1)\n", + "\n", + " # Crop the image\n", + " cropped_img = img[y1:y2, x1:x2]\n", + "\n", + " # Transform the image to fit the input size of the classification model\n", + " transformed_img = transform(cropped_img)\n", + " transformed_img = transformed_img.unsqueeze(0)\n", + "\n", + " # Classify the cropped image\n", + " with torch.no_grad():\n", + " outputs = classification_model(transformed_img)\n", + " _, predicted = torch.max(outputs.data, 1)\n", + " confidence = torch.nn.functional.softmax(outputs, dim=1)[0][predicted].item()\n", + "\n", + " # Print the classification result\n", + " print(f\"Class: {predicted.item()}, Confidence: {confidence:.2f}\")\n", + "\n", + " # Draw the bounding box and classification result on the image\n", + " cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 2)\n", + " cv2.putText(img, f\"Class: {predicted.item()}, Confidence: {confidence:.2f}\", (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0,255,0), 2)\n", + " return img" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Detection" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def run_detection_model(img, model_detect):\n", + " # img = transforms.ToTensor()(img).unsqueeze(0).to(device) # Convert image to tensor and add batch dimension\n", + " # model_detect.eval() # Set model to evaluation mode\n", + " img = transforms.ToTensor()(img).unsqueeze(0)\n", + " \n", + " # Move the model to the GPU\n", + " model_detect = model_detect.to(device)\n", + "\n", + " # Run inference\n", + " with torch.no_grad():\n", + " detections = model_detect(img)\n", + "\n", + " # Extract bounding boxes and confidence scores\n", + " boxes = detections.pred[0][:, :4].cpu().numpy().tolist()\n", + " scores = detections.pred[0][:, 4].cpu().numpy().tolist()\n", + "\n", + " return boxes, scores\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load detection model" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using cache found in C:\\Users\\pinb/.cache\\torch\\hub\\ultralytics_yolov5_master\n", + "YOLOv5 2023-6-12 Python-3.10.9 torch-1.12.1 CUDA:0 (NVIDIA GeForce RTX 3060, 12288MiB)\n", + "\n", + "Fusing layers... \n", + "Model summary: 157 layers, 7012822 parameters, 0 gradients, 15.8 GFLOPs\n", + "Adding AutoShape... \n" + ] + } + ], + "source": [ + "weights_detect = \"C:/Users/pinb/Desktop/pytorch/yolov5/runs/train/dduk_64_/weights/best.pt\"\n", + "model_detect = torch.hub.load('ultralytics/yolov5', 'custom', path=weights_detect)\n", + "model_detect = model_detect.to(device).eval()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load classification model" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using cache found in C:\\Users\\pinb/.cache\\torch\\hub\\ultralytics_yolov5_master\n", + "YOLOv5 2023-6-12 Python-3.10.9 torch-1.12.1 CUDA:0 (NVIDIA GeForce RTX 3060, 12288MiB)\n", + "\n", + "Fusing layers... \n", + "Model summary: 117 layers, 4173093 parameters, 0 gradients, 10.4 GFLOPs\n", + "WARNING YOLOv5 ClassificationModel is not yet AutoShape compatible. You must pass torch tensors in BCHW to this model, i.e. shape(1,3,224,224).\n" + ] + } + ], + "source": [ + "weights_cls = \"C:/Users/pinb/Desktop/pytorch/yolov5/runs/train-cls/dduk_cls3/weights/best.pt\"\n", + "model_cls = torch.hub.load('ultralytics/yolov5', 'custom', path=weights_cls)\n", + "model_cls = model_cls.to(device).eval()\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load YAML" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# # YAML 파일 경로\n", + "yaml_path = \"C:/Users/pinb/Desktop/pytorch/yolov5/runs/detect/test/data.yaml\"\n", + "\n", + "def read_dataset_paths(file_path):\n", + " with open(file_path, 'r') as file:\n", + " data = yaml.safe_load(file)\n", + " test_path = data.get('test')\n", + " train_path = data.get('train')\n", + " val_path = data.get('val')\n", + " \n", + " return os.path.join(os.path.dirname(file_path), val_path)\n", + "\n", + "# # YAML 파일에서 데이터셋 경로 읽기\n", + "val_path = read_dataset_paths(yaml_path)\n", + "\n", + "# 이미지가 있는 폴더 경로\n", + "folder_path = val_path\n", + "result_path = os.path.join(folder_path, \"result\")\n", + "# folder_path = \"C:/Users/pinb/Desktop/pytorch/yolov5/runs/detect/test/\"\n", + "# result_path = \"C:/Users/pinb/Desktop/pytorch/yolov5/runs/detect/test/result\"\n", + "\n", + "def get_image_and_label_paths(folder_path):\n", + " image_paths = []\n", + " label_paths = []\n", + " for file_name in os.listdir(folder_path):\n", + " if file_name.endswith(\".bmp\") or file_name.endswith(\".jpg\") or file_name.endswith(\".png\"):\n", + " image_path = os.path.join(folder_path, file_name)\n", + " image_paths.append(image_path)\n", + " file_name = os.path.splitext(file_name)[0] + \".txt\"\n", + " label_path = folder_path.replace(\"images\", \"labels\")\n", + " label_path = os.path.join(label_path, file_name)\n", + " if os.path.exists(label_path):\n", + " label_paths.append(label_path)\n", + " else:\n", + " label_paths.append(\"\")\n", + "\n", + " return image_paths, label_paths\n", + "\n", + "# 폴더 내의 이미지 파일 경로들을 가져옴\n", + "image_paths, label_paths = get_image_and_label_paths(folder_path)\n", + "\n", + "if not os.path.exists(result_path):\n", + " os.makedirs(result_path)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Read Label Data" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def read_label(label_path):\n", + " labels = []\n", + " with open(label_path, 'r') as file:\n", + " lines = file.readlines()\n", + " for line in lines:\n", + " label = line.strip().split(' ')\n", + " label_class = int(label[0])\n", + " bounding_box = tuple(map(float, label[1:]))\n", + " labels.append((label_class, bounding_box))\n", + " return labels" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Find closet label class" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def find_closest_label_class(pred_box, labels):\n", + " min_distance = float('inf')\n", + " closest_class = -1\n", + "\n", + " for i, label in enumerate(labels):\n", + " label_box = label[1]\n", + " label_center_x = (label_box[0] + label_box[2]) / 2\n", + " label_center_y = (label_box[1] + label_box[3]) / 2\n", + "\n", + " pred_center_x = (pred_box[0] + pred_box[2]) / 2\n", + " pred_center_y = (pred_box[1] + pred_box[3]) / 2\n", + "\n", + " distance = math.sqrt((label_center_x - pred_center_x) ** 2 + (label_center_y - pred_center_y) ** 2)\n", + "\n", + " if distance < min_distance:\n", + " min_distance = distance\n", + " closest_class = label[0]\n", + "\n", + " return closest_class" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Evaluate" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "lst_result = [[],[],[],[],[]] # class 0~4\n", + "eval_times = []\n", + "\n", + "def Evaluate(model_detect, model_cls, img, img_name, labels, output=True):\n", + " height, width, _ = img.shape\n", + " expand_ratio = 0.5 # The ratio to expand the ROI area\n", + "\n", + " # Inference detection model\n", + " start_time = time.time()\n", + " results = model_detect(img)\n", + "\n", + " # For each detection, crop the ROI and classify it\n", + " for *box, detect_conf, cls in results.xyxy[0]:\n", + " x1, y1, x2, y2 = map(int, box)\n", + " fbox = map(float, box)\n", + "\n", + " # Calculate the width and height of the bounding box\n", + " bbox_width = x2 - x1\n", + " bbox_height = y2 - y1\n", + " roi = (x1, y1, bbox_width, bbox_height)\n", + "\n", + " # Calculate the expanded coordinates\n", + " x1_expanded = max(0, x1 - int(bbox_width * expand_ratio))\n", + " y1_expanded = max(0, y1 - int(bbox_height * expand_ratio))\n", + " x2_expanded = min(width, x2 + int(bbox_width * expand_ratio))\n", + " y2_expanded = min(height, y2 + int(bbox_height * expand_ratio))\n", + "\n", + " roi_flat = (x1_expanded, \n", + " y1_expanded, \n", + " bbox_width + int(bbox_width * expand_ratio) * 2, \n", + " bbox_height + int(bbox_height * expand_ratio) * 2)\n", + "\n", + " # Crop the expanded ROI from the image\n", + " # roi = img[y1:y2, x1:x2]\n", + " roi_expanded = img.copy()\n", + " roi_expanded = roi_expanded[y1_expanded:y2_expanded, x1_expanded:x2_expanded]\n", + " roi_expanded = cv2.resize(roi_expanded, (224, 224))\n", + "\n", + " # Convert numpy array to torch tensor, and normalize pixel values\n", + " roi_expanded = torch.from_numpy(roi_expanded).float().div(255.0)\n", + "\n", + " # Reshape tensor to (channels, height, width)\n", + " roi_expanded = roi_expanded.permute(2, 0, 1)\n", + "\n", + " # Add an extra dimension for the batch\n", + " roi_expanded = roi_expanded.unsqueeze(0)\n", + "\n", + " # Move roi_expanded to the same device as class_model\n", + " roi_expanded = roi_expanded.to(device)\n", + " class_result = model_cls(roi_expanded)\n", + "\n", + " # classfication result\n", + " probabilities = F.softmax(class_result, dim=1)\n", + " max_confidence, max_indices = torch.max(probabilities, dim=1)\n", + " class_pred = max_indices.item()\n", + " class_conf = max_confidence.item()\n", + "\n", + " # confidence\n", + " total_conf = (detect_conf + class_conf) * 0.5\n", + "\n", + " # label - class\n", + " class_gt = find_closest_label_class((x1, y1, x2, y2), labels)\n", + "\n", + " # append (class, confidence, bounding box)\n", + " lst_result[class_pred].append((class_pred, class_gt, total_conf, (x1, y1, x2, y2)))\n", + "\n", + " # Put classification result on each ROI\n", + " thin = 1\n", + " color = ()\n", + " if class_pred == 0: # head\n", + " color = (0, 0, 255)\n", + " elif class_pred == 1: # helmet\n", + " color = (255, 0, 0)\n", + " elif class_pred == 2: # face\n", + " color = (0, 255, 0)\n", + " elif class_pred == 3: # mask\n", + " color = (255, 0, 255)\n", + " elif class_pred == 4: # helmet & mask\n", + " color = (255, 255, 0)\n", + " cv2.putText(img, f'{class_pred}: {total_conf}', (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, thin)\n", + " # cv2.rectangle(img, roi_flat, color, thin)\n", + " cv2.rectangle(img, roi, color, thin)\n", + " if output is True:\n", + " print(f'{img_name}\\'s det + cls result [{class_pred}]: {total_conf}%, {roi}:')\n", + "\n", + " end_time = time.time()\n", + " total_time = end_time - start_time\n", + " eval_times.append(total_time)\n", + " if output is True:\n", + " print(f'Detect + Classfication Time: {total_time}s')\n", + "\n", + " # Save image\n", + " cv2.imwrite(f'{result_path}/{img_name}_rst.jpg', img)\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Compare Ground Truth & Bounding Box" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Class\n", + "# 0: head\n", + "# 1: helmet\n", + "# 2: face\n", + "# 3: mask\n", + "# 4: helmet & mask\n", + "\n", + "def CompareClass(pr, gt):\n", + " if gt == 0: # head or face\n", + " if pr == 0 or pr == 2:\n", + " return True\n", + " else:\n", + " False\n", + " elif gt == 1: # helmet or mask\n", + " if pr == 1 or pr == 3 or pr == 4:\n", + " return True\n", + " else:\n", + " return False" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "def CompareGTandBox(predict, setting_mAP=0):\n", + " # 0: mAP@.5, 1: mAP@.5:.95 0\n", + " # 비교하여 TP와 FP 구분\n", + " results = []\n", + "\n", + " tp_cnt = 0\n", + " fp_cnt = 0\n", + " totalbox_cnt = 0\n", + " targetbox_cnt = len(predict)\n", + "\n", + " for p_class, gt_class, confidence, p_box in predict:\n", + " if CompareClass(p_class, gt_class):\n", + " # iou = calculate_iou(p_box, l_box)\n", + " # iou = confidence\n", + " if setting_mAP == 0: # mAP@.5\n", + " if confidence >= 0.5:\n", + " # True Positive (TP)\n", + " tp_cnt = tp_cnt + 1\n", + " totalbox_cnt = totalbox_cnt +1\n", + " # class, confidence, boudingbox, TP/FP, precision, recall\n", + " results.append((p_class, confidence, p_box, True, tp_cnt/totalbox_cnt, tp_cnt/targetbox_cnt))\n", + " elif setting_mAP == 1: # mAP@.5:.95\n", + " if confidence >= 0.5 and confidence < 0.95:\n", + " # True Positive (TP)\n", + " tp_cnt = tp_cnt + 1\n", + " totalbox_cnt = totalbox_cnt + 1\n", + " # class, confidence, boudingbox, TP/FP, precision, recall\n", + " results.append((p_class, confidence, p_box, True, tp_cnt/totalbox_cnt, tp_cnt/targetbox_cnt))\n", + " else: # all P, R\n", + " tp_cnt = tp_cnt + 1\n", + " totalbox_cnt = totalbox_cnt + 1\n", + " results.append((p_class, confidence, p_box, True, tp_cnt/totalbox_cnt, tp_cnt/targetbox_cnt))\n", + " \n", + " else:\n", + " # False Positive (FP)\n", + " totalbox_cnt = totalbox_cnt + 1\n", + " results.append((p_class, confidence, p_box, False, tp_cnt/totalbox_cnt, tp_cnt/targetbox_cnt))\n", + "\n", + " return results" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Get Precisions, Recalls and PR Curve" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [], + "source": [ + "def GetPR(results):\n", + " results = sorted(results, key=lambda x: x[5], reverse=True)\n", + " # results = sorted(results, key=lambda x: x[1], reverse=True)\n", + " precisions = [item[4] for item in results]\n", + " recalls = [item[5] for item in results]\n", + "\n", + " return precisions, recalls" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Calculate AP" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "def calculate_AP(precisions, recalls):\n", + " assert len(recalls) == len(precisions)\n", + "\n", + " sorted_indices = sorted(range(len(recalls)), key=lambda i: recalls[i])\n", + " sorted_precisions = [precisions[i] for i in sorted_indices]\n", + " sorted_recalls = [recalls[i] for i in sorted_indices]\n", + "\n", + " ap = 0\n", + " for i in range(1, len(sorted_recalls)):\n", + " recall_diff = sorted_recalls[i] - sorted_recalls[i-1]\n", + " ap += recall_diff * (sorted_precisions[i] + sorted_precisions[i-1]) * 0.5\n", + "\n", + " return ap" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Run" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Class 0\n", + "meanP: 0.2451500387154128\n", + "meanR: 0.1266693073789041\n", + "AP@.5: 0.056300405455419165\n", + "AP@.5:.95: 0.056300405455419165\n", + "\n", + "Class 1\n", + "meanP: 0.8831870385742567\n", + "meanR: 0.43243055555555554\n", + "AP@.5: 0.6344911937169155\n", + "AP@.5:.95: 0.6344911937169155\n", + "\n", + "Class 2\n", + "meanP: 0\n", + "meanR: 0\n", + "AP@.5: 0\n", + "AP@.5:.95: 0\n", + "\n", + "Class 3\n", + "meanP: 0.8349450369473351\n", + "meanR: 0.40800165622897366\n", + "AP@.5: 0.591933273620593\n", + "AP@.5:.95: 0.591933273620593\n", + "\n", + "Class 4\n", + "meanP: 0.8888927177286716\n", + "meanR: 0.43473958333333357\n", + "AP@.5: 0.727062010345605\n", + "AP@.5:.95: 0.727062010345605\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAs0AAAGdCAYAAADpKU7rAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAABV3klEQVR4nO3deXjMV///8ddENgmJSCyxNIglUe6WKqU3Yq26aysa6m7FWr1x21pbqaW1tNWFFlW0tFRrrd5FS23daLU/rd4VtIpSVBBZhIjk/P7wzdzGTPLJKhLPx3XNdWXO55zPnPPJ5J33nDlzxmaMMQIAAACQIbeC7gAAAABwqyNpBgAAACyQNAMAAAAWSJoBAAAACyTNAAAAgAWSZgAAAMACSTMAAABggaQZAAAAsEDSDAAAAFggaUa+mzx5smw2m44ePVrQXbmt5eb3UKVKFUVEROR5n24HNptNUVFRDmVcT2utWrXSP/7xj4LuBlBopKamKjw8XAMGDCjorhRZJM3IkeTkZL355ptq1aqVypQpIw8PDwUGBioiIkKvvvqqEhISCrqL2XLo0CFNmjRJTZo0UdmyZVWiRAnVrVtX48aNU2xsbJbPExERIZvNZr+5u7urfPny6tKli3bv3p2PI7g9LFmyxOH62mw2lSxZUvfee6/mzJmj1NTUgu5ivvnmm2/0z3/+U1WrVlXx4sXl6+urO++8U0OHDtXPP/9c0N3LUx999JG2b9+u559/Pt8f68EHH5TNZlOrVq0yrJP+gjP95ubmplKlSqlZs2Zavnx5lh8rJSVFSUlJuerv0aNHnf4G0m9BQUG5Ond+OHnypNzd3WWz2fTee+9lWK9KlSoOY/Hw8FClSpXUq1cvHThwIMuPl5iYmOs4cOPv+/rbU089latzS9LFixc1fvx41ahRQ15eXipTpowiIyP166+/OtXdsWNHhn1p0KCBQ91ixYpp8uTJevvtt/XTTz/lup9w5l7QHUDh88cff6hDhw7at2+fmjVrppEjR6p8+fKKjY3Vl19+qdGjR2vTpk3avHlzQXc1y95++2298cYb6tChg3r06CFPT09t375dM2fO1Pvvv6/vvvtO5cqVy9K53NzctHTpUknXXlz8+OOPWrx4sTZs2KDPP/9czZo1y8+hZGjChAkaO3asvLy8st324MGDstls+dCrnHnyySfVpEkTGWN06tQpLV26VMOGDVN0dLTmz59f0N3LU8YYjRw5Uq+99poqVqyoyMhI1apVS2lpafrll1+0Zs0azZs3T8eOHVOlSpUKurt5YvLkyWrRooXq1auXr49z/Phxbd68WdWrV9f27dv1+++/q1q1ahnWnzhxomrWrKnU1FQdOXJECxcu1D//+U8dP35cY8eOddlm27Ztevvtt7Vt2zadOnVKkuTn56dGjRqpR48eevzxx+Xunv1/xV26dNHDDz/sUObt7Z3t8+S3d955R8YYVa1aVYsWLdJjjz2WYd1y5cpp1qxZkq4llrt379ayZcv0ySefaM+ePapZs6ZTm6SkJC1atEjr1q3Tt99+q0uXLsnNzU0VKlTQgw8+qH79+qlRo0Y56vurr77q9EKkdu3aOTpXusuXLysiIkLff/+9OnXqpBEjRigmJkbz5s1To0aNtGvXLtWqVcup3cCBA9W0aVOHssDAQKd63bt311NPPaXnn39eq1atylVf4YIBsuHy5cumbt26plixYub99993Wef33383EydOtN+fNGmSkWSOHDlyk3qZfXv27DGxsbFO5c8884yRZJ566qksnad58+amWLFiTuUrV640kkz79u0zbZ+QkJClx7ldvfPOO0aSee+99xzKExISTKVKlYybm5uJiYkpoN65Jsn07t3boSwkJMQ0b948S+2nTZtmJJmHH37YJCUlOR2/fPmymTx5svnjjz/yoLfXXLp0yaSkpOTZ+bLjyy+/NJLMkiVL8v2xJk+ebIoVK2b27t1rPDw8zPjx413WS49hX375pUP50aNHTfHixY2fn5/T9Tpz5oxp27atkWSaNWtmZs6cadatW2f+85//mAULFphHHnnEFC9e3NSuXdvs3bs3y30+cuSIkWQmTZqU3eHedGlpaaZatWqmXbt25tVXXzWSzMGDB13WDQkJMaGhoU7lL774opFk/vWvfzkd++yzz0y5cuVMyZIlzeOPP24WLlxoNmzYYFauXGmmT59uGjZsaGw2m4mKijKXLl3Kcr/z83/W7NmzjSQzcOBAh/LDhw+b4sWLm7Zt2zqUb9++3Ugy77zzTpYfY+zYscbd3d2cPHkyL7qM65A0I1vmzp1rJJlRo0ZluY2rAPTnn3+aUaNGmXr16pmAgADj6elpatSoYcaPH++UGKSlpZk5c+aYu+++2/j5+RkfHx8TEhJievToYU6fPm2vt3//ftOjRw9TqVIl4+HhYQIDA03Dhg3N4sWLczzen376yUgyDzzwQJbqZ5Q0JyQkGEmmZs2axhjHQPjmm2+aunXrGi8vL4fkatu2baZdu3amVKlSxtPT04SFhZmZM2eaq1evOp3/999/N/379zd33HGH8fT0NGXLljVt2rQxmzdvttdx9Xs4f/68eeqpp0z16tWNt7e38fPzM+Hh4WbEiBEO588oydu0aZOJiIgwJUuWNN7e3uauu+4yb7zxhklLS3Oo17t3byPJXLhwwQwaNMiULVvWeHp6mvr165vPPvssK5fWGJNx0myMMV27djWSzK5duxzKf/vtN9O7d28THBxsPDw8TMWKFc2TTz7pMrlOSEgwkyZNMnfeeafx9vY2pUqVMg0aNDCvv/66vU58fLyZMGGCadSokQkKCjIeHh4mJCTEDB482Jw7d87pnLlJmmNiYoyPj4+pXLmyuXjxomV9Y/53jbZv3+50LP33cL3mzZubkJAQc/ToURMZGWkCAwONJPPTTz+Z4sWLm9atW7t8nIULFxpJZtmyZfaytLQ089Zbb5l7773X+Pj4GB8fH9O4cWOzbt26LPXdGGOGDBliJLn8/aRft3379pm2bduakiVLmtKlS5t+/fqZxMREk5aWZl588UUTGhpqPD09TXh4uPn4449dPk5qaqoJCQkxDz74oDHGmM6dO5sKFSq4/PvKKGk2xph77rnHSHJIUE6fPm2qVq1qQkNDze7duzMc64kTJ0ynTp1MqVKlzPfff295bYxxTJovXbpkEhMTs9QuK26MS+Hh4cbLy8vUqFHDLF261N7nyMhIU7p0aePj42M6duyYYXL2+eefG0nmww8/NGfOnDEeHh5m9OjRLutmlDT//PPPRpJTMrlixQrj5uZmHn/8cZd/d+k+++wzU6FCBdO6dWuTnJycpetwfayMj483V65cybT+sWPHTHR0tGU9Y4zp1KmTyzhljDFt27Y1NpvN4QXw9b+TixcvZin5T3/heX3cQt5geQayJf3tnkGDBuXqPPv27dOaNWv08MMPq2rVqjLGaMeOHZoxY4b27t2rjRs32utOnz5dEyZM0D/+8Q/1799fHh4eOn78uDZt2qTTp0+rXLlyOnfunFq0aKG0tDQ98cQTqlq1qmJjY7Vv3z598cUX6tu3b476+eeff0qSypYtm6vxHjp0SJJUpkwZh/LZs2fr9OnTGjhwoCpVqqSSJUtKurZcpH///qpXr57Gjh2rUqVK6euvv9a4ceO0d+9effDBB/Zz/L//9//UqlUrJSUlqW/fvrrrrrsUHx+v3bt36/PPP1ebNm0y7NcjjzyiHTt2aMCAAapXr56Sk5P122+/adu2bZZjWrx4sQYMGKAqVaro6aefVokSJbR69WoNGTJEP/30k9566y2nNg888IACAgL0zDPPKCkpSa+99po6dOigX3/9VXfccUeWrmVGDh8+LMnxLcsff/xRERER8vHxUd++fRUSEqJff/1V8+fP19atW/Xdd9/J399fkhQXF6emTZvq559/VqdOndSvXz8VK1ZM//3vf7V27VoNGTJE0rXnxMKFC9WtWzf17NlTXl5e+vbbb7VgwQJ99dVX2rNnjzw8PHI1lnQbNmxQUlKSRowYIR8fnzw5pyuJiYlq2rSpGjRooClTpighIUEVKlRQly5d9MEHH+jEiRNOSz+WLl0qPz8/hyUCffr00bvvvqtOnTqpV69ekqS1a9eqS5cumj9/fpbixvbt21W9evUM1+f++eefatWqlbp162b/rMDixYt16dIlBQQE6KuvvtITTzyhYsWKafbs2eratasOHTqkKlWqOJxn8+bNOnbsmF566SV73z/66CNt3LhRHTp0yNJ1S05O1h9//CF3d3eVKlXKXt6jRw+VLFlSO3fudChPTEyUj4+P3NzclJSUpBIlSmjt2rWKiopSZGSk9u/fL09Pzyw99ssvv6ypU6fKGKPg4GD17NlTU6ZMUYkSJbLUPjNz587V2bNnNWDAAJUsWVKLFi1S79695eHhoXHjxqlp06Z6/vnndeDAAc2dO1ePP/64tmzZ4nSehQsXKiAgQJ06dZKXl5ceeughLV26VNOmTcvykhRXsfPAgQOKiorSM888o6lTp9rLU1NTdenSJfs1iI2NVfPmzfXNN9+ocePGeu655/Tcc89l+Tqkx1I3NzfVq1dPo0eP1iOPPOJU7/HHH9fOnTt15MgRp+fZjS5fvixJLv+efXx8ZIzRt99+q8qVKzscGzZsmPr06SPp2vrvfv36acyYMS5jTYMGDexLDNPjFvJIASftKGRKly5tSpYsma02rmY4k5KSnGYjjfnfcojvvvvOXlavXj0THh6e6WOsX7/ePqORV65evWqaNGliJJmtW7dmqU36THNMTIyJiYkxJ06cMBs2bDBhYWFGknnzzTeNMf+bPShVqpQ5deqUwzlOnTplvL29TefOnZ2u0axZs4wks2PHDmPMtZm9OnXqGHd3d7Nnzx6n/qSmptp/vvH3cOHCBWOz2cyTTz5pOa4bZ0YvXLhgSpQoYSpWrOgwy5OSkmLatGnjNCuXPsN541uSu3btMpLMuHHjLPtgzP9mUefPn29iYmLMmTNnzE8//WQGDhxoJJn77rvPof7dd99tqlat6jQTtXv3blOsWDEzefJke9ngwYONJPPaa685Pe711zE5OdnljFL6zOvKlSsdypWLmeaRI0caSWbNmjWWddPlZKZZkhkzZoxT/c2bNxtJZtq0aQ7lv/32m5FkBgwYYC9bt26dkWReeeUVp/N06NDB+Pn5mfj4+Ez7npqaatzc3Ey7du1cHg8JCTGSzIoVKxzKu3TpYmw2m7n77rsdZhP37t1rJJmxY8c6natr166mdOnS5vLly8aYa8/dcuXKmY4dOzrVTf/b+eSTT0xMTIw5ffq02b17t3nooYeMJNOjRw973fXr1xsPDw+HZQgff/yxqVatmpFkfHx8zJAhQ8y4cePsz4HExEQTFBTk8h2UGx07dsy0aNHCzJ4926xfv968/fbbpmPHjkaSqV+/fpbfkXAlPS6VL1/enD9/3l7+119/GS8vL2Oz2cwLL7zg0GbYsGFGkjlw4IBD+dmzZ42Xl5cZPHiww3WQZNauXev02CEhIaZq1ar22Hns2DHz4YcfmgoVKhhJ5tNPP7XX7dKli4mIiLDHxytXrpjhw4cbX19fI8lUrVrVrFu3zoSEhNiXNXzwwQemZMmSWbo+r776qunfv7955513zMcff2xefvll+3NvxowZTvXT/4ayspxjxIgRRpJ59dVXHcovXrxogoODjSTz8ssv28u/+uor89BDD5l58+aZjz/+2CxYsMA0bdrUvtzv+th0vdDQUFO9enXL/iB7SJqRLe7u7qZixYrZamO1PuzKlSvm3LlzJiYmxuzYscPpbaWWLVuakiVL2hNFV7744gsjyTz++OMu1ybnRHoS9cQTT2S5TXrwvPEWEBBgZs6caa+X/s9p2LBhTud4/fXXHf5BX387cOCAQ5KZnhRERUVZ9u3G38OVK1eMt7e3qVevnjl8+HCmbW9M8tLXaF8/pnQ7d+40kszw4cPtZenJ2qFDh5zqlyhRwnTt2tWy/8b8LyF0devWrZv566+/7HXT39YdN26c03WMiYkxtWrVMo0bNzbGXEvWAgICTLVq1TL8J+RKSkqKiY2NNTExMebw4cMuly7lJmnu37+/kWS2bNmS5T7lNGm+PklKl5qaaipXrmxfVpRu4sSJRpL5+uuv7WVdu3Y1xYsXN3/++afTtV68eLGRZLkU58yZM0aS6dWrl8vjISEhpkKFCk7lr7zyipFk3nrrLadjfn5+Ts+v9KUCQ4YMcSgfNWqUy7Wg6X87N948PT1N7969HT6L0K1bN/PII4/Y70dHRxtPT08TERFhVqxYYd5//30TERFhfH19HZ4DvXv3Nv/85z8zvjgWRo8ebSQ5JbXZkR6XXK3t/tvf/mbc3NyclgesXbvWSDL/+c9/HMrT1zBfv+wk/YWJq892pCelN96Cg4Md1rfHxsYaDw8Ps3HjRnvZxIkTjYeHh3n66afNRx99ZF555RVTvnx54+XlZU+aL1++bLy8vMznn3+eo2sTHx9vQkNDjYeHhzl+/HiOzmGMMYcOHTI+Pj6mZMmS5q233jK///67+e6778yDDz5oPDw8jCTz3HPPZXqOtLQ0ExkZmelEUcOGDY2fn1+O+wnX2HIO2eLn55cn28mlpqbqhRdeUHh4uLy9vRUYGKgyZcrY9649f/68ve7MmTNVsmRJRUREqHz58urevbvefPNNxcXF2es0bdpUAwYM0LvvvqsyZcqoUaNGGjVqlHbt2pWj/k2YMEFz587Vww8/rDfeeCNbbd3c3LRlyxZt2bJF27dv188//6wzZ85ozJgxTnVdfRo8OjpakvTQQw+pTJkyDrewsDBJ0l9//SXpf29d5mSXAQ8PD73xxhuKjo5WaGioatWqpf79+2vt2rWWWzb9/vvvkqQ777zT6VjdunUl/W+5xPVc7UwQGBioc+fO2e/HxMTo9OnTDrcbjR07Vlu2bNGGDRs0Y8YM+fv766+//nLYPSD9Os6YMcPpOpYpU0YHDx60X8ezZ88qNjZWd911l9zcrMPiwoULVa9ePRUvXlwBAQEqU6aMQkNDJTk+d3PLz89PkhQfH59n53SlTJkyCggIcCp3c3PTY489pkOHDtm3TDTG6L333lPNmjXVpEkTe93o6GhdunRJFStWdLrW/fr1k/S/560VY0yGx1w9h9L7ntGx659f0rWtC1NSUtSsWTP99ttv9luzZs109epVLVmyxOVjv/rqq9qyZYu2bt2qPXv26Ny5c1qyZInDkojdu3frgQcesN+fN2+eKlSooE8//VQ9evRQz5499emnnzot1QoODs7y9XFl4sSJstls2rBhQ47PkS6j61ihQgWnHTrSr/2N13jRokWqUqWK/P397df36NGjeuCBB/TZZ5/pxIkTTo9RoUIFe+zcsWOHDhw4oBMnTqh37972Oj/88INSU1PVunVre9ns2bP11FNP6cUXX7TvSLFkyRIlJyfb63h5eSkgICDH17hkyZIaMWKEUlJSXC5FyaoaNWpo48aNKl++vAYOHKhq1aqpYcOGSkpKsu/Akv53nxGbzaaJEydKUoa/b2PMLbXjUVHBmmZkS926dbVz50799ttvql69eo7PM2rUKM2ePVvdunXTmDFjVLZsWXl6eurPP/9UVFSU0tLS7HXvvfde/frrr/YkdOfOnVq9erWeffZZffnll/bted566y2NHDlSmzZt0ldffaXFixfrlVde0dChQzVnzpws923y5MmaNm2afT1ndreDstlsDgE9M67WtaWPfdGiRQoJCXHZrkKFCpIyTy6yol+/furQoYM2btyoL774Qlu2bNHixYvVsGFD7dy5M8MtrNIf11VQzixQFytWLNPzSdd+38eOHcvwuHQtWU+/xu3bt9d9992nFi1aaPDgwfa9YNOv49ChQ9WxY0eXj1u8eHGX58/Ma6+9phEjRqhVq1b2hMjLy0upqalq166dw3M3t9JfgPy///f/nLYXy0hm1//q1asuyzNbLx0VFaXp06dryZIluu+++7Rjxw4dPXpU06dPd6iXlpYmf39/rV69OsNzuXqRdb3AwEC5ubll+sIjo+dQZsdu/P0uXrxYklyuT00/PnbsWKdr2aBBA/3973/P8PEl6cyZM6pYsaL9/uHDh3Xvvfc6bPXo5eWlBg0aKCYmxl527Ngxp0Q6O0qUKKHAwECHc+ZURtcxs2t//TXetWuXfvnlF0nXkkRX3nnnHXvil6548eKWsfPMmTMqW7asfS1vTEyM4uPjnX4vN96/fPmyzpw5k6trnL5eObfXuHnz5jp48KAOHjxof76EhoZq9OjRkqTw8PBc9+XcuXO5/iwOnJE0I1seeeQR7dy5U2+99ZZefPHFHJ/n3XffVdOmTZ32kdy0aZPL+j4+PurUqZM6deokSfrkk0/UoUMHvfjii/Z/gJIUFhamsLAwjRgxQklJSWrXrp1ef/11Pf30004frHBlypQpmjJlirp27ZqjhDkvpM8+BwQEWP4DSX/BsHfv3hw/XtmyZRUVFaWoqCgZYzR69GjNmjVLq1atynBP1fQXTP/973+dvrUt/Ys20mdes2v58uW6dOlSttpEREQoMjJSy5Yt07/+9S81btzYYRbf6jqmz7T+9NNPSktLy3S2+d1331WVKlW0efNmh3rpM9t56aGHHpKPj4/ee+89PfPMM/YkPzOlS5eW5HrGO/0dguyoUaOGmjRpog8//FCzZ8/W0qVL5ebmpscff9yhXs2aNXXgwAHVq1fP5f6xWeHm5qbw8HCXX/KQV7788ksdPHhQAwcOdPkh2S+//FJz5szRjh071KJFi2yf39/fXxcuXLDfr1Chgr777juHOsYYHTp0yD5Le/LkSa1fv14LFizI9uOli42N1dmzZ+0vtArSokWL5ObmpnfffdflvvDPPfec3n77bU2YMCHbs6H+/v4O7zKWLl1aXl5eOnDggNq3b28vP3jwoEO7BQsWqESJEg7vjmRX+vOyfPnyOT5HOpvNZv9/lW7Tpk3y9/fX/fffn6u+XL58WSdOnNBDDz2U637CEcszkC19+/bVnXfeqVdeeUUrV650Wefo0aOaNGlSpudxNWORkpKiGTNmOJW7eiV9zz33SPpfYnD+/HmnGT4fHx/7K/asvGU+depUTZ48WY888kiBJczStRcm3t7emjx5shITE52OX7p0yb5E5q677lKdOnW0bNkyff/99051M5v1TEpKcvp2MpvNpvr160vK/Jq1adNGJUqU0Ny5cx2+MTE1NVXTpk2TJHXt2jWTUWbs/vvvV+vWrR1uWTFp0iS5ubnpmWeekSTdfffd+tvf/qbFixe7TGiNMfbnlpubmx599FH9/vvvev31153qXn8d05+715cZYxw+xZ9XgoKCNG7cOP3xxx/q3bu3/ZP317ty5YqmTp2q48ePS/rfC6nPP//cod6XX36Z42+ljIqK0oULF/T+++9rzZo1atOmjcNsqiT7W+ijR492OXOf1bfFIyIidPjwYZ09ezZHfbWycOFCSdK4cePUrVs3p9v48ePl5uamRYsW5ej8derU0VdffWW//+ijj2rfvn0aPHiwDhw4oIMHD2rIkCH6+eeflZycrPXr16t58+aqX7++evbs6XCuAwcOOC1zcnUdjTH2t/YzelflZklISNCHH36oZs2aqVevXi6v8WOPPaajR486PUezok6dOrp06ZJ++OEHSdf+HiMjI/Xcc8/p/fff1x9//KGdO3cqKipKNptNf/75p6ZNm2ZfvuHr62s/V1xcnA4cOODwXLt69arTUhPp2v+hWbNmydvb2+nF1h9//KEDBw4oJSUlS+WuzJkzR//97381cuRIh3d+XP2+r169ao9zrn7fP/zwg65cuZKjF33IHDPNyBZvb2998skneuihhxQZGan58+erXbt2KleunGJjY/XNN99o/fr1atmyZabn6d69u+bPn69u3bqpbdu2On/+vJYtW+bybeLw8HA1atRIjRo1UsWKFe3rCG02m/0f9bvvvqtXXnlFnTt3VvXq1VW8eHF9//33WrRoke655x7L2Ze5c+dq0qRJqly5stq3b++wpZt07a3Pzp07Z+9i5VDFihW1YMEC9e3bV7Vq1VLv3r1VrVo1nT9/XtHR0Vq3bp0++ugj+1d2L1myRC1bttT9999v33Lu4sWL+vbbb1W1alW98MILLh/n0KFDatasmTp37qw6deooKChIhw8f1ptvvil/f3916dIlwz76+/vrtdde04ABA9SgQQP17dtXvr6+Wr16tb7++msNGDDA8m3svBYeHm5/wbNt2za1bNlS7733nlq2bKn69eurT58+qlOnjlJSUnTkyBF99NFHioqK0uTJkyVJzz//vHbs2KHhw4dr+/btioiIkIeHh3755RcdPHhQW7dulXTtuTtmzBg98MAD6tatm5KSkrR27VpduXIlX8b1zDPP6K+//tIbb7yhXbt2qUePHqpZs6bS0tIUHR2tNWvW6OTJk/Z1wzVr1tQDDzygN998U6mpqbrnnnsUHR2tpUuX6m9/+1uOvl43MjJSw4YN0/Dhw5WYmKioqCinOg8//LAGDBighQsXat++fercubPKlSunkydP6vvvv9emTZuylDxERkZq7ty52rBhg8Na1rwQFxen1atX6957781wa7By5cqpWbNmWrt2rWJjY12u9c5M165dNXHiRE2ePFmBgYFq0aKFnn/+eU2ZMkXz5s2TJDVu3Fj/+te/NHfuXD366KPq16+fZsyY4TSZEB4erpCQEB09etReNmjQIP31119q1aqVKleurNjYWK1fv167du3S3//+dz355JMO51iyZIn69OmjSZMm2Z/r+WnFihW6ePGiunfvnmGdbt266emnn9aiRYsy3RLTlTvuuEMNGjTQ7Nmz9e6770qSXnnlFR05csS+zWGxYsU0ceJExcfHa8KECQoNDdWyZcsUGRnpcK5169Y5XZvExERVqlRJXbt2Vd26dVW6dGn99ttvWrx4sc6fP6/XX39dwcHBDufJaMu5jMqbNWumevXqKTw8XGlpafrss8/08ccfq2PHjho/frzDuR988EEFBQXp/vvvV8WKFXX69Gl98MEH+uWXX/TII4/Y33293ieffCJ3d/csL+lCNtz8zx6iKLh06ZKZO3euiYiIMKVLlzbu7u6mdOnSJiIiwsyZM8dhw/2MtpwbM2aMCQkJMZ6enqZKlSpm3LhxJjo62r5xf7oZM2aY5s2bm7JlyxoPDw8THBxsHnzwQYdPQe/du9dERUWZGjVqGF9fX+Pr62vCw8PNhAkTsrSbRvquAhndQkJCsnRdMvpykxtl5Vuedu/ebbp162bKlStnPDw8TLly5Uzjxo3Nc88957SF2q+//urwBR7lypUzDzzwgMM1uvH3cPbsWTNixAj7F8x4eXmZKlWqmD59+jh9a1dGuz1s3LjRNG/e3JQoUcJ4eXmZv/3tb+b111/P8MtNXMnOt+Nl9uUmxhjzyy+/GDc3N9OkSRN72fHjx83gwYNNtWrVjKenpylVqpSpW7euGTZsmPnll18c2sfFxZnx48ebmjVr2us2bNjQzJs3z14nNTXVvPDCC6ZGjRrGy8vLVKhQwTz55JPm/PnzLnfKcFWWnTGn++KLL8yjjz5q7rjjDuPl5WWKFy9u7rzzTjNs2DCzf/9+h7p//fWX6dGjh/H39zc+Pj6mWbNm5ptvvsn0y02s9OrVy75NYmZfsLBixQoTERFh/P39jaenp6lcubJ58MEHzfz587M81r/97W+mRYsWTuUZXbfMdgy5vk36lzNZ7TCRXm/OnDnGmMy/3ORGly5dMlWqVDGdO3d22IklJibGfPHFF/bf1ZEjR8zevXsz/cINV7Fn8eLFJiIiwpQvX954eHgYX19fc88995iXXnrJ5bnmzJmT4c4iN8osLmX0PLmxzb333mvc3NycttK80b333ms8PT3tX2KT0ZebuPLpp58am81mVq9e7VC+f/9+88UXX5gzZ84YY65902tmOwOlP2+u/39z+fJl069fP1O3bl1TqlQp4+7ubsqUKWM6dOhgtm3b5vI8GW05l1H56NGjTVhYmPHx8TG+vr6mYcOGZsGCBS537pk5c6Zp0qSJKVOmjHF3dzd+fn7m/vvvNwsXLnS5bWv6jjdZ3ZEI2WMzJpefJAIAIA+tW7dOXbt21ffff29fLlSY7NmzRxEREWrbtq3eeecdhy84ud7Zs2f17bffOn0uIC917txZv/zyi/bv359nX7pzKxg9erTmzJmjOXPmaODAgRnW27lzp+644w5VrVr1Jvau4Hz44Yd69NFH9cMPP+juu+8u6O4UOSTNAIBbTqtWreTt7Z0nW6gVhN27d6tbt266ePGi+vfvrwceeEBVq1ZVsWLFdPjwYW3cuFGLFy9WlSpV9O2337r8wFxupaSkKDAwUO+8806OP2NwqzLG6LnnntOUKVN01113qU+fPmrSpInKli2rxMRE7d27V8uXL9emTZs0ffp0+5rvoiwtLU133nmn7r///hyvyUfmSJoBAMgHcXFxeu2117RkyRKHdcnStfXKgwYN0hNPPJEvCfPt4scff9T06dO1adMmhw9Oe3p6qk2bNhozZoyaNm1agD1EUULSDABAPjt+/Lj+/PNPpaWlqUqVKva91pE3UlJS9Ouvv+rs2bMqWbKkatas6bBTBpAXSJoBAAAAC+zTDAAAAFggaQYAAAAskDQDAAAAFkiaAQAAAAskzQAAAIAFkmYAAADAAkkzAAAAYIGkGQAAALBA0gwAAABYIGkGAAAALJA0AwAAABZImgEAAAALJM0AAACABZJmAAAAwAJJMwAAAGCBpBkAAACwQNIMAAAAWCBpBgAAACyQNAMAAAAWSJoBAAAAC+4F3YGiKi0tTSdPnlTJkiVls9kKujsAiiBjjBISElShQgW5uRW9ORDiKID8lp04StKcT06ePKnKlSsXdDcA3AaOHz+uSpUqFXQ38hxxFMDNkpU4StKcT0qWLCnp2i/Bz8+vgHsDoCiKj49X5cqV7fGmqCGOAshv2YmjJM35JP2tRD8/P4I9gHxVVJcuEEcB3CxZiaNFbxEcAAAAkMdImgEAAAALJM0AAACABZJmAAAAwAJJMwAAAGCBpBkAAACwQNIMAAAAWCBpBgAAACyQNAMAAAAWSJoBAAAACyTNAAAAgAWSZgAAAMACSTMAAABggaQZAAAAsEDSDAAAAFggaQYAAAAskDQDAAAAFkiaAQAAAAskzQAAAIAFkmYAAADAAkkzAAAAYIGkGQAAALBA0gwAAABYIGkGAAAALJA0AwAAABZImgEAAAALJM0AAACABZJmAAAAwAJJMwAAAGCBpBkAAACwQNIMAAAAWCBpBgAAACyQNAMAAAAWCmXSfOjQIbVr106+vr4qW7ashg0bpkuXLmWp7dKlSxUWFiZvb2/VqVNHq1atyrT+sGHDZLPZNGTIkLzoOgDcEoijAJA9hS5pvnDhglq2bKmEhAStWbNGs2bN0vLlyzVgwADLtqtXr1ZUVJS6dOmiTZs2qVWrVoqMjNTmzZtd1v/555/19ttvy8/PL6+HAQAFhjgKADlgCpmZM2caHx8fExMTYy9bvny5kWT279+faduwsDDTvXt3h7K2bduaRo0auazfrFkz8+yzz5qQkBAzePDgbPUzLi7OSDJxcXHZagcAWZXTOEMcBYBrshNnCt1M88aNG9W6dWsFBQXZy7p27SovLy9t3Lgxw3ZHjhzRgQMH1LNnT4fyRx99VN99953Onj3rUL58+XIdOXJEY8aMydsBAEABI44CQPYVuqQ5Ojpa4eHhDmVeXl4KDQ1VdHR0pu0kObWtXbu2jDE6cOCAvSwhIUFPP/20XnrpJfn4+ORh7wGg4BFHASD73Au6A9kVGxurUqVKOZUHBATo/PnzmbaT5NQ2ICBAkhzaTp48WdWrV1dkZGSW+5WcnKzk5GT7/fj4+Cy3BYCbiTgKANlX6JJmSbLZbE5lxhiX5VZtjTEO5fv379fcuXO1e/fubPVpxowZmjJlSrbaAEBBIY4CQPYUuuUZAQEB9tmO6124cME+25FRO0lObS9cuOBwfOTIkerevbuqVKmiCxcu6MKFC0pLS9OVK1fsP7sybtw4xcXF2W/Hjx/PyfAAIN8RRwEg+wpd0hweHu605i45OVmHDx92Wmd3YztJTm33798vm82msLAwSdKBAwe0bNkyBQQE2G/Hjx/XwoULFRAQoEOHDrk8v5eXl/z8/BxuAHArIo4CQPYVuuUZ7du313PPPadz584pMDBQkrRu3TolJyerffv2GbarWrWqwsLC9OGHH6pLly728hUrVqhhw4b2T5F/8MEHunz5skPbHj16qHHjxho2bJjuuOOOfBgVANw8xFEAyL5ClzQ/8cQTev3119WpUydNnDhRZ86c0ciRI9WrVy+HGZJ+/fpp6dKlunr1qr1s6tSpioyMVGhoqNq0aaP169dr8+bN+vTTT+117rvvPqfH9Pb2VsWKFRUREZGvYwOAm4E4CgDZV+iS5lKlSmnbtm0aOnSoHn74Yfn4+Khnz5564YUXHOqlpqYqNTXVoax79+5KSkrS9OnTNWvWLFWvXl0ffvih2rZtezOHAAAFijgKANlnM+kfe0aeio+Pl7+/v+Li4liXByBfFPU4U9THB6DgZSfOFLoPAgIAAAA3G0kzAAAAYIGkGQAAALBA0gwAAABYIGkGAAAALJA0AwAAABZImgEAAAALJM0AAACABZJmAAAAwAJJMwAAAGCBpBkAAACwQNIMAAAAWCBpBgAAACyQNAMAAAAWSJoBAAAACyTNAAAAgAWSZgAAAMACSTMAAABggaQZAAAAsEDSDAAAAFggaQYAAAAskDQDAAAAFkiaAQAAAAskzQAAAIAFkmYAAADAAkkzAAAAYIGkGQAAALBA0gwAAABYIGkGAAAALJA0AwAAABZImgEAAAALJM0AAACABZJmAAAAwAJJMwAAAGCBpBkAAACwQNIMAAAAWCBpBgAAACyQNAMAAAAWSJoBAAAACyTNAAAAgAWSZgAAAMACSTMAAABggaQZAAAAsFAok+ZDhw6pXbt28vX1VdmyZTVs2DBdunQpS22XLl2qsLAweXt7q06dOlq1apXTuYcOHaratWvL19dXISEh6tevn06fPp0fQwGAAkEcBYDsKXRJ84ULF9SyZUslJCRozZo1mjVrlpYvX64BAwZYtl29erWioqLUpUsXbdq0Sa1atVJkZKQ2b95sr7N582bt3LlTAwcO1IYNGzRt2jTt3LlTjRs3VmJiYn4ODQBuCuIoAOSAKWRmzpxpfHx8TExMjL1s+fLlRpLZv39/pm3DwsJM9+7dHcratm1rGjVqZL8fExNj0tLSHOr89NNPRpJZsmRJlvsZFxdnJJm4uLgstwGA7MhpnCGOAsA12YkzhW6meePGjWrdurWCgoLsZV27dpWXl5c2btyYYbsjR47owIED6tmzp0P5o48+qu+++05nz56VJAUFBclmsznUqVu3rooVK6aTJ0/m4UgAoGAQRwEg+wpd0hwdHa3w8HCHMi8vL4WGhio6OjrTdpKc2tauXVvGGB04cCDDtrt27VJqaqpTWwAojIijAJB97gXdgeyKjY1VqVKlnMoDAgJ0/vz5TNtJcmobEBAgSRm2TUlJ0fDhw1WrVi099NBDGZ4/OTlZycnJ9vvx8fEZ1gWAgkQcBYDsK3QzzZKc3vaTJGOMy3KrtsaYDM8pSUOGDNF///tfLVu2TO7uGb/GmDFjhvz9/e23ypUrW/YFAAoKcRQAsqfQJc0BAQH22Y7rXbhwwT7bkVE7SU5tL1y44HD8elOmTNHixYv1wQcfqEGDBpn2a9y4cYqLi7Pfjh8/bjUUACgQxFEAyL5ClzSHh4c7rblLTk7W4cOHM10rl37sxrb79++XzWZTWFiYQ/m8efM0efJkzZs3Tx07drTsl5eXl/z8/BxuAHArIo4CQPYVuqS5ffv22rp1q86dO2cvW7dunZKTk9W+ffsM21WtWlVhYWH68MMPHcpXrFihhg0bOnyK/IMPPtDQoUM1depUDRw4MO8HAQAFiDgKANlX6D4I+MQTT+j1119Xp06dNHHiRJ05c0YjR45Ur169HGZI+vXrp6VLl+rq1av2sqlTpyoyMlKhoaFq06aN1q9fr82bN+vTTz+119m5c6cef/xxNW3aVG3atNHu3bvtx8qUKaPQ0NCbM1AAyCfEUQDIgXzdMTqfHDx40LRt29b4+PiYoKAgM3ToUJOUlORQp3fv3sbV8JYsWWJq1qxpPD09Te3atc3KlSsdjk+aNMlIcnnr3bt3lvvIpvwA8ltu4gxxFACyF2dsxvzfx56Rp+Lj4+Xv76+4uDjW5QHIF0U9zhT18QEoeNmJM4VuTTMAAABws5E0AwAAABZImgEAAAALJM0AAACABZJmAAAAwAJJMwAAAGCBpBkAAACwQNIMAAAAWCBpBgAAACyQNAMAAAAWSJoBAAAACyTNAAAAgAWSZgAAAMACSTMAAABggaQZAAAAsEDSDAAAAFggaQYAAAAskDQDAAAAFtxz0zg2NlabNm3SiRMndPnyZYdjNptNEydOzFXnAKCoI44CQOGQ46R58+bN6tatmxITE+Xp6SkPDw+H4wR7AMgccRQACo8cL88YNWqU7rnnHv3666+6fPmyEhISHG7x8fF52U8AKHKIowBQeOR4pvn333/XK6+8otDQ0LzsDwDcNoijAFB45HimuX79+jp+/Hhe9gUAbivEUQAoPHKcNM+bN09z5szRZ599pqtXr+ZlnwDgtkAcBYDCI8fLM5o0aaKUlBS1b99ebm5uKl68uMNxm82muLi4XHcQAIoq4igAFB45TppHjRolm82Wl30BgNsKcRQACg+bMcYUdCeKovj4ePn7+ysuLk5+fn4F3R0ARVBRjzNFfXwACl524kyuvtxEkpKSkrR3716dP39epUuXVv369Z3eYgQAZIw4CgC3vlx9jfa0adNUvnx5NWvWTJ06dVLTpk1Vrlw5TZ8+Pa/6BwBFGnEUAAqHHM80z549WxMnTtTAgQPVs2dPlS9fXqdPn9YHH3ygZ599ViVKlNC///3vvOwrABQpxFEAKDxyvKa5Zs2a6tKli1544QWnY2PGjNG6det06NChXHewsGItHgAruY2jRT3OFPXxASh42YkzOV6e8ccff6hNmzYuj7Vu3Vp//PFHTk8NALcF4igAFB45TporVKigr776yuWxr7/+WhUqVMhxpwDgdkAcBYDCI8drmvv3769JkyYpOTlZjzzyiMqXL6+//vpLK1eu1KxZszRlypS87CcAFDnEUQAoPHK8ptkYo6eeekpvvPGGw9e/uru769///rdeeumlPOtkYcRaPABWchtHi3qcKerjA1DwshNncv3lJufOndO3336r2NhYlS5dWg0bNlRgYGBuTlkkEOwBZFVO42hRjzNFfXwACt5N/XKTwMBAtW/fPrenAYDbFnEUAG592Uqa165dq5YtW6pUqVJau3atZf2HH344xx0DgKKIOAoAhVO2lme4ublp9+7datiwodzcMt94w2azKTU1NdcdLKx4WxGAK3kZR4t6nCnq4wNQ8PJtecaRI0cUHBxs/xkAkD3EUQAonLKVNIeEhLj8GQCQNcRRACiccvxBwISEBCUnJysoKMhetnz5ckVHR6tVq1Zq0aJFnnQQAIoq4igAFB45/kbAf/7zn5o4caL9/tSpU/XYY4/pzTffVOvWrbVy5co86SAAFFXEUQAoPHKcNO/Zs0dt27aVdG2D/rlz52r8+PE6e/ashg0blq9fbnLo0CG1a9dOvr6+Klu2rIYNG6ZLly5lqe3SpUsVFhYmb29v1alTR6tWrXKqk5KSonHjxik4OFg+Pj5q0aKF9u3bl9fDAHCbI44CQOGR46T5/Pnz9rcUf/jhB509e1Z9+/aVJHXs2FEHDx7Mmx7e4MKFC2rZsqUSEhK0Zs0azZo1S8uXL9eAAQMs265evVpRUVHq0qWLNm3apFatWikyMlKbN292qDdixAjNnTtXU6dO1fr16+Xu7q5WrVrp9OnT+TImALcn4igAFCImh0JCQsybb75pjDFm8uTJplq1avZjn3zyiQkICMjpqTM1c+ZM4+PjY2JiYuxly5cvN5LM/v37M20bFhZmunfv7lDWtm1b06hRI/v9EydOmGLFipm5c+fay+Lj401gYKAZM2ZMlvsZFxdnJJm4uLgstwFwe8ltHM1pnCGOAsA12YkzOZ5p7t69u0aPHq3u3bvrxRdfVO/eve3H9u7dqxo1auQynXdt48aNat26tcMHZ7p27SovLy9t3Lgxw3ZHjhzRgQMH1LNnT4fyRx99VN99953Onj0rSdq8ebNSU1PVo0cPe52SJUuqQ4cO2rBhQx6PBsDtjDgKAIVHjpPmGTNmaNSoUbp8+bKeeuopjRs3zn7shx9+0COPPJInHbxRdHS0wsPDHcq8vLwUGhqq6OjoTNtJcmpbu3ZtGWN04MABe71y5cqpdOnSTvUOHjyotLS0vBgGABBHAaAQyfGWc+7u7nr22WddHlu3bl2OO2QlNjZWpUqVcioPCAjQ+fPnM20nyaltQECAJNnbZnb+lJQUJSYmuvzGmOTkZCUnJ9vvx8fHWw0FwG2OOOqIOArgVpbjmeaCZLPZnMqMMS7Lrdqa//sW8evLMzp/RsekazNG/v7+9lvlypUt+wIABYU4CgDZk62k2c/PTz/88IOka+vT/Pz8Mr3lh4CAAPtsx/UuXLhgn+3IqJ0kp7YXLlxwOJ7Z+T08POTr6+vy/OPGjVNcXJz9dvz48SyNB8DthThKHAVQOGVrecaoUaMUHBxs/zkrMxJ5LTw83GnNXXJysg4fPmzfqimjdtK1tXZhYWH28v3798tms9nLwsPDdebMGZ0/f95hPd7+/ftVq1Ytubm5fp3h5eUlLy+vHI8LwO2BOEocBVBI5eMuHvli5syZxtfX15w9e9ZetmLFiixvlRQZGelQ9sADD7jcKmn+/Pn2soSEBLZKAnDLyc2Wc8RRAMhenCl0SXNsbKypWLGiuf/++82nn35q3n33XRMUFGR69erlUK9v376mWLFiDmUrV640NpvNjB8/3mzfvt0MHz7c2Gw289lnnznUGzx4sPHz8zMLFy40mzdvNm3btjWBgYHm1KlTWe4nwR5AfstpnCGOAsA1NyVp7tu3r9MG9+l69OhhBgwYkNNTWzp48KBp27at8fHxMUFBQWbo0KEmKSnJoU7v3r2Nq4n0JUuWmJo1axpPT09Tu3Zts3LlSqc6ycnJZsyYMaZcuXLG29vbNG/e3Pz444/Z6iPBHoCV3MbR3MQZ4igAZC/O2Iz5v48zZ1PlypU1a9YsRUZGOh1btWqVnnrqKR07diwnpy4S4uPj5e/vr7i4uHz7MA+Awi23cbSox5miPj4ABS87cSbHW87FxMSoTJkyLo8FBgbqr7/+yumpAeC2QBwFgMIjx0lzxYoV9e2337o89u2339o/HQ4AcI04CgCFR46T5p49e2ratGlauXKlQ/mqVas0ffp0Pfroo7nuHAAUZcRRACg8crym+cqVK3r44Ye1ceNG+fr6Kjg4WKdOnVJSUpIefPBBrV27Vp6ennnd30KDtXgArOQ2jhb1OFPUxweg4GUnzmTry02u5+npqU8++URbtmzR1q1bdf78eQUGBqp169Zq1apVTk8LALcN4igAFB45nmlG5pghAZDfinqcKerjA1DwbsruGek+/fRTPffccxo4cKD++OMPSdIXX3yhkydP5vbUAHBbII4CwK0vx8szYmJi1KlTJ/snvE+dOqVBgwbpjjvu0Ntvvy1fX1/NnTs3L/sKAEUKcRQACo8czzQPHz5cZ8+e1c8//6yjR4/q+lUerVu31tatW/OkgwBQVBFHAaDwyPFM84YNG7Rw4ULVrl1bqampDscqV66sEydO5LpzAFCUEUcBoPDI8Uzz1atX5evr6/JYbGzsbb3dHABkBXEUAAqPHCfNjRo10ttvv+3y2AcffKD7778/x50CgNsBcRQACo8cL894/vnn1aJFCzVr1kzdunWTzWbTRx99pBkzZmjDhg366quv8rKfAFDkEEcBoPDI8Uxz48aNtX37dtlsNo0aNUrGGE2bNk2nTp3S1q1bVb9+/bzsJwAUOcRRACg8cjTTfOXKFf3nP//R3XffrZ07d+rSpUuKjY1VqVKl5OPjk9d9BIAihzgKAIVLjmaaPT091atXLx0/flySVLx4cVWoUIFADwBZRBwFgMIlx8szwsLC7MEeAJB9xFEAKDxynDTPmDFDzz//vH744Ye87A8A3DaIowBQeOR494zRo0fr7NmzatiwoYKCglS2bFnZbDb7cZvNpp9++ilPOgkARRFxFAAKjxwnzQ0aNMjLfgDAbYc4CgCFR7aT5l9++UULFizQ2bNnVaFCBXXr1k1t2rTJj74BQJFEHAWAwidbSfNXX32lVq1a6erVqwoKCtL58+e1aNEizZ07V4MGDcqvPgJAkUEcBYDCKVsfBJw8ebJq166to0eP6q+//tK5c+fUuXNnTZgwIb/6BwBFCnEUAAqnbCXN+/bt08SJE1W5cmVJkp+fn15++WWdP3+ebZMAIAuIowBQOGUraT579qwqVarkUJYe+M+ePZt3vQKAIoo4CgCFU7b3ab5+OyQAQPYRRwGg8Mn27hktWrSQm5tzrt20aVOHcpvNpri4uNz1DgCKIOIoABQ+2UqaJ02alF/9AIDbAnEUAAonmzHGFHQniqL4+Hj5+/srLi5Ofn5+Bd0dAEVQUY8zRX18AApeduJMttc0AwAAALcbkmYAAADAAkkzAAAAYIGkGQAAALBA0gwAAABYIGkGAAAALJA0AwAAABZImgEAAAALJM0AAACABZJmAAAAwAJJMwAAAGCBpBkAAACwQNIMAAAAWCBpBgAAACwUyqR548aNqlevnry9vVW9enXNmzcvS+1SUlI0btw4BQcHy8fHRy1atNC+ffsc6nz++efq2bOnqlatKh8fH4WHh2vatGlKTk7Oj6EAQIEgjgJA9hS6pHnXrl3q1KmT6tevr02bNikqKkpDhw7VokWLLNuOGDFCc+fO1dSpU7V+/Xq5u7urVatWOn36tL3OggULFBcXp8mTJ2vjxo3q37+/Zs6cqX/+85/5OSwAuGmIowCQA6aQadeunWnYsKFD2YABA0xwcLBJTU3NsN2JEydMsWLFzNy5c+1l8fHxJjAw0IwZM8ZedubMGae2s2fPNpLM0aNHs9zPuLg4I8nExcVluQ0AZEdO4wxxFACuyU6cKVQzzcnJydq2bZt69OjhUN6rVy+dOnVKe/fuzbDt5s2blZqa6tC2ZMmS6tChgzZs2GAvK1OmjFPbevXqSZJOnjyZ2yEAQIEijgJAzhSqpPnw4cO6cuWKwsPDHcpr164tSYqOjs6wbXR0tMqVK6fSpUs7tT148KDS0tIybPvll1+qWLFiqlGjRi56DwAFjzgKADnjXtAdyI7Y2FhJUqlSpRzKAwICJEnnz5/PtO2N7dLbpqSkKDExUX5+fk7Hjx07phdffFFRUVEKCgrK8PzJyckOH3KJj4/PbCgAUCCIowCQMwWeNMfFxenUqVOW9apWrWr/2WazuayTUXlmx40xGR5LTEzUww8/rLJly2rWrFmZnnvGjBmaMmVKpnUAID/ExcVladkDcRQAcq7Ak+Z169apT58+lvX27t1rnwlJnylJl34//bgrAQEBTu0k6cKFC/Lw8JCvr69DeUpKirp27ao///xT33zzjcvZleuNGzdOI0eOtN+Pj49X5cqVM20DAHnhk08+0b/+9S/LesRRAMi5Al/THBUVJWOM5e3uu+9WaGioPD09ndbc7d+/X5Kc1uhdLzw8XGfOnHF663H//v2qVauW3Nz+dynS0tL02GOPadeuXdq4caOqVatmOQ4vLy/5+fk53ADgZujVqxdxFADyWYEnzdnh5eWlli1bauXKlQ7lK1asUHBwsP3T2a60bdtWbm5uDm0TExP1n//8R//4xz8c6g4ZMkTr1q3T2rVrVb9+/bwdBAAUIOIoAORMgS/PyK5nn31WzZo104ABA9SrVy99/fXXWrhwoRYsWOAwy1G9enWFhIRo69atkqSKFStq0KBBGjNmjNzd3RUSEmJfXzd8+HB7uxkzZmj+/PkaMWKESpQood27d9uPhYaGutxKCQAKE+IoAORAHu8RfVNs2LDB3HXXXcbT09NUq1bNvPHGG051QkJCTPPmzR3KkpOTzZgxY0y5cuWMt7e3ad68ufnxxx8d6jRv3txIcnl75513stxHNuUHkN9yE2eIowCQvThjM+b/PvaMPBUfHy9/f3/FxcWxLg9Avijqcaaojw9AwctOnClUa5oBAACAgkDSDAAAAFggaQYAAAAskDQDAAAAFkiaAQAAAAskzQAAAIAFkmYAAADAAkkzAAAAYIGkGQAAALBA0gwAAABYIGkGAAAALJA0AwAAABZImgEAAAALJM0AAACABZJmAAAAwAJJMwAAAGCBpBkAAACwQNIMAAAAWCBpBgAAACyQNAMAAAAWSJoBAAAACyTNAAAAgAWSZgAAAMACSTMAAABggaQZAAAAsEDSDAAAAFggaQYAAAAskDQDAAAAFkiaAQAAAAskzQAAAIAFkmYAAADAAkkzAAAAYIGkGQAAALBA0gwAAABYIGkGAAAALJA0AwAAABZImgEAAAALJM0AAACABZJmAAAAwAJJMwAAAGCBpBkAAACwQNIMAAAAWCBpBgAAACwUyqR548aNqlevnry9vVW9enXNmzcvS+1SUlI0btw4BQcHy8fHRy1atNC+ffsyrJ+Wlqb69evLZrNp9erVedV9AChwxFEAyJ5ClzTv2rVLnTp1Uv369bVp0yZFRUVp6NChWrRokWXbESNGaO7cuZo6darWr18vd3d3tWrVSqdPn3ZZf8GCBTp58mReDwEAChRxFABywBQy7dq1Mw0bNnQoGzBggAkODjapqakZtjtx4oQpVqyYmTt3rr0sPj7eBAYGmjFjxjjVj4mJMaVLlzaLFy82ksyqVauy1c+4uDgjycTFxWWrHQBkVU7jDHEUAK7JTpwpVDPNycnJ2rZtm3r06OFQ3qtXL506dUp79+7NsO3mzZuVmprq0LZkyZLq0KGDNmzY4FR/3LhxatGihVq2bJl3AwCAAkYcBYCcKVRJ8+HDh3XlyhWFh4c7lNeuXVuSFB0dnWHb6OholStXTqVLl3Zqe/DgQaWlpdnL9uzZo/fff1+zZs3Kw94DQMEjjgJAzhSqpDk2NlaSVKpUKYfygIAASdL58+czbXtju/S2KSkpSkxMlHTtQyuDBw/WqFGjVKVKlSz3LTk5WfHx8Q43ALjVEEcBIGfcC7oDcXFxOnXqlGW9qlWr2n+22Wwu62RUntlxY4zDsUWLFunUqVMaO3asZZ+uN2PGDE2ZMiVbbQAgL8TFxWXpw3bEUQDIuQJPmtetW6c+ffpY1tu7d699JiR9piRd+v30464EBAQ4tZOkCxcuyMPDQ76+vkpMTNT48eM1bdo0XblyRVeuXLHPdCQlJSk+Pl5+fn4uzz9u3DiNHDnSfj8+Pl6VK1e2HBcA5NYnn3yif/3rX5b1iKMAkHMFvjwjKipKxhjL2913363Q0FB5eno6rbnbv3+/JDmt0bteeHi4zpw54/TW4/79+1WrVi25ubnp7NmzOnfunAYNGqSAgAAFBATorrvukiT17t1bNWvWzPD8Xl5e8vPzc7gBwM3Qq1cv4igA5LMCT5qzw8vLSy1bttTKlSsdylesWKHg4GDVq1cvw7Zt27aVm5ubQ9vExET95z//0T/+8Q9JUvny5bV9+3aH24oVKyRJkydP1tq1a/NhVABw8xBHASBnCnx5RnY9++yzatasmQYMGKBevXrp66+/1sKFC7VgwQK5uf3vNUD16tUVEhKirVu3SpIqVqyoQYMGacyYMXJ3d1dISIj9U93Dhw+XJHl7eysiIsLh8Y4ePSpJuvPOO9WkSZN8Hx8A5DfiKABkX6FLmhs3bqz169dr/Pjxevfdd1WpUiXNmTNH/fv3d6h39epVpaamOpS98sorKlGihCZMmKC4uDg1atRIW7duVfny5W/mEACgQBFHASD7bCb9Y8/IU/Hx8fL391dcXBzr8gDki6IeZ4r6+AAUvOzEmUK1phkAAAAoCCTNAAAAgAWSZgAAAMACSTMAAABggaQZAAAAsEDSDAAAAFggaQYAAAAskDQDAAAAFkiaAQAAAAskzQAAAIAFkmYAAADAAkkzAAAAYIGkGQAAALBA0gwAAABYIGkGAAAALJA0AwAAABZImgEAAAALJM0AAACABZJmAAAAwAJJMwAAAGCBpBkAAACwQNIMAAAAWCBpBgAAACyQNAMAAAAWSJoBAAAACyTNAAAAgAWSZgAAAMACSTMAAABggaQZAAAAsEDSDAAAAFggaQYAAAAskDQDAAAAFkiaAQAAAAskzQAAAIAF94LuQFFljJEkxcfHF3BPABRV6fElPd4UNcRRAPktO3GUpDmfJCQkSJIqV65cwD0BUNQlJCTI39+/oLuR54ijAG6WrMRRmymqUxQFLC0tTSdPnlTJkiVls9kKujsO4uPjVblyZR0/flx+fn4F3Z1cYSy3pqI0FunWHY8xRgkJCapQoYLc3Ireajvi6M3BWG5NRWks0q07nuzEUWaa84mbm5sqVapU0N3IlJ+f3y31xM0NxnJrKkpjkW7N8RTFGeZ0xNGbi7HcmorSWKRbczxZjaNFb2oCAAAAyGMkzQAAAIAFkubbkJeXlyZNmiQvL6+C7kquMZZbU1Eai1T0xoPcK0rPCcZyaypKY5GKxnj4ICAAAABggZlmAAAAwAJJMwAAAGCBpBkAAACwQNJcBG3cuFH16tWTt7e3qlevrnnz5mWpXUpKisaNG6fg4GD5+PioRYsW2rdvX4b109LSVL9+fdlsNq1evTqvuu8gP8fy+eefq2fPnqpatap8fHwUHh6uadOmKTk5OVd9PnTokNq1aydfX1+VLVtWw4YN06VLl7LUdunSpQoLC5O3t7fq1KmjVatW5WhseSU/x3Lo0CENHTpUtWvXlq+vr0JCQtSvXz+dPn06P4aS77+X6w0bNkw2m01DhgzJi66jABBHiaN5pSjF0fTHvG1jqUGR8s033xh3d3fTt29fs23bNvPcc88ZNzc3s3DhQsu2gwcPNiVLljRvvfWW2bx5s2ndurUJCgoyp06dcll/3rx5ply5ckaSWbVqVV4PJd/H0q1bN/Pggw+aJUuWmO3bt5tZs2aZEiVKmG7duuW4z7GxsaZixYqmSZMmZtOmTWbp0qUmMDDQ9OrVy7LtqlWrjCQzduxYs23bNvPvf//b2Gw289lnn2V7bHkhv8fy+uuvm7p165pXX33VbN++3bz33nsmNDTUVKlSxSQkJBSqsVxv3759pkSJEsbPz88MHjw4T8eBm4M4eg1xNPeKUhy9GeO53q0YS0mai5h27dqZhg0bOpQNGDDABAcHm9TU1AzbnThxwhQrVszMnTvXXhYfH28CAwPNmDFjnOrHxMSY0qVLm8WLF+dbsM/vsZw5c8ap7ezZs40kc/To0Rz1eebMmcbHx8fExMTYy5YvX24kmf3792faNiwszHTv3t2hrG3btqZRo0b2+9n9PeVGfo8lJibGpKWlOdT56aefjCSzZMmSPBjB/+T3WK7XrFkz8+yzz5qQkJBbJtAje4ijxNG8UpTiqDHEUpLmIuTy5cvG09PTvPLKKw7lO3bsMJLM999/n2Hbt99+20gy586dcyiPiooyderUcarfv39/07VrV3PkyJF8CfY3cyzX++KLL4wk88033+So382aNTMdO3Z0KLt8+bLx8vIys2bNyrDd77//biSZtWvXOpQvWbLE2Gw2e4DKzdiyK7/H4kpaWpopVqyYmT59eu46f4ObNZZly5aZypUrm4sXL95SgR5ZRxy9hjiaN4pSHDWGWMqa5iLk8OHDunLlisLDwx3Ka9euLUmKjo7OsG10dLTKlSun0qVLO7U9ePCg0tLS7GV79uzR+++/r1mzZuVh7x3drLHc6Msvv1SxYsVUo0aNHPU7Ojraqc9eXl4KDQ217LMkl+M1xujAgQP2ejkdW3bl91hc2bVrl1JTU53a5tbNGEtCQoKefvppvfTSS/Lx8cnD3uNmIo7Kfow4mntFKY6m9+t2jqUkzUVIbGysJKlUqVIO5QEBAZKk8+fPZ9r2xnbpbVNSUpSYmCjp2odWBg8erFGjRqlKlSp50u+M+iPl71hudOzYMb344ouKiopSUFBQjvud0WNb9VmyHm9Ox5YT+T2WG6WkpGj48OGqVauWHnrooZx1OpM+5fdYJk+erOrVqysyMjL3HUaBIY7+ry1xNPeKUhxN79ftHEvdC7oDyFxcXJxOnTplWa9q1ar2n202m8s6GZVndtz83xdGph9btGiRTp06pbFjx1r26Ua32liul5iYqIcfflhly5bN9cxPRo9t1WdXbV31Obtjy438Hsv1hgwZov/+97/64osv5O6e96EpP8eyf/9+zZ07V7t3786DniKv3WqxhzhqjTjqum1Bx9GMHvt2iaUkzbe4devWqU+fPpb19u7da3/Flv6KLl36/fTjrgQEBDi1k6QLFy7Iw8NDvr6+SkxM1Pjx4zVt2jRduXJFV65cUXx8vCQpKSlJ8fHx8vPzKxRjuV5KSoq6du2qP//8U998843LV9FZldljZ/ZW2fXjLVeunEO7649nd2y5kd9jud6UKVO0ePFirV27Vg0aNMhlz133KT/HMnLkSHXv3l1VqlSxH0tLS9OVK1d04cIF+fn5yc2NN/YKyq0Ue4ij1oijt2YcTX/c2zmWEsVvcVFRUTLXPrCZ6e3uu+9WaGioPD09ndYV7d+/X5LzWqLrhYeH68yZM05vr+zfv1+1atWSm5ubzp49q3PnzmnQoEEKCAhQQECA7rrrLklS7969VbNmzUIzlnRpaWl67LHHtGvXLm3cuFHVqlXLdAxWwsPDnfqcnJysw4cPW/ZZcl5juH//ftlsNoWFhWV7bLmV32NJN2/ePE2ePFnz5s1Tx44d86j3zn3Kz7EcOHBAy5Yts/9dBAQE6Pjx41q4cKECAgJ06NChPB4RsuNWij3EUWvE0Vszjqb367aOpXnzeULcKtq1a2fuu+8+h7Innngiy9sLzZ8/316WkJDgsAXPpUuXzPbt2x1uK1asMJLM5MmTzddff11oxpLuySefNJ6enmbLli150ueZM2caX19fc/bsWXtZ+jXKynY8kZGRDmUPPPCAy62SsjK23MrvsaSfz83NzUydOjXvOu5Cfo9l165dTn8b5cqVM507dzbbt283Fy9ezNsBIV8RR4mjeaUoxVFjiKUkzUVM+kb2/fv3N9u3bzfPP/+8y43sQ0NDTcuWLR3KBg8ebPz8/MzChQvN5s2bTdu2bU1gYGCmm73n11ZJN2Ms06dPN5LMiBEjzK5duxxurvYezYr0jd/vv/9+8+mnn5p3333XBAUFOW383rdvX1OsWDGHspUrVxqbzWbGjx9vtm/fboYPH57hpvzZ/T3dimPZsWOH8fDwMM2bN3e6/r/99luhGosrt9I2Scge4mjWx0IcLdix3Mw4ejPG48qtFEtJmougDRs2mLvuust4enqaatWqmTfeeMOpTkhIiGnevLlDWXJyshkzZowpV66c8fb2Ns2bNzc//vhjpo+Vn8HemPwdS/PmzY0kl7d33nknx30+ePCgadu2rfHx8TFBQUFm6NChJikpyaFO7969jas3epYsWWJq1qxpPD09Te3atc3KlSud6uTk93QrjmXSpEkZXv/evXsXqrG4cisFemQfcZQ4mleKUhzN7/G4civFUpsx//fRRQAAAAAu8UFAAAAAwAJJMwAAAGCBpBkAAACwQNIMAAAAWCBpBgAAACyQNAMAAAAWSJoBAAAACyTNQA5MnjxZNpvNfgsKCtLf//53bdy4sUD6c/ToUdlsNq1evdpeFhERoYceeqhA+gMAWUEsRWFC0gzkUPHixbVr1y7t2rVLb731lq5cuaIOHTrom2++KeiuAUChQSxFYeFe0B0ACis3Nzfdd9999vuNGzdWxYoVtXTpUjVp0qQAewYAhQexFIUFM81AHgkODlaZMmX0xx9/2Mt27dqlli1bytfXV/7+/nr00Ud15swZh3bJycmaMGGCqlWrJi8vL1WqVEl9+vRxOEfHjh1VoUIF+fr66u6779Z7771308YFADcTsRS3KmaagTySmJio8+fPKzQ0VNK1AB0REaH27dvrww8/1MWLFzVhwgR17NhRu3fvtrfr2rWrtm3bpvHjx+u+++5TTEyM1qxZYz9+7Ngx3X///Ro0aJC8vb319ddfq1+/fjLG6PHHH7/p4wSA/EQsxa2KpBnIhatXr0qSTp06pbFjx8rPz0/Dhg2TJI0dO1YNGjTQ2rVrZbPZJEl16tRR3bp1tXHjRrVv315btmzRhg0b9P7776tnz572817/c48ePew/G2PUrFkznThxQm+++SaBHkCRQCxFYUDSDOTQxYsX5eHhYb9frFgxffzxx6pRo4aSkpL09ddfa9asWUpNTbXXqVWrloKDg7Vnzx61b99eW7dulY+Pj0Mwv1FsbKwmTZqk9evX688//7SfLzAwMP8GBwA3CbEUhQVrmoEcKl68uPbs2aNvv/1Wy5YtU3BwsB577DGdOnVKsbGxSk1N1YgRI+Th4eFwO3nypI4fPy5JOnfunIKDg+2zJ65ERUVpxYoVeuqpp7R582bt2bNHffv21eXLl2/WUAEg3xBLUVgw0wzkkJubmxo0aCBJatiwocLCwtSwYUNNnTpVs2bNks1m0/jx49W5c2entkFBQZKuzXCcOnVKxhiXwf7y5cvasGGDXn75ZQ0dOtRenpaWlj+DAoCbjFiKwoKZZiCP3HPPPerZs6feeecdJSQkqHHjxoqOjlaDBg2cblWqVJEktW7dWklJSVq5cqXLcyYnJys1NVWenp72soSEBH388cc3Y0gAcNMRS3GrYqYZyEMTJ07UihUr9Nprr+mll15Sy5YtFRkZqR49eiggIEAnTpzQli1b1KdPH0VERKh169Zq3769+vbtq8OHD6tRo0Y6f/681qxZow8++ED+/v669957NXPmTJUpU0bu7u6aOXOm/P39nbZbAoCigliKWxEzzUAeqlWrlnr27Kn58+frzjvv1FdffaXExET16dNH7du319SpU+Xj46Pq1avb26xZs0b//ve/tWDBAj344IMaOXKkfH197cfff/99hYaGqnfv3vr3v/+tbt268UlvAEUasRS3IpsxxhR0JwAAAIBbGTPNAAAAgAWSZgAAAMACSTMAAABggaQZAAAAsEDSDAAAAFggaQYAAAAskDQDAAAAFkiaAQAAAAskzQAAAIAFkmYAAADAAkkzAAAAYIGkGQAAALDw/wHxSqB2fHxesgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==> Union Model (Detection + Classification) - 5 classes\n", + "[mean Precisions] 0.5704349663931353\n", + "[mean Recalls] 0.2803682204993534\n", + "[mAP@.5] 0.40195737662770653\n", + "[mAP@.5:.95] 0.40195737662770653\n", + "[mean time] 0.042649137104018055s\n", + "\n", + "==> Convert to Model 1\n", + "[mean Precisions] 0.6230357850195234\n", + "[mean Recalls] 0.3059043619902019\n", + "[mAP@.5] 0.4484272475282988\n", + "[mAP@.5:.95] 0.4484272475282988\n", + "[mean time] 0.042649137104018055s\n", + "\n", + "==> Convert to Model 2\n", + "[mean Precisions] 0.6190156182172799\n", + "[mean Recalls] 0.30386862037965345\n", + "[mAP@.5] 0.3349644805230888\n", + "[mAP@.5:.95] 0.8897615083738772\n", + "[mean time] 0.042649137104018055s\n", + "\n" + ] + } + ], + "source": [ + "lst_result = [[],[],[],[],[]] # class 0~4\n", + "eval_times = []\n", + "\n", + "for i in range(0, len(image_paths)):\n", + " # Image name\n", + " img_dir = os.path.dirname(image_paths[i])\n", + " img_name = os.path.basename(image_paths[i])\n", + "\n", + " # Load image\n", + " img = cv2.imread(image_paths[i]) \n", + " img = cv2.resize(img, (640, 640))\n", + " labels = read_label(label_paths[i])\n", + " Evaluate(model_detect, model_cls, img, img_name, labels, False)\n", + "\n", + "Ps = []\n", + "Rs = []\n", + "ap5s = []\n", + "ap95s = []\n", + "\n", + "# Class\n", + "# 0: head\n", + "# 1: helmet\n", + "# 2: face\n", + "# 3: mask\n", + "# 4: helmet & mask\n", + "\n", + "# each class result\n", + "class_len = len(lst_result)\n", + "\n", + "for i in range(0, class_len): \n", + " results_all = CompareGTandBox(lst_result[i], -1) # all P, R\n", + " results_5 = CompareGTandBox(lst_result[i], 0) # mAP@.5\n", + " results_95 = CompareGTandBox(lst_result[i], 1) # mAP@.5:.95\n", + "\n", + " p, r = GetPR(results_all)\n", + " p1, r1 = GetPR(results_5)\n", + " p2, r2 = GetPR(results_95)\n", + " ap1 = calculate_AP(p1, r1)\n", + " ap2 = calculate_AP(p2, r2)\n", + " # print(p1)\n", + " # print(r1)\n", + " # print(p2)\n", + " # print(r2)\n", + " if len(p) != 0:\n", + " p = sum(p) / len(p)\n", + " else:\n", + " p = 0\n", + " if len(r) != 0:\n", + " r = sum(r) / len(r)\n", + " else:\n", + " r = 0\n", + "\n", + " Ps.append(p)\n", + " Rs.append(r)\n", + " ap5s.append(ap1)\n", + " ap95s.append(ap2)\n", + " print(f'Class {i}')\n", + " print(f'meanP:', p)\n", + " print(f'meanR:', r)\n", + " print(f\"AP@.5:\", ap1)\n", + " print(f\"AP@.5:.95:\", ap2)\n", + "\n", + " fig, axs = plt.subplots(1, 2, figsize=(8, 4))\n", + " axs[0].plot(r1, p1)\n", + " axs[0].set_xlabel('Recall')\n", + " axs[0].set_ylabel('Precision')\n", + " axs[1].plot(r2, p2)\n", + " axs[1].set_xlabel('Recall')\n", + " axs[1].set_ylabel('Precision')\n", + " plt.suptitle(f'Class {i} Precision-Recall Curve (mAP@.5, mAP@.5:.95)')\n", + " print()\n", + " \n", + "# plt.tight_layout()\n", + "plt.show()\n", + "\n", + "mP = sum(Ps) / class_len\n", + "mR = sum(Rs) / class_len\n", + "mAP_5 = sum(ap5s) / class_len\n", + "mAP_95 = sum(ap95s) / class_len\n", + "mean_time = sum(eval_times) / len(eval_times)\n", + "\n", + "print(f'==> Union Model (Detection + Classification) - 5 classes')\n", + "print(f'[mean Precisions] {mP}')\n", + "print(f'[mean Recalls] {mR}')\n", + "print(f'[mAP@.5] {mAP_5}')\n", + "print(f'[mAP@.5:.95] {mAP_95}')\n", + "print(f'[mean time] {mean_time}s')\n", + "print()\n", + "\n", + "\n", + "#### Convert to evaluate ####\n", + "\n", + "# Class\n", + "# 0: head\n", + "# 1: helmet\n", + "# 2: face\n", + "# 3: mask\n", + "# 4: helmet & mask\n", + "\n", + "# => Model 1: (0, 2, 3) - head, (1, 4) - helmet \n", + "# => Model 2: (0, 1, 2) - face, (3, 4) - mask \n", + "\n", + "print(f'==> Convert to Model 1')\n", + "print(f'[mean Precisions] {((Ps[0] + Ps[2] + Ps[3]) / 3 + (Ps[1] + Ps[4]) / 2) / 2}')\n", + "print(f'[mean Recalls] {((Rs[0] + Rs[2] + Rs[3]) / 3 + (Rs[1] + Rs[4]) / 2) / 2}')\n", + "print(f'[mAP@.5] {((ap5s[0] + ap5s[2] + ap5s[3]) / 3 + (ap5s[1] + ap5s[4]) / 2) / 2}')\n", + "print(f'[mAP@.5:.95] {((ap95s[0] + ap95s[2] + ap95s[3]) / 3 + (ap95s[1] + ap95s[4]) / 2) / 2}')\n", + "print(f'[mean time] {mean_time}s')\n", + "print()\n", + "\n", + "print(f'==> Convert to Model 2')\n", + "print(f'[mean Precisions] {((Ps[0] + Ps[1] + Ps[2]) / 3 + (Ps[3] + Ps[4]) / 2) / 2}')\n", + "print(f'[mean Recalls] {((Rs[0] + Rs[1] + Rs[2]) / 3 + (Rs[3] + Rs[4]) / 2) / 2}')\n", + "print(f'[mAP@.5] {((ap5s[0] + ap5s[1] + ap5s[2]) / 3 + (ap5s[3] + ap5s[4]) / 3) / 2}')\n", + "print(f'[mAP@.5:.95] {((ap95s[0] + ap95s[1] + ap95s[2]) / 3 + (ap95s[3] + ap95s[4]) / 2)}')\n", + "print(f'[mean time] {mean_time}s')\n", + "print()\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +}