{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Proporciones altas de fondos en test - usando HOG" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Imports" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [], "source": [ "# Encadenar iterables\n", "from itertools import chain\n", "\n", "# Proporciona una barra de progreso rápida\n", "from tqdm import tqdm\n", "\n", "# Interfaz para hacer gráficos y visualizaciones\n", "import matplotlib.pyplot as plt\n", "\n", "# Computación científica\n", "import numpy as np\n", "\n", "# Manipulación de datos\n", "import pandas as pd\n", "\n", "# Extraer parches (pequeños subconjuntos de imágenes) de imágenes\n", "from sklearn.feature_extraction.image import PatchExtractor\n", "\n", "# data: conjunto de datos de muestra y funciones de carga\n", "# color: convertir imágenes entre espacios de color\n", "# feature: funciones para identificar y extraer características de imágenes\n", "from skimage import data, color, feature\n", "\n", "# Cambiar el tamaño de una imagen\n", "from skimage.transform import resize, rescale\n", "\n", "# Descarga y carga en memoria un conjunto de datos de imágenes de caras de personas famosas\n", "from sklearn.datasets import fetch_lfw_people\n", "\n", "# Modelos\n", "from sklearn.linear_model import LogisticRegression\n", "\n", "# Train test split\n", "from sklearn.model_selection import train_test_split\n", "\n", "# Matriz de confusión\n", "from sklearn.metrics import confusion_matrix\n", "\n", "# La curva ROC\n", "from sklearn.metrics import roc_curve\n", "\n", "# Classification report\n", "from sklearn.metrics import classification_report\n", "\n", "# Métricas varias\n", "from sklearn.metrics import accuracy_score, balanced_accuracy_score, precision_score, recall_score, f1_score, roc_auc_score" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Funciones auxiliares" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "# Función para extraer porciones de una imagen\n", "def extract_patches(img, N, scale=1.0, patch_size=(62,47), random_state=0):\n", " # Calcula el tamaño del parche extraído basado en el factor de escala dado\n", " H = img.shape[0]\n", " W = img.shape[1]\n", " H_patch = min(H , int(scale * patch_size[0]))\n", " W_patch = min(W , int(scale * patch_size[1]))\n", " extracted_patch_size = (H_patch, W_patch)\n", "\n", " # Inicializa un objeto PatchExtractor con el tamaño de parche calculado,\n", " # el número máximo de parches, y una semilla de estado aleatorio\n", " extractor = PatchExtractor(patch_size=extracted_patch_size, max_patches=N, random_state=random_state)\n", "\n", " # Extrae parches de la imagen dada\n", " # img[np.newaxis] se utiliza la entrada de PatchExtractor es un conjunto de imágenes\n", " patches = extractor.transform(img[np.newaxis])\n", "\n", " # Si el factor de escala no es 1, redimensiona cada parche extraído\n", " # al tamaño del parche original\n", " if scale != 1:\n", " patches = np.array([resize(patch, patch_size) for patch in patches])\n", "\n", " # Devuelve la lista de parches extraídos (y posiblemente redimensionados)\n", " return patches" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "def non_max_suppression(indices, Ni, Nj, overlapThresh):\n", " # Si no hay rectángulos, regresar una lista vacía\n", " if len(indices) == 0:\n", " return []\n", "\n", " # Si las cajas son enteros, convertir a flotantes\n", " if indices.dtype.kind == \"i\":\n", " indices = indices.astype(\"float\")\n", "\n", " # Inicializar la lista de índices seleccionados\n", " pick = []\n", "\n", " # Tomar las coordenadas de los cuadros\n", " x1 = np.array([indices[i,0] for i in range(indices.shape[0])])\n", " y1 = np.array([indices[i,1] for i in range(indices.shape[0])])\n", " x2 = np.array([indices[i,0]+Ni for i in range(indices.shape[0])])\n", " y2 = np.array([indices[i,1]+Nj for i in range(indices.shape[0])])\n", "\n", " # Calcula el área de los cuadros y ordena los cuadros\n", " area = (x2 - x1 + 1) * (y2 - y1 + 1)\n", " idxs = np.argsort(y2)\n", "\n", " # Mientras todavía hay índices en la lista de índices\n", " while len(idxs) > 0:\n", " # Toma el último índice de la lista y agrega el índice a la lista de seleccionados\n", " last = len(idxs) - 1\n", " i = idxs[last]\n", " pick.append(i)\n", "\n", " # Encontrar las coordenadas (x, y) más grandes para el inicio de la caja y las coordenadas (x, y) más pequeñas para el final de la caja\n", " xx1 = np.maximum(x1[i], x1[idxs[:last]])\n", " yy1 = np.maximum(y1[i], y1[idxs[:last]])\n", " xx2 = np.minimum(x2[i], x2[idxs[:last]])\n", " yy2 = np.minimum(y2[i], y2[idxs[:last]])\n", "\n", " # Calcula el ancho y alto de la caja\n", " w = np.maximum(0, xx2 - xx1 + 1)\n", " h = np.maximum(0, yy2 - yy1 + 1)\n", "\n", " # Calcula la proporción de superposición\n", " overlap = (w * h) / area[idxs[:last]]\n", "\n", " # Elimina todos los índices del índice de lista que tienen una proporción de superposición mayor que el umbral proporcionado\n", " idxs = np.delete(idxs, np.concatenate(([last], np.where(overlap > overlapThresh)[0])))\n", "\n", " # Devuelve solo las cajas seleccionadas\n", " return indices[pick].astype(\"int\")" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# Define una función para realizar una ventana deslizante (sliding window) sobre una imagen.\n", "def sliding_window(img,\n", " patch_size=(62,47), # Define el tamaño del parche (patch) basado en el primer parche positivo por defecto\n", " istep=2, # Paso de desplazamiento en la dirección i (verticalmente)\n", " jstep=2, # Paso de desplazamiento en la dirección j (horizontalmente)\n", " scale=1.0): # Factor de escala para ajustar el tamaño del parche\n", "\n", " # Calcula las dimensiones Ni y Nj del parche ajustadas por el factor de escala.\n", " Ni, Nj = (int(scale * s) for s in patch_size)\n", "\n", " # Itera a lo largo de la imagen en la dirección i\n", " for i in range(0, img.shape[0] - Ni, istep):\n", " # Itera a lo largo de la imagen en la dirección j\n", " for j in range(0, img.shape[1] - Ni, jstep):\n", "\n", " # Extrae el parche de la imagen usando las coordenadas actuales i, j.\n", " patch = img[i:i + Ni, j:j + Nj]\n", "\n", " # Si el factor de escala es diferente de 1, redimensiona el parche al tamaño original del parche.\n", " if scale != 1:\n", " patch = resize(patch, patch_size)\n", "\n", " # Usa yield para devolver las coordenadas actuales y el parche.\n", " # Esto convierte la función en un generador.\n", " yield (i, j), patch" ] }, { "cell_type": "code", "execution_count": 109, "metadata": {}, "outputs": [], "source": [ "# Función que devuelve el número de detecciones brutas y procesadas para diversas escalas\n", "# Esta función asume conocidos model, size y los parámetros de las HOG\n", "def detections_by_scale(test_image, test_scales, step, thresholds=[0.5]):\n", " raw_detections = []\n", " detections = []\n", "\n", " for scale in tqdm(test_scales):\n", " raw_detections_scale = []\n", " detections_scale = []\n", "\n", " # Ventana deslizante\n", " indices, patches = zip(*sliding_window(test_image, scale=scale, istep=step, jstep=step))\n", "\n", " # Calcula las características HOG para cada parche y las almacena en un array.\n", " patches_hog = np.array([feature.hog(patch,\n", " orientations=orientations,\n", " pixels_per_cell=pixels_per_cell,\n", " cells_per_block=cells_per_block) for patch in patches])\n", " # Predicción\n", " for thr in thresholds:\n", " labels = (model.predict_proba(patches_hog)[:,1]>=thr).astype(int)\n", " raw_detections_scale.append(labels.sum())\n", " Ni, Nj = (int(scale*s) for s in size)\n", " indices = np.array(indices)\n", " detecciones = indices[labels == 1]\n", " detecciones = non_max_suppression(np.array(detecciones),Ni,Nj, 0.3)\n", " detections_scale.append(len(detecciones))\n", " \n", " # Actualizamos las listas\n", " raw_detections.append(raw_detections_scale)\n", " detections.append(detections_scale)\n", " \n", " return np.array(raw_detections), np.array(detections)" ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [], "source": [ "# True Positive Rate\n", "def tpr_scorer(clf, X, y):\n", " y_pred = clf.predict(X)\n", " cm = confusion_matrix(y, y_pred)\n", " tpr = cm[1,1]/(cm[1,1]+cm[1,0])\n", " return tpr\n", "\n", "# False Positive Rate\n", "def fpr_scorer(clf, X, y):\n", " y_pred = clf.predict(X)\n", " cm = confusion_matrix(y, y_pred)\n", " fpr = cm[0,1]/(cm[0,0]+cm[0,1])\n", " return fpr\n", "\n", "# True Negative Rate\n", "def tnr_scorer(clf, X, y):\n", " y_pred = clf.predict(X)\n", " cm = confusion_matrix(y, y_pred)\n", " tnr = cm[0,0]/(cm[0,0]+cm[0,1])\n", " return tnr\n", "\n", "# True Negative Rate\n", "def fnr_scorer(clf, X, y):\n", " y_pred = clf.predict(X)\n", " cm = confusion_matrix(y, y_pred,)\n", " fnr = cm[1,0]/(cm[1,0]+cm[1,1])\n", " return fnr\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Dataset de rostros (LFW)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(13233, 62, 47)" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Cargamos el dataset\n", "faces = fetch_lfw_people()\n", "positive_patches = faces.images\n", "positive_patches.shape" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "# Dividimos en train y test\n", "positive_patches_train, positive_patches_test = train_test_split(\n", " positive_patches,\n", " test_size=0.1,\n", " random_state=42\n", ")" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Shape train: (11909, 62, 47)\n", "Shape test: (1324, 62, 47)\n" ] } ], "source": [ "print('Shape train: ',positive_patches_train.shape)\n", "print('Shape test: ',positive_patches_test.shape)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Dataset de fondos" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "41\n" ] } ], "source": [ "# Tomamos algunas imágenes de sklearn\n", "imgs = ['camera',\n", " 'text',\n", " 'coins',\n", " 'moon',\n", " 'page',\n", " 'clock',\n", " 'immunohistochemistry',\n", " 'chelsea',\n", " 'coffee',\n", " 'hubble_deep_field'\n", " ]\n", "\n", "backgrounds = []\n", "for name in imgs:\n", " img = getattr(data, name)()\n", " if len(img.shape) == 3 and img.shape[2] == 3: # Chequeamos si la imagen es RGB\n", " img = color.rgb2gray(img)\n", " backgrounds.append(img)\n", "\n", "# Imagenes caseras adicionales\n", "for i in range(31):\n", " filename = str(i)+'.jpg'\n", " img = plt.imread(filename)\n", " img = color.rgb2gray(img)\n", " backgrounds.append(img)\n", "\n", "print(len(backgrounds))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Definimos el modelo, los datos y las HOG" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "LogisticRegression(C=1, max_iter=1000)_R_1_S_[0.5, 1, 2, 4, 8]_PTrain_10_PTest_100_O_3_C_(12, 12)_B_(3, 3)\n" ] } ], "source": [ "# Modelo\n", "model = LogisticRegression(penalty='l2',C=1, max_iter=1000)\n", "\n", "# Resolución de los rostros\n", "resolution = 1\n", "\n", "# Fondos\n", "scales = [0.5,1,2,4,8]\n", "proportion_train = 10\n", "proportion_test = 100\n", "num_patches_train = int((proportion_train * len(positive_patches_train))/(len(scales) * len(backgrounds)))\n", "num_patches_test = int((proportion_test * len(positive_patches_test))/(len(scales) * len(backgrounds)))\n", "\n", "# HOG\n", "orientations = 3\n", "pixels_per_cell = (12, 12)\n", "cells_per_block = (3, 3)\n", "\n", "# Nombre del experimento\n", "model_name = str(model)\n", "experiment_name = model_name\n", "experiment_name += '_R_' + str(resolution)\n", "experiment_name += '_S_' + str(scales)\n", "experiment_name += '_PTrain_' + str(proportion_train)\n", "experiment_name += '_PTest_' + str(proportion_test)\n", "experiment_name += '_O_' + str(orientations)\n", "experiment_name += '_C_' + str(pixels_per_cell)\n", "experiment_name += '_B_' + str(cells_per_block)\n", "\n", "print(experiment_name)" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 11909/11909 [00:03<00:00, 3439.57it/s]\n", "100%|██████████| 1324/1324 [00:00<00:00, 3437.03it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Tamaño de los rostros: (62, 47)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "# Tamaño de las imágenes de rostros\n", "\n", "# Train\n", "positive_patches_train = np.array(\n", " [rescale(positive_patches_train[i], resolution)\n", " for i in tqdm(range(len(positive_patches_train)))]\n", " )\n", "\n", "# Test\n", "positive_patches_test = np.array(\n", " [rescale(positive_patches_test[i], resolution)\n", " for i in tqdm(range(len(positive_patches_test)))]\n", " )\n", "\n", "size = positive_patches_train[0].shape\n", "print('Tamaño de los rostros: ',size)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Procesando imágenes train: 100%|██████████| 41/41 [03:30<00:00, 5.14s/it]\n", "Procesando imágenes test: 100%|██████████| 41/41 [03:36<00:00, 5.28s/it]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Shape train: (112961, 62, 47)\n", "Shape test: (125356, 62, 47)\n" ] } ], "source": [ "# Extraemos las imágenes de fondo\n", "\n", "# Train\n", "negative_patches_train = np.vstack(\n", " [extract_patches(im, num_patches_train, scale, random_state=42)\n", " for im in tqdm(backgrounds, desc='Procesando imágenes train')\n", " for scale in scales]\n", " )\n", "\n", "# Test\n", "negative_patches_test = np.vstack(\n", " [extract_patches(im, num_patches_test, scale, random_state=0)\n", " for im in tqdm(backgrounds, desc='Procesando imágenes test')\n", " for scale in scales]\n", " )\n", "\n", "print('Shape train: ',negative_patches_train.shape)\n", "print('Shape test: ',negative_patches_test.shape)" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [] }, { "name": "stderr", "output_type": "stream", "text": [ "124870it [01:22, 1507.93it/s]\n", "126680it [01:50, 1150.90it/s]\n" ] } ], "source": [ "# Armamos la matriz de features y el vector de etiquetas\n", "\n", "# Train\n", "X_train = np.array(\n", " [feature.hog(image=im,\n", " orientations=orientations,\n", " pixels_per_cell=pixels_per_cell,\n", " cells_per_block=cells_per_block)\n", " for im in tqdm(chain(positive_patches_train, negative_patches_train))]\n", " )\n", "y_train = np.zeros(X_train.shape[0])\n", "y_train[:positive_patches_train.shape[0]] = 1\n", "\n", "# Test\n", "X_test = np.array(\n", " [feature.hog(image=im,\n", " orientations=orientations,\n", " pixels_per_cell=pixels_per_cell,\n", " cells_per_block=cells_per_block)\n", " for im in tqdm(chain(positive_patches_test, negative_patches_test))]\n", " )\n", "y_test = np.zeros(X_test.shape[0])\n", "y_test[:positive_patches_test.shape[0]] = 1" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Shape X_train: (124870, 81)\n", "Shape y_train: (124870,)\n", "Shape X_test: (126680, 81)\n", "Shape y_test: (126680,)\n" ] } ], "source": [ "print('Shape X_train: ', X_train.shape)\n", "print('Shape y_train: ', y_train.shape)\n", "print('Shape X_test: ', X_test.shape)\n", "print('Shape y_test: ', y_test.shape)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Entrenamiento y evaluación del modelo" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
LogisticRegression(C=1, max_iter=1000)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" ], "text/plain": [ "LogisticRegression(C=1, max_iter=1000)" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Entrenamos el modelo\n", "model.fit(X_train,y_train)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Predicciones\n", "y_pred = model.predict(X_test)\n", "y_pred_proba = model.predict_proba(X_test)[:,1]" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ACCURACY 0.997450\n", "PRECISION 0.919092\n", "RECALL 0.966951\n", "F1 0.884684\n", "B_ACCURACY 0.966951\n", "AUC 0.997011\n", "TPR 0.935801\n", "FPR 0.001899\n", "TNR 0.998101\n", "FNR 0.064199\n", "dtype: float64\n" ] } ], "source": [ "# Métrcias\n", "acc = accuracy_score(y_test, y_pred)\n", "b_acc = balanced_accuracy_score(y_test, y_pred)\n", "prec = precision_score(y_test,y_pred)\n", "rec = recall_score(y_test, y_pred)\n", "f1 = f1_score(y_test, y_pred)\n", "auc = roc_auc_score(y_test, y_pred_proba)\n", "tpr = tpr_scorer(model, X_test, y_test)\n", "fpr = fpr_scorer(model, X_test, y_test)\n", "tnr = tnr_scorer(model, X_test, y_test)\n", "fnr = fnr_scorer(model, X_test, y_test)\n", "\n", "# Guardamos en un dataframe\n", "results = pd.Series(\n", " data={\n", " 'ACCURACY': acc,\n", " 'PRECISION': prec,\n", " 'RECALL': rec,\n", " 'F1': f1,\n", " 'B_ACCURACY': b_acc,\n", " 'AUC': auc,\n", " 'TPR': tpr,\n", " 'FPR': fpr,\n", " 'TNR': tnr,\n", " 'FNR': fnr\n", " }\n", ")\n", "\n", "print(results)" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " precision recall f1-score support\n", "\n", " 0.0 0.9993 0.9981 0.9987 125356\n", " 1.0 0.8389 0.9358 0.8847 1324\n", "\n", " accuracy 0.9975 126680\n", " macro avg 0.9191 0.9670 0.9417 126680\n", "weighted avg 0.9976 0.9975 0.9975 126680\n", "\n" ] } ], "source": [ "print(classification_report(y_test,y_pred, digits=4))" ] }, { "cell_type": "code", "execution_count": 61, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxoAAAGNCAYAAACWvAeAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABtyElEQVR4nO3deVxUVf8H8M8wMIAIuKAsyqamYmoquACZaYq7ZZmY5paYhKVCWZKZSyVpj0Sl4IqmmVIu1fNEKS1ugaGEuf7cQHEBFVRAUJaZ8/uDmBwBZWBm7gx83q/XvGrOnHvv98w45/Kdc+85MiGEABERERERkQ6ZSR0AERERERHVPUw0iIiIiIhI55hoEBERERGRzjHRICIiIiIinWOiQUREREREOsdEg4iIiIiIdI6JBhERERER6RwTDSIiIiIi0jkmGkREREREpHNMNMikHT16FJMnT4anpyesrKzQsGFDdOvWDUuXLsXNmzelDq9GZDKZxsPOzg5+fn7YsmVLldscPHgQL774IpydnaFQKODk5IRRo0YhKSmpym3q4ntHRKRLD/bHlT0WLFggdZhERstc6gCIamrNmjUICQlBu3btMHv2bHTo0AElJSU4fPgwVq5ciaSkJOzcuVPqMGtk1KhRePPNNyGEQHp6OhYvXoyxY8dCCIGxY8dq1P3iiy8wa9Ys9OjRA0uXLoW7uzsyMjKwYsUKPPnkk/jss8/w+uuva2xTl987IiJdqerHmtLSUkyYMAFXrlzBkCFDDBwVkQkRRCYoMTFRyOVyMWjQIHHv3r0KrxcVFYnvv/9eJ8cqLCwUKpVKJ/uqDgBi+vTpGmUXLlwQAMRTTz2lUX7gwAFhZmYmhg0bJkpKSjReKykpEcOGDRNmZmbiwIED6nJDvndERHXRG2+8IQCIVatWSR0KkVHjpVNkkhYvXgyZTIbVq1fD0tKywusKhQIjRoxQP69qeNvDwwOTJk1SP9+wYQNkMhl2796NV155Bc2aNUODBg0QFxcHmUyGX3/9tcI+YmJiIJPJcPToUQDA4cOHMWbMGHh4eMDa2hoeHh546aWXcPHixRq3193dHc2aNcO1a9c0yiMiIiCTyRATEwNzc80BSnNzc0RHR0Mmk+Hjjz9Wl2v73hER0b82bdqEL774AlOmTMGrr76qLr958yZCQkLQokULKBQKtGrVCnPnzkVRUZHG9vfu3UN4eDg8PT2hUCjQokULTJ8+Hbdv39ao5+HhgWHDhuF///sfunbtCmtra3h5eeF///sfgLLzlZeXF2xsbNCjRw8cPnxY720n0hYvnSKTo1Qq8dtvv8Hb2xuurq56OcYrr7yCoUOHYtOmTSgoKMCwYcPQvHlzrF+/Hs8884xG3Q0bNqBbt27o3LkzAODChQto164dxowZgyZNmiAzMxMxMTHo3r07Tp48CQcHB63jyc3Nxc2bN9GrVy91mVKpxO+//w4fHx+0bNmy0u1cXV3h7e2N3377DUqlEgD0/t4REdVVqampmDZtGrp3744VK1aoy+/du4e+ffvi/PnzWLhwITp37oz9+/cjIiICR44cwY8//ggAEELgueeew6+//orw8HD07t0bR48exfz585GUlISkpCSNH4D+/vtvhIeHY+7cubC3t8fChQvx/PPPIzw8HL/++qv6h6N33nkHw4YNQ3p6OqytrQ3+vhBVSeohFSJtZWVlCQBizJgx1d4GgJg/f36Fcnd3dzFx4kT18/Xr1wsAYsKECRXqhoWFCWtra3H79m112cmTJwUA8cUXX1R57NLSUnHnzh1hY2MjPvvss2rFGhISIkpKSkRxcbE4c+aMGDFihLC1tRWHDx9W16vu+xAYGCgAiGvXrtXovSMiIiFu3Lgh3N3dRbNmzURGRobGaytXrhQAxDfffKNRvmTJEgFA7N69WwghxM8//ywAiKVLl2rUi4uLEwDE6tWr1WXu7u7C2tpaXL58WV125MgRAUA4OzuLgoICdfl3330nAIgffvhBZ+0l0gVeOkVUiRdeeKFC2SuvvIK7d+8iLi5OXbZ+/XpYWlpq3KB9584dvPPOO2jTpg3Mzc1hbm6Ohg0boqCgAKdOnarW8aOjo2FhYQGFQoG2bdvip59+wpYtW+Dt7a11W4QQAMouHyMiIu0plUqMGTMGly9fRlxcXIUR4d9++w02NjYYNWqURnn5pbnll93+9ttvGuXlXnzxRdjY2FS4PLdLly5o0aKF+rmXlxcA4Omnn0aDBg0qlNfmEl0ifWCiQSbHwcEBDRo0QHp6ut6O4ezsXKHs8ccfR/fu3bF+/XoAZSeer776Cs8++yyaNGmirjd27FgsX74cQUFB2LVrF5KTk3Ho0CE0a9YMd+/erdbxR48ejUOHDiExMRGrVq2Cra0txowZg7Nnz6rrVPd9uHDhAho0aIAmTZoY5L0jIqpr3n77bfz6669YsmQJ+vbtW+H1nJwcODk5VfhBp3nz5jA3N0dOTo66nrm5OZo1a6ZRTyaTwcnJSV2v3P3nFqDsHrqHld+7d68GrSPSHyYaZHLkcjmeeeYZpKSk4PLly9XaxtLSssINeQAqdOrlqvr1f/LkyTh48CBOnTqFn3/+GZmZmZg8ebL69dzcXPzvf//D22+/jTlz5uCZZ55B9+7d0alTJ63WpmjWrBl8fHzg6+uLV199Fd999x0KCgoQGhqqriOXy9G3b18cPny4yvfh8uXLSElJQb9+/SCXy2v03hER1WdbtmxBZGQkAgMD8eabb1Zap2nTprh27Zp6BLnc9evXUVpaqr43r2nTpigtLcWNGzc06gkhkJWVVaN7+IiMGRMNMknh4eEQQmDq1KkoLi6u8HpJSQn++9//qp97eHioZ4Uq99tvv+HOnTtaHfell16ClZUVNmzYgA0bNqBFixYICAhQvy6TySCEqDCb09q1a9U3Y9dE7969MWHCBPz4448a87qXvw8hISEV9q9UKvHaa69BCIHw8PAK21T3vSMiqq+OHj2KoKAgdOzYEevWrauy3jPPPIM7d+7gu+++0yjfuHGj+vX7//vVV19p1Nu+fTsKCgoqTDZCZOo46xSZJF9fX8TExCAkJATe3t547bXX8Pjjj6OkpASpqalYvXo1OnbsiOHDhwMAxo8fj3nz5uH9999Hnz59cPLkSSxfvhz29vZaHbdRo0YYOXIkNmzYgNu3b+Ott96Cmdm/+bqdnR2eeuopfPLJJ3BwcICHhwf27t2LdevWoVGjRrVq8wcffIC4uDjMmzcPv/zyCwDA398fUVFRmDVrFp588km8/vrrcHNzUy/Y9+effyIqKgp+fn41fu+IiOqjW7du4bnnnkNRURHeeecdHDt2rNJ6zZo1w4QJE7BixQpMnDgRFy5cQKdOnXDgwAEsXrwYQ4YMQf/+/QEAAwYMwMCBA/HOO+8gLy8P/v7+6lmnunbtivHjxxuyiUT6J9196ES1d+TIETFx4kTh5uYmFAqFsLGxEV27dhXvv/++uH79urpeUVGRePvtt4Wrq6uwtrYWffr0EUeOHKly1qlDhw5Veczdu3cLAAKAOHPmTIXXL1++LF544QXRuHFjYWtrKwYNGiSOHz9e4VhVQSUL9pWbPXu2ACD27t2rUZ6UlCRGjRolHB0dhbm5uWjevLl4/vnnRWJiYpXHqe57R0RUH/3+++/qvv5hj/J+PScnRwQHBwtnZ2dhbm4u3N3dRXh4eIWFUe/evSveeecd4e7uLiwsLISzs7N47bXXxK1btzTqubu7i6FDh1aIq7JzRHp6ugAgPvnkE52+B0S1JRPigQsKiYiIiIiIaon3aBARERERkc4x0SAiIiIiIp1jokFERERERDrHRIOIiPRu3759GD58OFxcXCCTySpMA1qZvXv3wtvbG1ZWVmjVqhVWrlxZoc727dvRoUMHWFpaokOHDti5c6ceoicioppgokFERHpXUFCAJ554AsuXL69W/fT0dAwZMgS9e/dGamoq3n33XcyYMQPbt29X10lKSkJgYCDGjx+Pv//+G+PHj8fo0aPx559/6qsZRESkBc46RUREBiWTybBz504899xzVdZ555138MMPP+DUqVPqsuDgYPz999/qRSsDAwORl5eHn376SV1n0KBBaNy4MbZs2aK3+ImIqHrq3YJ9KpUKV69eha2tLWQymdThEBHpnBAC+fn5cHFx0VhQ0pQkJSUhICBAo2zgwIFYt24dSkpKYGFhgaSkJISGhlaoExUV9dB9FxUVoaioSP1cpVLh5s2baNq0Kc8LRFQnSXVeqHeJxtWrV+Hq6ip1GEREenfp0iW0bNlS6jBqJCsrC46Ojhpljo6OKC0tRXZ2Npydnausk5WV9dB9R0REYOHChTqPmYjI2Bn6vFDvEg1bW1sAZW+0nZ2dxNEQEeleXl4eXF1d1f2dqXpwdKH8St/7yyur86hRifDwcISFhamf5+bmws3NjecFIqqzpDov1LtEo/wEZGdnxxMKEdVppnwZkJOTU4WRievXr8Pc3BxNmzZ9aJ0HRzkeZGlpCUtLywrlPC8QUV1n6POCaV68S0REdZqvry8SEhI0ynbv3g0fHx9YWFg8tI6fn5/B4iQioqrVuxENIiIyvDt37uDcuXPq5+np6Thy5AiaNGkCNzc3hIeH48qVK9i4cSOAshmmli9fjrCwMEydOhVJSUlYt26dxmxSM2fOxFNPPYUlS5bg2Wefxffff49ffvkFBw4cMHj7iIioIo5oEBGR3h0+fBhdu3ZF165dAQBhYWHo2rUr3n//fQBAZmYmMjIy1PU9PT0RHx+PPXv2oEuXLvjggw/w+eef44UXXlDX8fPzw9atW7F+/Xp07twZGzZsQFxcHHr27GnYxhERUaXq3ToaeXl5sLe3R25uLq/FJaI6if2cdvh+EVFdJ1U/xxENIiIiIiLSOSYaRERERESkc0w0iIiIiIhI5yRNNPbt24fhw4fDxcUFMpkM33333SO32bt3L7y9vWFlZYVWrVph5cqV+g+UiIiIiIi0ImmiUVBQgCeeeALLly+vVv309HQMGTIEvXv3RmpqKt59913MmDED27dv13OkRERERESkDUnX0Rg8eDAGDx5c7forV66Em5sboqKiAABeXl44fPgw/vOf/2hMeUhERERERNIyqQX7kpKSEBAQoFE2cOBArFu3DiUlJerVYu9XVFSEoqIi9fO8vDy9x0mPdq9EibQbBXo/TmbuXWTl3YMMMhy9fBtKlYBMpvfDEulMm+YN8epTraUOg4iISGsmlWhkZWXB0dFRo8zR0RGlpaXIzs6Gs7NzhW0iIiKwcOFCQ4VodA5fuInsO0VVvp566XaN9nuroBhHL+fCztoCj/q7/fDFW1CqBCzN/71Sr6hUVaPj1pRMBpSvGNPVrZFBj01UG9YWcqlDICIiqhGTSjQAQPbAz9Hl6w0+WF4uPDwcYWFh6ud5eXlwdXXVX4A1pFQJlKqq/uP78q27+OjHUxp/rJe7evsuzt8ogJWFHOZm/74PWXn3qn18TwcbreItValwu7AErk0aoKHlw/8ZjWhkDaVKwNu9sUZ5Q0tztGneUKvj1oRbkwZobKPQ+3GIiIiI6F8mlWg4OTkhKytLo+z69eswNzdH06ZNK93G0tISlpaWug9GpQQuJgJ3rgENHQF3P8BMu18eNx28iC8TL0Auk+H0tfxqbfOEayM0sta8RMy+gQLuTQX6tmsOuZlmwlWqUmFMdzfYWlX9UdtbW1SZqBERERER1YRJJRq+vr7473//q1G2e/du+Pj4VHp/ht6c/AH4+R0g7+q/ZXYuwKAlQIcR6iKVSmDznxfx0/EsyGTAoQtllxBZmZtBJYC7JUoAZddgv9TDFS0bN4CzvVWlhxQCaNXMBl3dGlf6OhERERGRMZE00bhz5w7OnTunfp6eno4jR46gSZMmcHNzQ3h4OK5cuYKNGzcCAIKDg7F8+XKEhYVh6tSpSEpKwrp167BlyxbDBX3yB+CbCQCEZnleZln56I2422Yo1u5Pw7KEM+qXh3V2RkAHR5QqBXw8ypKFYqUKo7xborlt5ckFERERERm3hJPXEL7jmPpyfmOkvKf/CXgqI2micfjwYfTt21f9vPxeiokTJ2LDhg3IzMxERkaG+nVPT0/Ex8cjNDQUK1asgIuLCz7//HPDTW2rUpaNZDyYZAAABASAzLhZeLJIBtU/S5Q80dIe0S97o0Uja8PESEREREQ1dj3vHg5duFXt+rtOZKGgqBSv92ujx6hq525BPv6W4LgyYczplx7k5eXB3t4eubm5sLOz027j9P3Al8MeWW2FexTa9RyCZ7ya894HIjK4WvVz9RDfLyK6X/iOo9iSfEmrbbyc7fDTzN56iqj2pOrnTOoeDcnduVatatN9bIEOjo+uSEREREQGd/xKLj768RSUlfzennbjDrq4NsKmKT2qvT8rTkVeKSYa2mhYzeShuvWIiIiIyKAu3yrET8czcTA9B891aVHh9RaNrPF0u2awtTLgREN1FBMNbbj7AXYuEHlXq1ikTlY2+5S7n4EDIyIiIqJHycgpxFOf/A4AaNzAAp8GdpE2oDqOiYY2zOTAoCUQceMhAGguWfHPk0Efa72eBhERERHp1/+OXsWPRzMBAJ+M6gy/Ng4SR1T3VVxmmh4qrVk/vFYyC3csm2u+YOcCjN6osY4GERERET2cSiWgNMBj1d40HEzLQa9WTTCggyNnBDUAjmhoKWbPeexS9cC7U9+E3Z2/a7UyOBEREVF9drOgGL2X/IaCYqVBjjfB1x2Lnu1okGMREw2tfXfkClo0soZ7MzugmfFOY0ZERESkS7cKivHfo1ehVOluZYTsO0UoKFbiRe+W6O7ZRGf7rUrvx3i5lCEx0dBCYXEpSpQC/m2aSh0KERERkUH971gm3v/+BKx1PJVrUxsF3uj3GNyaNtDpfkl6TDS0kJ5dtnz74E7OEkdCREREZFhf/5kBADj1wSCJIyFTwZvBtXA6Kx8A4NaEGTcRERHVHzfyi3AqMw8u9lZSh0ImhImGFi7dvAsA8GhqI3EkRERERIbz/vfHAQAveLeUOBIyJbx0SguZuXfRQCGH3Kzy5fqIiIiITFXcoQz8cup6pa+lZtxCpxb2CO3f1sBRkSljoqEFS3MzWJpzEIiIiIjqFpVKIHrPeRSXqtDB2a7C60+0bITnuraAGX9sJS0w0dBCsVIFV96fQURERHXMf3afxsWcQrzcyw0fPtdJ6nCojmCioYXiUgGFnCMaREREZPrOXb+DHX9dhgCw5/QNAMBbAe2kDYrqFCYaWsi4WQBzOYcMiYiIyPR9m3IJq/amwf2f9Sum9WmFRg0UEkdFdQkTDS3YWlngev49qcMgIiIiqpYSpQqDovbhWl5RhdeKSpVo07whfgnrI0FkVB/wOiAtFJUq4c6pbYmIaiw6Ohqenp6wsrKCt7c39u/f/9D6K1asgJeXF6ytrdGuXTts3LixQp2oqCi0a9cO1tbWcHV1RWhoKO7d449CVH9dvlWI7SmXsT3lMr45fAnnbxQgoIMjZvV/TOPxzqD2+ODZjlKHS3UYRzS0cCG7ED09uVANEVFNxMXFYdasWYiOjoa/vz9WrVqFwYMH4+TJk3Bzc6tQPyYmBuHh4VizZg26d++O5ORkTJ06FY0bN8bw4cMBAJs3b8acOXMQGxsLPz8/nDlzBpMmTQIAfPrpp4ZsHpHRiPrlLLalXFY/l5vJMLanG3w8mkgYFdVHTDS0YGdtgbx7pVKHQURkkiIjIzFlyhQEBQUBKBuJ2LVrF2JiYhAREVGh/qZNmzBt2jQEBgYCAFq1aoWDBw9iyZIl6kQjKSkJ/v7+GDt2LADAw8MDL730EpKTkw3UKiJp/HEuG5/sOg1RyWsXcwrQw6MJvgrqCQCQyQALTmZDEmCioQUhBFo04ogGEZG2iouLkZKSgjlz5miUBwQEIDExsdJtioqKYGWl2edaW1sjOTkZJSUlsLCwwJNPPomvvvoKycnJ6NGjB9LS0hAfH4+JEydWGUtRURGKiv69Xj0vL68WLSPSj2t595CVW/UlgP/9+ypOZ+Xjua4uFV7r4GyLp9s1h4Jrf5HEmGhoQakSkJvxS0tEpK3s7GwolUo4OjpqlDs6OiIrK6vSbQYOHIi1a9fiueeeQ7du3ZCSkoLY2FiUlJQgOzsbzs7OGDNmDG7cuIEnn3wSQgiUlpbitddeq5DQ3C8iIgILFy7UafuIdO25FX8g8yGJBgC0ad4QEc93NlBERNpjoqGFskRD6iiIiEyXTKY5RbgQokJZuXnz5iErKwu9evWCEAKOjo6YNGkSli5dCrlcDgDYs2cPPvroI0RHR6Nnz544d+4cZs6cCWdnZ8ybN6/S/YaHhyMsLEz9PC8vD66urjpqIVHtlSpVyMy9h1f8PTHKu2WV9ZzseZUFGTcmGlpQCo5oEBHVhIODA+RyeYXRi+vXr1cY5ShnbW2N2NhYrFq1CteuXYOzszNWr14NW1tbODg4AChLRsaPH6++76NTp04oKCjAq6++irlz58Kskj7b0tISlpaWOm4hkW6UKlU4f6MAAODaxBodXOwkjoio5vhXsxZKlRzRICKqCYVCAW9vbyQkJGiUJyQkwM/P76HbWlhYoGXLlpDL5di6dSuGDRumTiAKCwsrJBNyuRxCCAhR2W2yRMatzyd7MDBqHwCgYwt7iaMhqh2OaGhBJQTkVQzxExHRw4WFhWH8+PHw8fGBr68vVq9ejYyMDAQHBwMou6TpypUr6rUyzpw5g+TkZPTs2RO3bt1CZGQkjh8/ji+//FK9z+HDhyMyMhJdu3ZVXzo1b948jBgxQn15FZGxK1Wq8HVyBgqKlLiaexeBPq7o38ERXV0bSR0aUa0w0dBCZu49mJkx0SAiqonAwEDk5ORg0aJFyMzMRMeOHREfHw93d3cAQGZmJjIyMtT1lUolli1bhtOnT8PCwgJ9+/ZFYmIiPDw81HXee+89yGQyvPfee7hy5QqaNWuG4cOH46OPPjJ084hq7FRmPt7//gRsLc3R1EaB57q2gG/rplKHRVRrMlHPxpbz8vJgb2+P3Nxc2Nlpd91jp/m78KKPK94f3kFP0RER1V5t+rn6iO8X6dL73x/HLyevabVNsVKF7DvF+Glmb3g5898g6Z5U/RxHNLRgLpehmS1vICQiIqrzVErgYiJw5xrQ0BFw9wPMqr4cr6hUiaTzOfjt/67DwdYST7dtptXhGlqZ47HmDWsbNZFRYaJBREREdL+TPwA/vwPkXf23zM4FGLQE6DCi0k1+Pp6FmVuPAABG+7hixjOPGSBQIuPGRIOIiIio3MkfgG8mAHjgyvK8zLLy0RuBDiPw+a9ncejCTfXL5at4J899Bs0a8uoHIoCJBhEREVEZlbJsJOPBJAMAICAggzL+HVx2eBpf/5kBG0s52jnZAgBsrRqin1dzNLflInpE5ZhoEBEREQFl92Tcf7nUA2QQML9zFXOiViFL1QGzB7bD9L5tDBggkWlhokFEREQElN34XQ0fPOOAm5698ATXuSB6KCYaREREREDZ7FLV8FirNoAn17kgehQzqQMgIiIiMgrufmWzS6GqxXllgF2LsnpE9EhMNLRQr1Y2JCIiqm/M5GVT2AJQVXjxn+Rj0McPXU+DiP7FRENLsqp+5CAiIiLT12EEMHojruOBS6PsXNRT2xJR9fAeDSIiIqJ/bEu5jLX7GyGt+HN82C0fo9tZVGtlcCKqiIkGERER0T9+PHoVOQXFGOfriW493YHmDaUOichkMdEgIiIi+sfprHw0tDTH/OGPSx0KkcnjPRpEREREAIQQuJp7Dz09m0gdClGdwESDiIiICMDtwhIAgJUF78Ug0gUmGkRERFTvHb+Si64fJAAAvN0bSxwNUd3AezSIiIio3tp35gb+yriFizmFAIAPn+uIgMert0I4ET0cEw0tCK7YR0REVKcs+fn/kHajAHbW5mjvZIsXurWEpTkvnSLSBckvnYqOjoanpyesrKzg7e2N/fv3P7T+5s2b8cQTT6BBgwZwdnbG5MmTkZOTY6BoiYiIyNSVKlUY+vl+eH+QgP/Lykdgd1f8+W5//DzrKVgrmGQQ6YqkiUZcXBxmzZqFuXPnIjU1Fb1798bgwYORkZFRaf0DBw5gwoQJmDJlCk6cOIFvv/0Whw4dQlBQkMFi5sLgREREpqu4VIWfjmfhxNU8+LVxQNiAtpjo5yF1WER1kqSJRmRkJKZMmYKgoCB4eXkhKioKrq6uiImJqbT+wYMH4eHhgRkzZsDT0xNPPvkkpk2bhsOHDxs4ciIiIjJFB87dwBtbUiGTAeN6umF63zbwdLCROiyiOkmyRKO4uBgpKSkICAjQKA8ICEBiYmKl2/j5+eHy5cuIj4+HEALXrl3Dtm3bMHTo0CqPU1RUhLy8PI0HERER1R8qlcCsrakYvSoJEfH/BwBImvMMerVqKnFkRHWbZIlGdnY2lEolHB01Z3ZwdHREVlZWpdv4+flh8+bNCAwMhEKhgJOTExo1aoQvvviiyuNERETA3t5e/XB1ddVpO4iIiMi4FZWq8N2Rq1CpBDq1sMe0Pq3gaGcpdVhEdZ7kN4PLZJp3PQghKpSVO3nyJGbMmIH3338fKSkp+Pnnn5Geno7g4OAq9x8eHo7c3Fz149KlSzqNn4iIiIzbnaJSAMAL3i0RGdgF4YO9qvxbg4h0R7LpbR0cHCCXyyuMXly/fr3CKEe5iIgI+Pv7Y/bs2QCAzp07w8bGBr1798aHH34IZ2fnCttYWlrC0pK/WhAREdVXBf8kGu5NGkgcCVH9ItmIhkKhgLe3NxISEjTKExIS4OfnV+k2hYWFMDPTDFkuL5uGTnCRCyIiIqpEUakKAGDFqWuJDErSS6fCwsKwdu1axMbG4tSpUwgNDUVGRob6Uqjw8HBMmDBBXX/48OHYsWMHYmJikJaWhj/++AMzZsxAjx494OLiovd4mcwQERGZni3JZdPm2yi4TjGRIUn6jQsMDEROTg4WLVqEzMxMdOzYEfHx8XB3dwcAZGZmaqypMWnSJOTn52P58uV488030ahRI/Tr1w9LliyRqglERERkpO6VKLH9r8s4diUXANDWsaHEERHVL5Kn9iEhIQgJCan0tQ0bNlQoe+ONN/DGG2/oOSoiIiIydYnnszF353FYWZjh+W4teAM4kYFJnmiYGvZRREREpuFucdm9GYfm9oetlYXE0RDVP5JPb0tERESkDzfy7wEALM15EziRFJhoEBGRwURHR8PT0xNWVlbw9vbG/v37H1p/xYoV8PLygrW1Ndq1a4eNGzdWqHP79m1Mnz4dzs7OsLKygpeXF+Lj4/XVBDIhhy/eAgBYyHk5ApEUeOkUEREZRFxcHGbNmoXo6Gj4+/tj1apVGDx4ME6ePAk3N7cK9WNiYhAeHo41a9age/fuSE5OxtSpU9G4cWMMHz4cAFBcXIwBAwagefPm2LZtG1q2bIlLly7B1tbW0M0jI5R4PgftnWx5bwaRRJhoEBGRQURGRmLKlCkICgoCAERFRWHXrl2IiYlBREREhfqbNm3CtGnTEBgYCABo1aoVDh48iCVLlqgTjdjYWNy8eROJiYmwsCi7Br985kKi/Hsl8HSwkToMonqLl04REZHeFRcXIyUlBQEBARrlAQEBSExMrHSboqIiWFlZaZRZW1sjOTkZJSUlAIAffvgBvr6+mD59OhwdHdGxY0csXrwYSqWyyliKioqQl5en8aC659LNQpQoBfxbN5U6FKJ6i4kGERHpXXZ2NpRKJRwdHTXKHR0dkZWVVek2AwcOxNq1a5GSkgIhBA4fPozY2FiUlJQgOzsbAJCWloZt27ZBqVQiPj4e7733HpYtW4aPPvqoylgiIiJgb2+vfri6uuquoWQ0fvu/6wCA3m2bSRwJUf3FREMLXBeciKh2HrxWXghR5fXz8+bNw+DBg9GrVy9YWFjg2WefxaRJkwAAcnnZLEIqlQrNmzfH6tWr4e3tjTFjxmDu3LmIiYmpMobw8HDk5uaqH5cuXdJN48io7D9bloy24qVTRJJhokFERHrn4OAAuVxeYfTi+vXrFUY5yllbWyM2NhaFhYW4cOECMjIy4OHhAVtbWzg4OAAAnJ2d0bZtW3XiAQBeXl7IyspCcXFxpfu1tLSEnZ2dxoPqltSMW/jl1DU83a4Zmja0lDoconqLiYaWZODMFURE2lIoFPD29kZCQoJGeUJCAvz8/B66rYWFBVq2bAm5XI6tW7di2LBhMDMrO335+/vj3LlzUKlU6vpnzpyBs7MzFAqF7htCJuFiTiEA4I1+bSSOhKh+Y6JBREQGERYWhrVr1yI2NhanTp1CaGgoMjIyEBwcDKDskqYJEyao6585cwZfffUVzp49i+TkZIwZMwbHjx/H4sWL1XVee+015OTkYObMmThz5gx+/PFHLF68GNOnTzd4+8h4iH8udn7cxV7iSIjqN05vS0REBhEYGIicnBwsWrQImZmZ6NixI+Lj49XT0WZmZiIjI0NdX6lUYtmyZTh9+jQsLCzQt29fJCYmwsPDQ13H1dUVu3fvRmhoKDp37owWLVpg5syZeOeddwzdPDIS739/HHtO35A6DCICEw0iIjKgkJAQhISEVPrahg0bNJ57eXkhNTX1kfv09fXFwYMHdREembiiUiU2Jl1E55b2GO3TFlYW8kdvRER6w0SDiIiI6oTVe9MAAC90a4mJfh7SBkNEvEeDiIiI6oa07ALIZMDLvbg6PJExYKJBREREdYK9tQVsLc0hN+MMkUTGgImGNrhiHxERkdEqKlXBgwv0ERkNJhpERERk8k5ezcOW5Awo5PzThshY1OjbWFpail9++QWrVq1Cfn4+AODq1au4c+eOToMjIiJpsb8nU7FizzkAQFe3RtIGQkRqWs86dfHiRQwaNAgZGRkoKirCgAEDYGtri6VLl+LevXtYuXKlPuI0GjJe9klE9UR97+/JtPx4NBP+bZpi7tAOUodCRP/QekRj5syZ8PHxwa1bt2Btba0uHzlyJH799VedBkdERNJhf0+morC4FADQslEDiSMhovtpPaJx4MAB/PHHH1AoFBrl7u7uuHLlis4CIyIiabG/J1Px7eHLAIC+7ZtLHAkR3U/rEQ2VSgWlUlmh/PLly7C1tdVJUEREJD3292Qq1h1IBwAM6ugkcSREdD+tE40BAwYgKipK/Vwmk+HOnTuYP38+hgwZosvYiIhIQuzvyRQIIZBxsxAeTXnZFJGx0frSqU8//RR9+/ZFhw4dcO/ePYwdOxZnz56Fg4MDtmzZoo8YiYhIAuzvyRRs/6vsMr6Jfh7SBkJEFWidaLi4uODIkSPYunUrUlJSoFKpMGXKFIwbN07jZsG6iOv1EVF9Up/7ezINJUoVlv78fwCAsT3dJI6GiB6kdaKxb98++Pn5YfLkyZg8ebK6vLS0FPv27cNTTz2l0wCJiEga7O/J2J2/cQfX84vwuIsdLM3lUodDRA/Q+h6Nvn374ubNmxXKc3Nz0bdvX50ERURE0mN/T8auVFl2rcHHz3eWOBIiqozWiYYQArJKVq3LycmBjY2NToIiIiLpsb8nYyf+uabZTOu/ZojIEKp96dTzzz8PoGzWkUmTJsHS0lL9mlKpxNGjR+Hn56f7CImIyKDY35OpUP6TaZhVkhATkfSqnWjY29sDKPuFy9bWVuNGQIVCgV69emHq1Km6j5CIiAyK/T2ZCqWqLNGQmzHRIDJG1U401q9fDwDw8PDAW2+9xWFzIqI6iv09mYqColIAHNEgMlZazzo1f/58fcRBRERGhv09Gbsfj2YCAOystP5zhogMoEbfzG3btuGbb75BRkYGiouLNV7766+/dBIYERFJj/09GbOLNwvgZGeF5nZWUodCRJXQep6Gzz//HJMnT0bz5s2RmpqKHj16oGnTpkhLS8PgwYP1ESMREUmA/T0ZO4W5HLxqish4aZ1oREdHY/Xq1Vi+fDkUCgXefvttJCQkYMaMGcjNzdVHjEZDCK4NTkT1R33u78k07DtzAx5NeQ8RkbHSOtHIyMhQT2tobW2N/Px8AMD48eOxZcsW3UZHRESSYX9Pxiw14xYAoKtbI2kDIaIqaZ1oODk5IScnBwDg7u6OgwcPAgDS09P5iz8RUR3C/p6MWfSe8wCAp9o2kzgSIqqK1olGv3798N///hcAMGXKFISGhmLAgAEIDAzEyJEjdR6gsalslVwiorqovvf3ZNyEAJ5p3xy9WjWVOhQiqoLWs06tXr0aKpUKABAcHIwmTZrgwIEDGD58OIKDg3UeIBERSYP9PRmzCzkFcGvSQOowiOghtE40zMzMYGb270DI6NGjMXr0aADAlStX0KJFC91FR0REkmF/T8YsPbuA62cQGTmtL52qTFZWFt544w20adNGF7sjIiIjxf6ejIVCbobBHZ2lDoOIHqLaicbt27cxbtw4NGvWDC4uLvj888+hUqnw/vvvo1WrVjh48CBiY2P1GSsRERkA+3sydkII3C1RwlzO+yaJjFm1E413330X+/btw8SJE9GkSROEhoZi2LBhOHDgAH766SccOnQIL730kj5jJSIiA9Bnfx8dHQ1PT09YWVnB29sb+/fvf2j9FStWwMvLC9bW1mjXrh02btxYZd2tW7dCJpPhueeeq1FsZDoSTl4DANgoeOkUkTGr9jf0xx9/xPr169G/f3+EhISgTZs2aNu2LaKiovQYnnHhZI5EVB/oq7+Pi4vDrFmzEB0dDX9/f6xatQqDBw/GyZMn4ebmVqF+TEwMwsPDsWbNGnTv3h3JycmYOnUqGjdujOHDh2vUvXjxIt566y307t27VjGSabh9twQA8GxXF4kjIaKHqfaIxtWrV9GhQwcAQKtWrWBlZYWgoCC9BUZERNLQV38fGRmJKVOmICgoCF5eXoiKioKrqytiYmIqrb9p0yZMmzYNgYGBaNWqFcaMGYMpU6ZgyZIlGvWUSiXGjRuHhQsXolWrVrWOk4xfqbLspz+FXCe3mhKRnlT7G6pSqWBhYaF+LpfLYWNjU+sAtB1GLyoqwty5c+Hu7g5LS0u0bt2a1woTEemQPvr74uJipKSkICAgQKM8ICAAiYmJlW5TVFQEKysrjTJra2skJyejpKREXbZo0SI0a9YMU6ZMqVYsRUVFyMvL03iQaYk7lAGAa1sRGbtqXzolhMCkSZNgaWkJALh37x6Cg4MrnHx27NhR7YNrO4wOlE2veO3aNaxbtw5t2rTB9evXUVpaWu1jEhHRw+mjv8/OzoZSqYSjo6NGuaOjI7KysirdZuDAgVi7di2ee+45dOvWDSkpKYiNjUVJSQmys7Ph7OyMP/74A+vWrcORI0eqHUtERAQWLlxY7fpkfCzN5WjnaCt1GET0CNVONCZOnKjx/OWXX671we8fRgeAqKgo7Nq1CzExMYiIiKhQ/+eff8bevXuRlpaGJk2aAAA8PDxqHYc2+NsJEdV1+ujvyz34C7QQospfpefNm4esrCz06tULQgg4Ojpi0qRJWLp0KeRyOfLz8/Hyyy9jzZo1cHBwqHYM4eHhCAsLUz/Py8uDq6trzRpEkigqVaKrWyOpwyCiR6h2orF+/XqdHrh8GH3OnDka5Q8bRv/hhx/g4+ODpUuXYtOmTbCxscGIESPwwQcfwNrautJtioqKUFRUpH7OIXIioofTdX8PAA4ODpDL5RVGL65fv15hlKOctbU1YmNjsWrVKly7dg3Ozs5YvXo1bG1t4eDggKNHj+LChQsaN4aXr2Rubm6O06dPo3Xr1hX2a2lpqR6tIdNzp6gUf1/ORaeW9lKHQkSPINm8cDUZRk9LS8OBAwdgZWWFnTt3Ijs7GyEhIbh582aV92lwiJyISHoKhQLe3t5ISEjAyJEj1eUJCQl49tlnH7qthYUFWrZsCaBsCtthw4bBzMwM7du3x7FjxzTqvvfee8jPz8dnn33GUYo6KvP2XQDgpVNEJkDyCai1GUZXqVSQyWTYvHkz7O3LfsmIjIzEqFGjsGLFikpHNThETkRkHMLCwjB+/Hj4+PjA19cXq1evRkZGBoKDgwGU9ddXrlxRr5Vx5swZJCcno2fPnrh16xYiIyNx/PhxfPnllwAAKysrdOzYUeMYjRo1AoAK5VR3HL54CwDg7d5E4kiI6FEkSzRqMozu7OyMFi1aqJMMAPDy8oIQApcvX8Zjjz1WYRsOkRMRGYfAwEDk5ORg0aJFyMzMRMeOHREfHw93d3cAQGZmJjIyMtT1lUolli1bhtOnT8PCwgJ9+/ZFYmKiwe/NI+MiNyv7MbKdE0c0iIydZIlGTYbR/f398e233+LOnTto2LAhgLJfvMzMzNTD6vokuGIfEVGthISEICQkpNLXNmzYoPHcy8sLqampWu3/wX1QHcRzMZHJkHSlm7CwMKxduxaxsbE4deoUQkNDKwyjT5gwQV1/7NixaNq0KSZPnoyTJ09i3759mD17Nl555ZUqbwYnIiKiuuPMtXwAnAWSyBTUKNHYtGkT/P394eLigosXLwIom5r2+++/12o/gYGBiIqKwqJFi9ClSxfs27fvocPoDRs2REJCAm7fvg0fHx+MGzcOw4cPx+eff16TZhAR0SPoqr8n0hVbKwso5GYwM2OqQWTstE40YmJiEBYWhiFDhuD27dtQKpUAym7Ai4qK0jqAkJAQXLhwAUVFRUhJScFTTz2lfm3Dhg3Ys2ePRv327dsjISEBhYWFuHTpEpYtW8bRDCIiPdB1f0+kC0qVCs1see8lkSnQOtH44osvsGbNGsydOxdyuVxd7uPjU2GaQSIiMl3s78kYfZ18CSVKldRhEFE1aJ1opKeno2vXrhXKLS0tUVBQoJOgjFkVM+8SEdU59b2/J+OUU1AEDwcbqcMgomrQOtHw9PTEkSNHKpT/9NNP6NChgy5iIiIiI8D+noxNiVIFIYDWzRpKHQoRVYPW09vOnj0b06dPx7179yCEQHJyMrZs2YKIiAisXbtWHzESEZEE2N+TsVH9M898D8/GEkdCRNWhdaIxefJklJaW4u2330ZhYSHGjh2LFi1a4LPPPsOYMWP0ESMREUmA/T0REdVGjRbsmzp1KqZOnYrs7GyoVCo0b95c13EREZERYH9PREQ1pfU9GgsXLsT58+cBAA4ODvXqpCO4HCkR1SP1ub8n4yR4GiYyKVonGtu3b0fbtm3Rq1cvLF++HDdu3NBHXEREJDH292Rs8u6VAACKSzm9LZEp0DrROHr0KI4ePYp+/fohMjISLVq0wJAhQ/D111+jsLBQHzESEZEE2N+TsSlVlg1pONlzoV4iU6B1ogEAjz/+OBYvXoy0tDT8/vvv8PT0xKxZs+Dk5KTr+IiISELs78mYFBaXAgAszLioFZEpqFGicT8bGxtYW1tDoVCgpKREFzEZNXZtRFRf1bf+nozPtbwiAIClRa3/fCEiA6jRNzU9PR0fffQROnToAB8fH/z1119YsGABsrKydB0fERFJiP09GZPyH/uaNbSSNA4iqh6tp7f19fVFcnIyOnXqhMmTJ6vnVSciorqF/T0Zm/JJp2S8vIDIJGidaPTt2xdr167F448/ro94iIjISLC/J2NTvjK4Ge/RIDIJWicaixcv1kccRERkZNjfk7G5kF0AgPdLEpmKaiUaYWFh+OCDD2BjY4OwsLCH1o2MjNRJYMaICwURUV3H/p6MWdE/62c42vEeDSJTUK1EIzU1VT3DSGpqql4DIiIi6bC/J2N2MjMPACDnpVNEJqFaicbvv/9e6f8TEVHdwv6ejFlTGwWa2iikDoOIqknr6W1feeUV5OfnVygvKCjAK6+8opOgiIhIeuzvyRjZN7CQOgQiqiatE40vv/wSd+/erVB+9+5dbNy4USdBERGR9Njfk7G5fOsuikpUUodBRNVU7Vmn8vLyIISAEAL5+fmwsvr3RiylUon4+Hg0b95cL0EaExkn7yaiOo79PRmrJjYKKFWcmYXIVFQ70WjUqBFkMhlkMhnatm1b4XWZTIaFCxfqNDgiIjI89vdkrFRCwNHOUuowiKiaqp1o/P777xBCoF+/fti+fTuaNGmifk2hUMDd3R0uLi56CZKIiAyH/T0ZK6VKcLE+IhNS7USjT58+AID09HS4ubnxEiIiojqK/T0ZK5UAzPjvkchkVCvROHr0KDp27AgzMzPk5ubi2LFjVdbt3LmzzoIjIiLDYn9PxkylEpAz0SAyGdVKNLp06YKsrCw0b94cXbp0gUwmg6hkmWyZTAalUqnzII0Fbz8jorqO/T0ZM6UQYJ5BZDqqlWikp6ejWbNm6v8nIqK6if09GTOlSnBVcCITUq1Ew93dvdL/JyKiuoX9PRkzIcBEg8iE1GjBvh9//FH9/O2330ajRo3g5+eHixcv6jQ4IiKSjj76++joaHh6esLKygre3t7Yv3//Q+uvWLECXl5esLa2Rrt27SosFLhmzRr07t0bjRs3RuPGjdG/f38kJyfXKDYyfldz73JyAiITonWisXjxYlhbWwMAkpKSsHz5cixduhQODg4IDQ3VeYBERCQNXff3cXFxmDVrFubOnYvU1FT07t0bgwcPRkZGRqX1Y2JiEB4ejgULFuDEiRNYuHAhpk+fjv/+97/qOnv27MFLL72E33//HUlJSXBzc0NAQACuXLlSs0aTUWugkON2YbHUYRBRNclEZXf5PUSDBg3wf//3f3Bzc8M777yDzMxMbNy4ESdOnMDTTz+NGzdu6CtWncjLy4O9vT1yc3NhZ2en1bZt3/sJ7w31wgRfD/0ER0SkA7Xp5+6n6/6+Z8+e6NatG2JiYtRlXl5eeO655xAREVGhvp+fH/z9/fHJJ5+oy2bNmoXDhw/jwIEDlR5DqVSicePGWL58OSZMmFCtuHT1fpH+Ba5KgrO9FaLGdJU6FCKTIlU/p/WIRsOGDZGTkwMA2L17N/r37w8AsLKywt27d3UbHRERSUaX/X1xcTFSUlIQEBCgUR4QEIDExMRKtykqKoKVlZVGmbW1NZKTk1FSUlLpNoWFhSgpKdFYZLCy/ebl5Wk8yDRczCmEhVzrP12ISCJaf1sHDBiAoKAgBAUF4cyZMxg6dCgA4MSJE/Dw8NB1fEREJBFd9vfZ2dlQKpVwdHTUKHd0dERWVlal2wwcOBBr165FSkoKhBA4fPgwYmNjUVJSguzs7Eq3mTNnDlq0aKFOiioTEREBe3t79cPV1VWrtpB0svLu4U5RqdRhEFE1aZ1orFixAr6+vrhx4wa2b9+Opk2bAgBSUlLw0ksv6TxAIiKShj76+wdv5BVCVHlz77x58zB48GD06tULFhYWePbZZzFp0iQAgFwur1B/6dKl2LJlC3bs2FFhJOR+4eHhyM3NVT8uXbpUo7aQ4SnMzdDDs+rRKiIyLtWa3vZ+jRo1wvLlyyuUL1y4UCcBGTWu2EdE9Ygu+3sHBwfI5fIKoxfXr1+vMMpRztraGrGxsVi1ahWuXbsGZ2dnrF69Gra2tnBwcNCo+5///AeLFy/GL7/88sgVyy0tLWFpaal1G0h6xaUqTm9LZEK0TjQA4Pbt21i3bh1OnToFmUwGLy8vTJkyBfb29rqOj4iIJKSr/l6hUMDb2xsJCQkYOXKkujwhIQHPPvvsQ7e1sLBAy5YtAQBbt27FsGHDYGb274D8J598gg8//BC7du2Cj4+PVnGR6ci/V3ZfTmExV6QnMhVaXzp1+PBhtG7dGp9++ilu3ryJ7OxsfPrpp2jdujX++usvfcRIREQS0HV/HxYWhrVr1yI2NhanTp1CaGgoMjIyEBwcDKDskqb7Z4o6c+YMvvrqK5w9exbJyckYM2YMjh8/jsWLF6vrLF26FO+99x5iY2Ph4eGBrKwsZGVl4c6dO7V/A8ioFBSVJRhtmjWUOBIiqi6tRzRCQ0MxYsQIrFmzBubmZZuXlpYiKCgIs2bNwr59+3QeJBERGZ6u+/vAwEDk5ORg0aJFyMzMRMeOHREfH69egTwzM1NjTQ2lUolly5bh9OnTsLCwQN++fZGYmKhxI3p0dDSKi4sxatQojWPNnz8fCxYsqFnDySiVKFUAACuLivfnEJFx0nodDWtra6SmpqJ9+/Ya5SdPnoSPjw8KCwt1GqCu1Wodjbk/4b1hXEeDiIybruZLN/X+vrq4joZpSDqfg5fWHMTXQT3h18bh0RsQkZrJrKNhZ2dX6Squly5dgq2trU6CIiIi6bG/J2Ny5XbZ2i0ujawljoSIqkvrRCMwMBBTpkxBXFwcLl26hMuXL2Pr1q0ICgqqF9Pbcq4LIqov6nt/T8bl7LV8AEDThgqJIyGi6tL6Ho3//Oc/kMlkmDBhAkpLyxbNsbCwwGuvvYaPP/5Y5wESEZE02N+TMbGQm6FFI2vYWllIHQoRVZPWiYZCocBnn32GiIgInD9/HkIItGnTBg0aNNBHfEREJBH290REVBvVvnSqsLAQ06dPR4sWLdC8eXMEBQXB2dkZnTt3rjcnHcEV+4ioHmB/T0REulDtRGP+/PnYsGEDhg4dijFjxiAhIQGvvfaaPmMjIiIJsL8nY3TxZiGUKv7gR2RKqn3p1I4dO7Bu3TqMGTMGAPDyyy/D398fSqUScjnntCYiqivY35MxsrUyV68OTkSmodojGpcuXULv3r3Vz3v06AFzc3NcvXq1VgFER0fD09MTVlZW8Pb2xv79+6u13R9//AFzc3N06dKlVscnIiJN+urviWpDCKB1c64KTmRKqp1oKJVKKBSaU8qZm5urZyKpibi4OMyaNQtz585FamoqevfujcGDB1c6b/v9cnNzMWHCBDzzzDM1PjYREVVOH/09UW0JISCTcZJ5IlNS7UunhBCYNGkSLC0t1WX37t1DcHAwbGxs1GU7duyo9sEjIyMxZcoUBAUFAQCioqKwa9cuxMTEICIiosrtpk2bhrFjx0Iul+O7776r9vGIiOjR9NHfE9WWSgiYMc8gMinVTjQmTpxYoezll1+u8YGLi4uRkpKCOXPmaJQHBAQgMTGxyu3Wr1+P8+fP46uvvsKHH374yOMUFRWhqKhI/TwvL6/GMQMA+GsKEdVxuu7viXRBqQLkPAcTmZRqJxrr16/X6YGzs7OhVCrh6OioUe7o6IisrKxKtzl79izmzJmD/fv3w9y8eqFHRERg4cKFtY6XiKi+0HV/T6QLQgiYMdEgMinVvkdDXx683rKqazCVSiXGjh2LhQsXom3bttXef3h4OHJzc9WPS5cu1TpmIiIiMiyVELyogMjEaL0yuK44ODhALpdXGL24fv16hVEOAMjPz8fhw4eRmpqK119/HQCgUqkghIC5uTl2796Nfv36VdjO0tJS4zpjIiIiMj0qAch5kwaRSZFsREOhUMDb2xsJCQka5QkJCfDz86tQ387ODseOHcORI0fUj+DgYLRr1w5HjhxBz5499R6z4DpBREREksi9W8IRDSITI9mIBgCEhYVh/Pjx8PHxga+vL1avXo2MjAwEBwcDKLvs6cqVK9i4cSPMzMzQsWNHje2bN28OKyurCuVERERUt6Rl34GdlYXUYRCRFiRNNAIDA5GTk4NFixYhMzMTHTt2RHx8PNzd3QEAmZmZj1xTg4iIiOq+nDvF6O7eROowiEgLNbp0atOmTfD394eLiwsuXrwIoGwNjO+//17rfYWEhODChQsoKipCSkoKnnrqKfVrGzZswJ49e6rcdsGCBThy5IjWxyQiourRZX9PVBsNFOYoUfEaZiJTonWiERMTg7CwMAwZMgS3b9+GUqkEADRq1AhRUVG6jo+IiCTC/p6MidwMaOVg8+iKRGQ0tE40vvjiC6xZswZz586FXC5Xl/v4+ODYsWM6DY6IiKTD/p6MiRDgOhpEJkbrRCM9PR1du3atUG5paYmCggKdBGXM2MURUX1R3/t7Mi4qAXB2WyLTonWi4enpWel9ET/99BM6dOigi5iIiMgIsL8nYyK4YB+RydF61qnZs2dj+vTpuHfvHoQQSE5OxpYtWxAREYG1a9fqI0YiIpIA+3syJgKAjJkGkUnROtGYPHkySktL8fbbb6OwsBBjx45FixYt8Nlnn2HMmDH6iNFocK4LIqpP6nN/T8ZHxRENIpNTo3U0pk6diqlTpyI7OxsqlQrNmzfXdVxERGQE2N+TseDN4ESmp1YL9jk4OOgqDiIiMmLs70lqKiE4IQuRidE60fD09HzoNZJpaWm1CoiIiIwD+3syKhzRIDI5Wicas2bN0nheUlKC1NRU/Pzzz5g9e7au4iIiIomxvydjkl9Uyns0iEyM1onGzJkzKy1fsWIFDh8+XOuAiIjIOLC/J2OTe7dE6hCISAtar6NRlcGDB2P79u262h0RERkp9vckBXMzGZrbWUkdBhFpQWeJxrZt29CkSRNd7c5ocdiWiOq7+tLfk3FRCQE5T8JEJkXrRKNr167o1q2b+tG1a1c4Ozvj3XffxbvvvquPGImISAL66O+jo6Ph6ekJKysreHt7Y//+/Q+tv2LFCnh5ecHa2hrt2rXDxo0bK9TZvn07OnToAEtLS3To0AE7d+6sUWxkvIQQUAnAjHkGkUnR+h6N5557TuO5mZkZmjVrhqeffhrt27fXVVxGSQgu2UdE9Yeu+/u4uDjMmjUL0dHR8Pf3x6pVqzB48GCcPHkSbm5uFerHxMQgPDwca9asQffu3ZGcnIypU6eicePGGD58OAAgKSkJgYGB+OCDDzBy5Ejs3LkTo0ePxoEDB9CzZ88atZuMT/npl7NOEZkWrRKN0tJSeHh4YODAgXByctJXTEREJDF99PeRkZGYMmUKgoKCAABRUVHYtWsXYmJiEBERUaH+pk2bMG3aNAQGBgIAWrVqhYMHD2LJkiXqRCMqKgoDBgxAeHg4ACA8PBx79+5FVFQUtmzZopO4SXqqfzIN5hlEpkWrS6fMzc3x2muvoaioSF/xEBGREdB1f19cXIyUlBQEBARolAcEBCAxMbHSbYqKimBlpXnzr7W1NZKTk1FSUjb7UFJSUoV9Dhw4sMp9lu83Ly9P40HGTflPoiHntVNEJkXrezR69uyJ1NRUfcRCRERGRJf9fXZ2NpRKJRwdHTXKHR0dkZWVVek2AwcOxNq1a5GSkgIhBA4fPozY2FiUlJQgOzsbAJCVlaXVPgEgIiIC9vb26oerq2stW0f6xkuniEyT1vdohISE4M0338Tly5fh7e0NGxsbjdc7d+6ss+CIiEg6+ujvH1xpXAhR5erj8+bNQ1ZWFnr16gUhBBwdHTFp0iQsXboUcrm8RvsEyi6vCgsLUz/Py8tjsmHkeOkUkWmqdqLxyiuvICoqSn2t7IwZM9SvyWQydceuVCp1HyURERmMPvp7BwcHyOXyCiMN169frzAiUc7a2hqxsbFYtWoVrl27BmdnZ6xevRq2trZwcHAAADg5OWm1TwCwtLSEpaVltWMn6SlVvHSKyBRVO9H48ssv8fHHHyM9PV2f8RARkcT00d8rFAp4e3sjISEBI0eOVJcnJCTg2Weffei2FhYWaNmyJQBg69atGDZsGMzMyq789fX1RUJCAkJDQ9X1d+/eDT8/P53FTtJTqcr+y0uniExLtRON8qld3d3d9RaMKZCBnRwR1W366u/DwsIwfvx4+Pj4wNfXF6tXr0ZGRgaCg4MBlF3SdOXKFfVaGWfOnEFycjJ69uyJW7duITIyEsePH8eXX36p3ufMmTPx1FNPYcmSJXj22Wfx/fff45dffsGBAwd0GjtJq1hZlmkUFvOqCSJTotU9Gg+75pWIiOoOffT3gYGByMnJwaJFi5CZmYmOHTsiPj5endBkZmYiIyNDXV+pVGLZsmU4ffo0LCws0LdvXyQmJsLDw0Ndx8/PD1u3bsV7772HefPmoXXr1oiLi+MaGnVM+T0aTWwsJI6EiLShVaLRtm3bR558bt68WauAiIhIevrq70NCQhASElLpaxs2bNB47uXlVa1Zr0aNGoVRo0ZpHQuZjn/v0dB6skwikpBWicbChQthb2+vr1iMHtcFJ6L6or7392Rc1IkGr6wgMilaJRpjxoxB8+bN9RULEREZCfb3ZEzKEw0OaBCZlmp/ZXl/BhFR/cD+noxN+crg5sw0iExKtb+x5bOQEBFR3cb+nozNv/doSBwIEWml2pdOqconsSYiojqN/T0Zm7v/TGvLdTSITAt/GyAiIiKToOJgG5FJYaJBRERERq38Ho2GllrNYUNEEmOioSWO2hIRERkW79EgMk38yhIREZFRU09vy1/7iEwKEw0tcCIWIiIiw1OpOL0tkSniN5aIiIiMWikX7CMySfzKEhERkVErvxlcbsZLp4hMCRMNIiIiMmrX8+4BAOS8R4PIpDDRICIiIqMm+yfBsG9gIXEkRKQNJhpERERk1MpvBldwflsik8JvLBERERk1pRCQyf4d2SAi08BEg4iIiIyaSiVgzhvBiUwOEw0tsZsjIiIyrFKV4GJ9RCaIiQYREREZtVsFxVBx1Vwik8NEg4iIiIxasVKgRMlEg8jUMNEgIiIio2Yhl8HF3krqMIhIS0w0iIiIyKgJwRmniEyR5IlGdHQ0PD09YWVlBW9vb+zfv7/Kujt27MCAAQPQrFkz2NnZwdfXF7t27TJgtERERGRoKiFgJvlfLESkLUm/tnFxcZg1axbmzp2L1NRU9O7dG4MHD0ZGRkal9fft24cBAwYgPj4eKSkp6Nu3L4YPH47U1FQDR05ERESGohLgrFNEJkjSRCMyMhJTpkxBUFAQvLy8EBUVBVdXV8TExFRaPyoqCm+//Ta6d++Oxx57DIsXL8Zjjz2G//73vwaOnIiIiAxFQHB6eSITJFmiUVxcjJSUFAQEBGiUBwQEIDExsVr7UKlUyM/PR5MmTaqsU1RUhLy8PI0HERERmQ7BEQ0ikyRZopGdnQ2lUglHR0eNckdHR2RlZVVrH8uWLUNBQQFGjx5dZZ2IiAjY29urH66urrWKm/0cERGRYalUgudfIhMk+a1VD84iIYSo1swSW7ZswYIFCxAXF4fmzZtXWS88PBy5ubnqx6VLl2odMxERERmOAEc0iEyRuVQHdnBwgFwurzB6cf369QqjHA+Ki4vDlClT8O2336J///4PrWtpaQlLS8taxyu4IikREZEkVIIjGkSmSLIRDYVCAW9vbyQkJGiUJyQkwM/Pr8rttmzZgkmTJuHrr7/G0KFD9R0mERERSYz3aBCZJslGNAAgLCwM48ePh4+PD3x9fbF69WpkZGQgODgYQNllT1euXMHGjRsBlCUZEyZMwGeffYZevXqpR0Osra1hb28vWTuIiIhIf6p7WTURGRdJ79EIDAxEVFQUFi1ahC5dumDfvn2Ij4+Hu7s7ACAzM1NjTY1Vq1ahtLQU06dPh7Ozs/oxc+ZMqZpARERa0GaRVgDYvHkznnjiCTRo0ADOzs6YPHkycnJyNOpERUWhXbt2sLa2hqurK0JDQ3Hv3j19NoMM7FRmPi9hJjJBko5oAEBISAhCQkIqfW3Dhg0az/fs2aP/gIiISC/KF2mNjo6Gv78/Vq1ahcGDB+PkyZNwc3OrUP/AgQOYMGECPv30UwwfPhxXrlxBcHAwgoKCsHPnTgBlicicOXMQGxsLPz8/nDlzBpMmTQIAfPrpp4ZsHumRjaUcWXlMHolMjeSzThERUf2g7SKtBw8ehIeHB2bMmAFPT088+eSTmDZtGg4fPqyuk5SUBH9/f4wdOxYeHh4ICAjASy+9pFGH6ob2TrZSh0BEWmKiQUREeleTRVr9/Pxw+fJlxMfHQwiBa9euYdu2bRoTgTz55JNISUlBcnIyACAtLQ3x8fEPnSyEC7maHgGuY0VkiiS/dIqIiOq+mizS6ufnh82bNyMwMBD37t1DaWkpRowYgS+++EJdZ8yYMbhx4waefPJJCCFQWlqK1157DXPmzKkyloiICCxcuFA3DSODEAKQgZkGkanhiIaW2NEREdWcNou0njx5EjNmzMD777+PlJQU/Pzzz0hPT1fPTAiU3bv30UcfITo6Gn/99Rd27NiB//3vf/jggw+qjIELuZoejmgQmSaOaFQTJ7sgIqq5mizSGhERAX9/f8yePRsA0LlzZ9jY2KB379748MMP4ezsjHnz5mH8+PEICgoCAHTq1AkFBQV49dVXMXfuXJiZVfw9TVcLuRIR0cNxRIOIiPSuJou0FhYWVkgU5HI5AKinOq2qjhCC06HWIYIrgxOZJI5oEBGRQWi7SOvw4cMxdepUxMTEYODAgcjMzMSsWbPQo0cPuLi4qOtERkaia9eu6NmzJ86dO4d58+ZhxIgR6qSE6gZeukxkephoEBGRQQQGBiInJweLFi1CZmYmOnbs+NBFWidNmoT8/HwsX74cb775Jho1aoR+/fphyZIl6jrvvfceZDIZ3nvvPVy5cgXNmjXD8OHD8dFHHxm8faQ/QgDMM4hMj0zUs7HlvLw82NvbIzc3F3Z2dtXeTqUSaPVuPJa+0Bmju7vqMUIiotqpaT9XX/H9Mn7j1h5EowYKrBjbTepQiEySVP0c79EgIiIio1Y2vS0RmRomGkRERGT0qpoGmYiMFxMNIiIiMmoc0SAyTUw0iIiIyKgJ1KvbSYnqDCYa1aTu4viTChERkUEJwZXBiUwREw0iIiIyaldz70Kp4qgGkalhokFERERGrVlDSxQUlUodBhFpiYkGERERGT2HhpZSh0BEWmKiQUREREZNgPdoEJkiJhpERERk1Mqmt2WmQWRqmGgQERGRUeOIBpFpYqJBREREREQ6x0SDiIiIjJsQHNEgMkFMNIiIiMiola2gwUyDyNQw0agmIdjNERERSYErgxOZJiYaREREZNQEuCo4kSliokFERERGjwMaRKaHiQYREREZNV46RWSamGgQERGRUeOCfUSmiYkGERERGTXeoUFkmphoEBERkdHjpVNEpoeJBhERERk1IQQvnCIyQUw0iIiIyOjJOKRBZHKYaFRT+fWh7OiIiIgMS/AmDSKTxESDiIiIjBoX7CMyTUw0iIiIyOjxggIi08NEg4iIiIwa19EgMk1MNIiIiMio8cIpItPERIOIiIiMmhCCl04RmSAmGkRERGT0mGcQmR4mGkRERGTUBHgzOJEpYqJBREQGEx0dDU9PT1hZWcHb2xv79+9/aP3NmzfjiSeeQIMGDeDs7IzJkycjJydHo87t27cxffp0ODs7w8rKCl5eXoiPj9dnM8jQeJMGkUliolFNXCyIiKh24uLiMGvWLMydOxepqano3bs3Bg8ejIyMjErrHzhwABMmTMCUKVNw4sQJfPvttzh06BCCgoLUdYqLizFgwABcuHAB27Ztw+nTp7FmzRq0aNHCUM0iAygb0eCQBpGpMZc6AFPDbo6IqGYiIyMxZcoUdaIQFRWFXbt2ISYmBhERERXqHzx4EB4eHpgxYwYAwNPTE9OmTcPSpUvVdWJjY3Hz5k0kJibCwsICAODu7m6A1pAhCSF4/iUyQRzRICIivSsuLkZKSgoCAgI0ygMCApCYmFjpNn5+frh8+TLi4+MhhMC1a9ewbds2DB06VF3nhx9+gK+vL6ZPnw5HR0d07NgRixcvhlKprDKWoqIi5OXlaTzIBDDTIDI5TDSIiEjvsrOzoVQq4ejoqFHu6OiIrKysSrfx8/PD5s2bERgYCIVCAScnJzRq1AhffPGFuk5aWhq2bdsGpVKJ+Ph4vPfee1i2bBk++uijKmOJiIiAvb29+uHq6qqbRpLeCHDBPiJTxESDiIgM5sHr7MvWR6j8D8iTJ09ixowZeP/995GSkoKff/4Z6enpCA4OVtdRqVRo3rw5Vq9eDW9vb4wZMwZz585FTExMlTGEh4cjNzdX/bh06ZJuGkd6w/skiUyT5ImGtjOQ7N27F97e3rCyskKrVq2wcuVKA0VKREQ15eDgALlcXmH04vr16xVGOcpFRETA398fs2fPRufOnTFw4EBER0cjNjYWmZmZAABnZ2e0bdsWcrlcvZ2XlxeysrJQXFxc6X4tLS1hZ2en8SDjJsAF+4hMkaSJhrYzkKSnp2PIkCHo3bs3UlNT8e6772LGjBnYvn27gSMnIiJtKBQKeHt7IyEhQaM8ISEBfn5+lW5TWFgIMzPN01R5QiH++Ynb398f586dg0qlUtc5c+YMnJ2doVAodNkEktDlW3elDoGIakDSROP+GUi8vLwQFRUFV1fXKoe8V65cCTc3N0RFRcHLywtBQUF45ZVX8J///MfAkRMRkbbCwsKwdu1axMbG4tSpUwgNDUVGRob6Uqjw8HBMmDBBXX/48OHYsWMHYmJikJaWhj/++AMzZsxAjx494OLiAgB47bXXkJOTg5kzZ+LMmTP48ccfsXjxYkyfPl2SNpJ+NG6gQO7dEqnDICItSTa9bfkMJHPmzNEof9gMJElJSRVmLBk4cCDWrVuHkpIS9dSG9ysqKkJRUZH6OWcXISKSRmBgIHJycrBo0SJkZmaiY8eOiI+PV09Hm5mZqTGiPWnSJOTn52P58uV488030ahRI/Tr1w9LlixR13F1dcXu3bsRGhqKzp07o0WLFpg5cybeeecdg7eP9MdMJoOznZXUYRCRliRLNGoyA0lWVlal9UtLS5GdnQ1nZ+cK20RERGDhwoW6C5yIiGosJCQEISEhlb62YcOGCmVvvPEG3njjjYfu09fXFwcPHtRFeGS0eI8GkSmS/GZwbWYgqap+ZeXldDW7iIVcht/e7IOAxyu/aZGIiIj0QwiuDE5kiiQb0ajJDCROTk6V1jc3N0fTpk0r3cbS0hKWlpa1jlcmk6FVs4a13g8RERERUX0g2YhGTWYg8fX1rVB/9+7d8PHxqfT+DCIiIjJ9XEaDyDRJeumUtjOQBAcH4+LFiwgLC8OpU6cQGxuLdevW4a233pKqCURERKRnZZdVSx0FEWlLskunAO1nIPH09ER8fDxCQ0OxYsUKuLi44PPPP8cLL7wgVROIiIhIzziiQWSaJE00AO1nIOnTpw/++usvPUdFRERExkQGDmkQmRrJZ50iIiIiepiyWaekjoKItMVEg4iIiIyaEILjGUQmiIkGERERGTXeo0FkmphoEBERkdHjpVNEpoeJBhERERk3wZvBiUwREw0iIiIyarx0isg0MdEgIiIio8YF+4hMk+TraBiaEGW/i+Tl5UkcCRGRfpT3b+X9HT0czwvGT1lUgLsF+fyMiGpIqvOCTNSzM9Hly5fh6uoqdRhERHp36dIltGzZUuowjF5aWhpat24tdRhERHp3/vx5tGrVymDHq3cjGi4uLrh06RJsbW0h03IcNi8vD66urrh06RLs7Oz0FKG02Ma6gW2sG2raRiEE8vPz4eLiosfo6o4mTZoAADIyMmBvby9xNLVX174bda09QN1rE9tj/HJzc+Hm5qbu7wyl3iUaZmZmtf6Fz87Ors78w6sK21g3sI11Q03aWBf+YDYUM7Oy2xXt7e3r1L+luvbdqGvtAepem9ge41fe3xnseAY9GhERERER1QtMNIiIiIiISOeYaGjB0tIS8+fPh6WlpdSh6A3bWDewjXVDfWijMahr7zPbY/zqWpvYHuMnVZvq3axTRERERESkfxzRICIiIiIinWOiQUREREREOsdEg4iIiIiIdI6JBhERERER6RwTjftER0fD09MTVlZW8Pb2xv79+x9af+/evfD29oaVlRVatWqFlStXGijS2tGmnTt27MCAAQPQrFkz2NnZwdfXF7t27TJgtDWj7WdZ7o8//oC5uTm6dOmi3wB1QNs2FhUVYe7cuXB3d4elpSVat26N2NhYA0VbM9q2cfPmzXjiiSfQoEEDODs7Y/LkycjJyTFQtNrbt28fhg8fDhcXF8hkMnz33XeP3MZU+x1DuXXrFsaPHw97e3vY29tj/PjxuH379kO3EUJgwYIFcHFxgbW1NZ5++mmcOHFCo87TTz8NmUym8RgzZkytjy1Vm27evIk33ngD7dq1Q4MGDeDm5oYZM2YgNzdXYz8eHh4V2j1nzhyt4tfHuXX79u3o0KEDLC0t0aFDB+zcubPWx5WqPWvWrEHv3r3RuHFjNG7cGP3790dycrJGnQULFlT4HJycnHTSHn20acOGDRXilclkuHfvXq2OK1V7Kvv+y2QyDB06VF1Hn5+RNu3JzMzE2LFj0a5dO5iZmWHWrFmV1jPYd0iQEEKIrVu3CgsLC7FmzRpx8uRJMXPmTGFjYyMuXrxYaf20tDTRoEEDMXPmTHHy5EmxZs0aYWFhIbZt22bgyLWjbTtnzpwplixZIpKTk8WZM2dEeHi4sLCwEH/99ZeBI68+bdtY7vbt26JVq1YiICBAPPHEE4YJtoZq0sYRI0aInj17ioSEBJGeni7+/PNP8ccffxgwau1o28b9+/cLMzMz8dlnn4m0tDSxf/9+8fjjj4vnnnvOwJFXX3x8vJg7d67Yvn27ACB27tz50Pqm2u8Y0qBBg0THjh1FYmKiSExMFB07dhTDhg176DYff/yxsLW1Fdu3bxfHjh0TgYGBwtnZWeTl5anr9OnTR0ydOlVkZmaqH7dv3671saVq07Fjx8Tzzz8vfvjhB3Hu3Dnx66+/iscee0y88MILGvtxd3cXixYt0mh3fn5+tWPXx7k1MTFRyOVysXjxYnHq1CmxePFiYW5uLg4ePFjj40rZnrFjx4oVK1aI1NRUcerUKTF58mRhb28vLl++rK4zf/588fjjj2t8DtevX69VW/TZpvXr1ws7OzuNeDMzM2t1XCnbk5OTo9GO48ePC7lcLtavX6+uo6/PSNv2pKenixkzZogvv/xSdOnSRcycObNCHUN+h5ho/KNHjx4iODhYo6x9+/Zizpw5ldZ/++23Rfv27TXKpk2bJnr16qW3GHVB23ZWpkOHDmLhwoW6Dk1natrGwMBA8d5774n58+cbfaKhbRt/+uknYW9vL3JycgwRnk5o28ZPPvlEtGrVSqPs888/Fy1bttRbjLpUnUTDVPsdQzl58qQAoHGyTEpKEgDE//3f/1W6jUqlEk5OTuLjjz9Wl927d0/Y29uLlStXqsv69OlT6Qm7NseWuk0P+uabb4RCoRAlJSXqMnd3d/Hpp5/WOH59nFtHjx4tBg0apFFn4MCBYsyYMTU+bnUZ4m+F0tJSYWtrK7788kt1mT7PS/po0/r164W9vb1Oj1tdhviMPv30U2Frayvu3LmjLtPXZ1Sb96mqfsuQ3yFeOgWguLgYKSkpCAgI0CgPCAhAYmJipdskJSVVqD9w4EAcPnwYJSUleou1NmrSzgepVCrk5+ejSZMm+gix1mraxvXr1+P8+fOYP3++vkOstZq08YcffoCPjw+WLl2KFi1aoG3btnjrrbdw9+5dQ4SstZq00c/PD5cvX0Z8fDyEELh27Rq2bdumMbRt6kyx3zGkpKQk2Nvbo2fPnuqyXr16wd7evsp/N+np6cjKytJ4Xy0tLdGnT58K22zevBkODg54/PHH8dZbbyE/P79WxzaGNt0vNzcXdnZ2MDc31yhfsmQJmjZtii5duuCjjz5CcXFxtWLX17m1qjrl+9TFuc6Q7XlQYWEhSkpKKpxnz549CxcXF3h6emLMmDFIS0urcVvK6bNNd+7cgbu7O1q2bIlhw4YhNTW1VseVuj33W7duHcaMGQMbGxuNcl1/Rvp6nwz5HTJ/dJW6Lzs7G0qlEo6Ojhrljo6OyMrKqnSbrKysSuuXlpYiOzsbzs7Oeou3pmrSzgctW7YMBQUFGD16tD5CrLWatPHs2bOYM2cO9u/fX+EEa4xq0sa0tDQcOHAAVlZW2LlzJ7KzsxESEoKbN28a5X0aNWmjn58fNm/ejMDAQNy7dw+lpaUYMWIEvvjiC0OEbBCm2O8YUlZWFpo3b16hvHnz5g/tywFU+r5evHhR/XzcuHHw9PSEk5MTjh8/jvDwcPz9999ISEio8bGlbtP9cnJy8MEHH2DatGka5TNnzkS3bt3QuHFjJCcnIzw8HOnp6Vi7du0jY9fXubWqOuX71MW5zpDtedCcOXPQokUL9O/fX13Ws2dPbNy4EW3btsW1a9fw4Ycfws/PDydOnEDTpk2Nrk3t27fHhg0b0KlTJ+Tl5eGzzz6Dv78//v77bzz22GMm/RklJyfj+PHjWLdunUa5Pj4jfb1PhvwOGf9fVQYkk8k0ngshKpQ9qn5l5cZG23aW27JlCxYsWIDvv/++0hOfMaluG5VKJcaOHYuFCxeibdu2hgpPJ7T5HFUqFWQyGTZv3gx7e3sAQGRkJEaNGoUVK1bA2tpa7/HWhDZtPHnyJGbMmIH3338fAwcORGZmJmbPno3g4OAKJwRTZqr9Tm0sWLAACxcufGidQ4cOAaj8fahOH/eof2tTp05V/3/Hjh3x2GOPwcfHB3/99Re6deum9bGNoU3l8vLyMHToUHTo0KHCqG5oaKj6/zt37ozGjRtj1KhR6lGO6tDHubU6+6zpue5R9Pm3wtKlS7Flyxbs2bMHVlZW6vLBgwer/79Tp07w9fVF69at8eWXXyIsLKxG7XhUjLVpU69evdCrVy/16/7+/ujWrRu++OILfP755zU+bnXp8zNat24dOnbsiB49emiU6/Mz0sf7ZKjvEBMNAA4ODpDL5RWytOvXr1fI5so5OTlVWt/c3LxWvy7oU03aWS4uLg5TpkzBt99+q/Eri7HRto35+fk4fPgwUlNT8frrrwMo+6NcCAFzc3Ps3r0b/fr1M0js1VWTz9HZ2RktWrRQJxkA4OXlBSEELl++jMcee0yvMWurJm2MiIiAv78/Zs+eDaDsjyIbGxv07t0bH374YZ34td8U+x1deP311yvM8PQgDw8PHD16FNeuXavw2o0bNx7alwNlv/Dd/2/kUf1it27dYGFhgbNnz6Jbt25wcnLS6tjG0qb8/HwMGjQIDRs2xM6dO2FhYfHQmMr/eDx37twj/83p69xaVZ3yfdbmXCdFe8r95z//weLFi/HLL7+gc+fOD43FxsYGnTp1wtmzZ2vQkn8Z6u8fMzMzdO/eXR2vqX5GhYWF2Lp1KxYtWvTIWHTxGenrfTLkd4j3aABQKBTw9vZWD4GXS0hIgJ+fX6Xb+Pr6Vqi/e/du+Pj4PLKjlkpN2gmUjWRMmjQJX3/9tdFf765tG+3s7HDs2DEcOXJE/QgODka7du1w5MgRjeuijUVNPkd/f39cvXoVd+7cUZedOXMGZmZmaNmypV7jrYmatLGwsBBmZppdmlwuB/Dvr1OmzhT7HV1wcHBA+/btH/qwsrKCr68vcnNzNaYG/fPPP5Gbm1vlv5vyy6Huf1+Li4uxd+/eh/aLJ06cQElJifoPeW2PbQxtysvLQ0BAABQKBX744QeNX9CrUn6dfXUSd32dW6uqU77Pmp7rpGoPAHzyySf44IMP8PPPP8PHx+eRsRQVFeHUqVO1/gHFUH//CCFw5MgRdbym+BkBwDfffIOioiK8/PLLj4xFF5+Rvt4ng36HtLp1vA4rn8Zr3bp14uTJk2LWrFnCxsZGXLhwQQghxJw5c8T48ePV9cunQwsNDRUnT54U69atM4lpJrVt59dffy3Mzc3FihUrHjqtozHRto0PMoVZp7RtY35+vmjZsqUYNWqUOHHihNi7d6947LHHRFBQkFRNeCRt27h+/Xphbm4uoqOjxfnz58WBAweEj4+P6NGjh1RNeKT8/HyRmpoqUlNTBQARGRkpUlNT1dMH1pV+x5AGDRokOnfuLJKSkkRSUpLo1KlThalg27VrJ3bs2KF+/vHHHwt7e3uxY8cOcezYMfHSSy9pTAV77tw5sXDhQnHo0CGRnp4ufvzxR9G+fXvRtWtXUVpaqtWxjaVNeXl5omfPnqJTp07i3LlzGv17eZsSExPV/ybT0tJEXFyccHFxESNGjKh27Po4t/7xxx9CLpeLjz/+WJw6dUp8/PHHVU7NWdVxa0of7VmyZIlQKBRi27ZtVU4j/Oabb4o9e/aItLQ0cfDgQTFs2DBha2tb6/boq00LFiwQP//8szh//rxITU0VkydPFubm5uLPP/+s9nGNqT3lnnzySREYGFjpcfX1GdXkb5ry84q3t7cYO3asSE1NFSdOnFC/bsjvEBON+6xYsUK4u7sLhUIhunXrJvbu3at+beLEiaJPnz4a9ffs2SO6du0qFAqF8PDwEDExMQaOuGa0aWefPn0EgAqPiRMnGj5wLWj7Wd7PFBINIbRv46lTp0T//v2FtbW1aNmypQgLCxOFhYUGjlo72rbx888/Fx06dBDW1tbC2dlZjBs3TmMuemPz+++/P/T7VZf6HUPJyckR48aNE7a2tsLW1laMGzdO3Lp1S6MOAI3571UqlZg/f75wcnISlpaW4qmnnhLHjh1Tv56RkSGeeuop0aRJE6FQKETr1q3FjBkzKkwXXZ1jG0ubqvq3B0Ckp6cLIYRISUkRPXv2FPb29sLKykq0a9dOzJ8/XxQUFGgVvz7Ord9++61o166dsLCwEO3btxfbt2/X6ri1oev2uLu7V/o5zJ8/X12nfB0UCwsL4eLiIp5//nmNPxyNrU2zZs0Sbm5uQqFQiGbNmomAgACRmJio1XGNqT1CCHH69GkBQOzevbvSY+rzM9K2PZX9e3J3d9eoY6jvkOyfgIiIiIiIiHSG92gQEREREZHOMdEgIiIiIiKdY6JBREREREQ6x0SDiIiIiIh0jokGERERERHpHBMNIiIiIiLSOSYaRERERESkc0w0iIiIiIhI55hokEnYsGEDGjVqJHUYNebh4YGoqKiH1lmwYAG6dOlikHiIiEwZzwlEpoGJBhnMpEmTIJPJKjzOnTsndWjYsGGDRkzOzs4YPXo00tPTdbL/Q4cO4dVXX1U/l8lk+O677zTqvPXWW/j11191cryqPNhOR0dHDB8+HCdOnNB6P6Z8kici6fGcwHMC1X1MNMigBg0ahMzMTI2Hp6en1GEBAOzs7JCZmYmrV6/i66+/xpEjRzBixAgolcpa77tZs2Zo0KDBQ+s0bNgQTZs2rfWxHuX+dv74448oKCjA0KFDUVxcrPdjExHdj+eEqvGcQHUBEw0yKEtLSzg5OWk85HI5IiMj0alTJ9jY2MDV1RUhISG4c+dOlfv5+++/0bdvX9ja2sLOzg7e3t44fPiw+vXExEQ89dRTsLa2hqurK2bMmIGCgoKHxiaTyeDk5ARnZ2f07dsX8+fPx/Hjx9W/rsXExKB169ZQKBRo164dNm3apLH9ggUL4ObmBktLS7i4uGDGjBnq1+4fJvfw8AAAjBw5EjKZTP38/mHyXbt2wcrKCrdv39Y4xowZM9CnTx+dtdPHxwehoaG4ePEiTp8+ra7zsM9jz549mDx5MnJzc9W/gi1YsAAAUFxcjLfffhstWrSAjY0NevbsiT179jw0HiKqv3hO4DmB6jYmGmQUzMzM8Pnnn+P48eP48ssv8dtvv+Htt9+usv64cePQsmVLHDp0CCkpKZgzZw4sLCwAAMeOHcPAgQPx/PPP4+jRo4iLi8OBAwfw+uuvaxWTtbU1AKCkpAQ7d+7EzJkz8eabb+L48eOYNm0aJk+ejN9//x0AsG3bNnz66adYtWoVzp49i++++w6dOnWqdL+HDh0CAKxfvx6ZmZnq5/fr378/GjVqhO3bt6vLlEolvvnmG4wbN05n7bx9+za+/vprAFC/f8DDPw8/Pz9ERUWpfwXLzMzEW2+9BQCYPHky/vjjD2zduhVHjx7Fiy++iEGDBuHs2bPVjomIiOcETTwnkMkSRAYyceJEIZfLhY2NjfoxatSoSut+8803omnTpurn69evF/b29urntra2YsOGDZVuO378ePHqq69qlO3fv1+YmZmJu3fvVrrNg/u/dOmS6NWrl2jZsqUoKioSfn5+YurUqRrbvPjii2LIkCFCCCGWLVsm2rZtK4qLiyvdv7u7u/j000/VzwGInTt3atSZP3++eOKJJ9TPZ8yYIfr166d+vmvXLqFQKMTNmzdr1U4AwsbGRjRo0EAAEADEiBEjKq1f7lGfhxBCnDt3TshkMnHlyhWN8meeeUaEh4c/dP9EVP/wnPCp+jnPCVRXmUuX4lB91LdvX8TExKif29jYAAB+//13LF68GCdPnkReXh5KS0tx7949FBQUqOvcLywsDEFBQdi0aRP69++PF198Ea1btwYApKSk4Ny5c9i8ebO6vhACKpUK6enp8PLyqjS23NxcNGzYEEIIFBYWolu3btixYwcUCgVOnTqlceMeAPj7++Ozzz4DALz44ouIiopCq1atMGjQIAwZMgTDhw+HuXnNv2Ljxo2Dr68vrl69ChcXF2zevBlDhgxB48aNa9VOW1tb/PXXXygtLcXevXvxySefYOXKlRp1tP08AOCvv/6CEAJt27bVKC8qKjLIdcZEZHp4Tqg+nhPIFDHRIIOysbFBmzZtNMouXryIIUOGIDg4GB988AGaNGmCAwcOYMqUKSgpKal0PwsWLMDYsWPx448/4qeffsL8+fOxdetWjBw5EiqVCtOmTdO4Hracm5tblbGVd7ZmZmZwdHSs0HnKZDKN50IIdZmrqytOnz6NhIQE/PLLLwgJCcEnn3yCvXv3agw/a6NHjx5o3bo1tm7ditdeew07d+7E+vXr1a/XtJ1mZmbqz6B9+/bIyspCYGAg9u3bB6Bmn0d5PHK5HCkpKZDL5RqvNWzYUKu2E1H9wHNC9fGcQKaIiQZJ7vDhwygtLcWyZctgZlZ229A333zzyO3atm2Ltm3bIjQ0FC+99BLWr1+PkSNHolu3bjhx4kSFk9ej3N/ZPsjLywsHDhzAhAkT1GWJiYkavxBZW1tjxIgRGDFiBKZPn4727dvj2LFj6NatW4X9WVhYVGvmkrFjx2Lz5s1o2bIlzMzMMHToUPVrNW3ng0JDQxEZGYmdO3di5MiR1fo8FApFhfi7du0KpVKJ69evo3fv3rWKiYjqL54TqsZzApka3gxOkmvdujVKS0vxxRdfIC0tDZs2baowbHu/u3fv4vXXX8eePXtw8eJF/PHHHzh06JC6g3/nnXeQlJSE6dOn48iRIzh79ix++OEHvPHGGzWOcfbs2diwYQNWrlyJs2fPIjIyEjt27FDf8LZhwwasW7cOx48fV7fB2toa7u7ule7Pw8MDv/76K7KysnDr1q0qjztu3Dj89ddf+OijjzBq1ChYWVmpX9NVO+3s7BAUFIT58+dDCFGtz8PDwwN37tzBr7/+iuzsbBQWFqJt27YYN24cJkyYgB07diA9PR2HDh3CkiVLEB8fr1VMRFR/8ZzAcwLVIdLcGkL10cSJE8Wzzz5b6WuRkZHC2dlZWFtbi4EDB4qNGzcKAOLWrVtCCM0bzYqKisSYMWOEq6urUCgUwsXFRbz++usaN7slJyeLAQMGiIYNGwobGxvRuXNn8dFHH1UZW2U3sj0oOjpatGrVSlhYWIi2bduKjRs3ql/buXOn6Nmzp7CzsxM2NjaiV69e4pdfflG//uCNfz/88INo06aNMDc3F+7u7kKIijf+levevbsAIH777bcKr+mqnRcvXhTm5uYiLi5OCPHoz0MIIYKDg0XTpk0FADF//nwhhBDFxcXi/fffFx4eHsLCwkI4OTmJkSNHiqNHj1YZExHVTzwnfKp+znMC1VUyIYSQLs0hIiIiIqK6iJdOERERERGRzjHRICIiIiIinWOiQUREREREOsdEg4iIiIiIdI6JBhERERER6RwTDSIiIiIi0jkmGkREREREpHNMNIiIiIiISOeYaBARERERkc4x0SAiIiIiIp1jokFERERERDr3//Pq0DsmfhPeAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Umbral óptimo: 0.1307\n", "FPR: 0.0146, TPR: 0.9743\n" ] } ], "source": [ "# Curva ROC y umbral óptimo\n", "fig, ax = plt.subplots(1,2,figsize=(8, 8))\n", "\n", "fpr, tpr, thresholds = roc_curve(y_test, y_pred_proba)\n", "gmean = np.sqrt(tpr * (1 - fpr))\n", "index = np.argmax(gmean)\n", "thresholdOpt = round(thresholds[index], ndigits = 4)\n", "fprOpt = round(fpr[index], ndigits = 4)\n", "tprOpt = round(tpr[index], ndigits = 4)\n", "\n", "ax[0].step(\n", " fpr,\n", " tpr,\n", " lw=1,\n", " alpha=1,\n", ")\n", "\n", "ax[0].plot(\n", " fprOpt,\n", " tprOpt,\n", " marker = 'o'\n", ")\n", "\n", "ax[0].set(\n", " xlim=[-0.05, 1.05],\n", " ylim=[-0.05, 1.05],\n", " xlabel=\"False Positive Rate\",\n", " ylabel=\"True Positive Rate\",\n", " title=f\"Curva ROC\",\n", ")\n", "ax[0].axis(\"square\")\n", "\n", "ax[1].set_aspect('equal')\n", "ax[1].set_xlim([-0.05, 0.1])\n", "ax[1].set_xbound(lower=-0.05, upper=0.1)\n", "ax[1].set_ylim([0.85,1])\n", "ax[1].set_ybound(lower=0.85, upper=1.0)\n", "\n", "ax[1].step(\n", " fpr,\n", " tpr,\n", " lw=1,\n", " alpha=1,\n", ")\n", "\n", "ax[1].plot(\n", " fprOpt,\n", " tprOpt,\n", " marker = 'o'\n", ")\n", "\n", "ax[1].set(\n", " xlabel=\"False Positive Rate\",\n", " ylabel=\"True Positive Rate\",\n", " title=f\"Zoom\",\n", ")\n", "\n", "plt.tight_layout()\n", "plt.show()\n", "\n", "print(f'Umbral óptimo: {thresholdOpt}')\n", "print(f'FPR: {fprOpt}, TPR: {tprOpt}')" ] }, { "cell_type": "code", "execution_count": 85, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Umbral adecuado: 0.7334499246893632\n" ] } ], "source": [ "# Otra forma de calcular un umbral adecuado\n", "indx = np.argmax(tpr>=0.90)\n", "thresholdAde = thresholds[indx]\n", "print('Umbral adecuado: ', thresholdAde)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Test en la imagen del astronauta" ] }, { "cell_type": "code", "execution_count": 62, "metadata": {}, "outputs": [], "source": [ "# Imagen de prueba\n", "test_image = data.astronaut()\n", "test_image = color.rgb2gray(test_image)\n", "test_image = rescale(test_image, 0.5)\n", "test_image = test_image[:160, 40:180]" ] }, { "cell_type": "code", "execution_count": 69, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Visualizamos la imagen\n", "# Buscamos la escala de los rostros\n", "fig, ax = plt.subplots()\n", "ax.imshow(test_image, cmap='gray')\n", "\n", "true_scale = 1\n", "Ni, Nj = (int(true_scale * s) for s in size)\n", "\n", "ax.add_patch(plt.Rectangle((0, 0), Nj, Ni, edgecolor='red', alpha=1, lw=1, facecolor='none'))\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 64, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(1911, 81)" ] }, "execution_count": 64, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Utiliza la función de ventana deslizante en una imagen de prueba.\n", "# zip(*...) toma las tuplas generadas y las descompone en índices y parches.\n", "indices, patches = zip(*sliding_window(test_image, scale=true_scale))\n", "\n", "# Calcula las características HOG para cada parche y las almacena en un array.\n", "patches_hog = np.array([feature.hog(patch,\n", " orientations=orientations,\n", " pixels_per_cell=pixels_per_cell,\n", " cells_per_block=cells_per_block) for patch in patches])\n", "\n", "# Muestra la forma del array de características HOG.\n", "patches_hog.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Desempeño según umbrales" ] }, { "cell_type": "code", "execution_count": 86, "metadata": {}, "outputs": [], "source": [ "# Predicción\n", "\n", "# Umbral default\n", "labels_default = model.predict(patches_hog).astype(int)\n", "\n", "# Umbral óptimo\n", "labels_optimo = (model.predict_proba(patches_hog)[:,1]>=thresholdOpt).astype(int)\n", "\n", "# Umbral adecuado\n", "labels_adecuado = (model.predict_proba(patches_hog)[:,1]>=thresholdAde).astype(int)" ] }, { "cell_type": "code", "execution_count": 87, "metadata": {}, "outputs": [], "source": [ "Ni, Nj = (int(true_scale*s) for s in size)\n", "indices = np.array(indices)\n", "\n", "# Umbral default\n", "detecciones_default = indices[labels_default == 1]\n", "detecciones_default = non_max_suppression(np.array(detecciones_default),Ni,Nj, 0.3)\n", "\n", "# Umbral optimo\n", "detecciones_optimo = indices[labels_optimo == 1]\n", "detecciones_optimo = non_max_suppression(np.array(detecciones_optimo),Ni,Nj, 0.3)\n", "\n", "# Umbral adecuado\n", "detecciones_adecuado = indices[labels_adecuado == 1]\n", "detecciones_adecuado = non_max_suppression(np.array(detecciones_adecuado),Ni,Nj, 0.3)" ] }, { "cell_type": "code", "execution_count": 92, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Visualizamos las detecciones\n", "fig, ax = plt.subplots(1,3, figsize=(8,4))\n", "\n", "# Umbral default\n", "ax[0].imshow(test_image, cmap='gray')\n", "ax[0].axis('off')\n", "\n", "for i, j in detecciones_default:\n", " ax[0].add_patch(plt.Rectangle((j, i), Nj, Ni, edgecolor='red',alpha=1, lw=1, facecolor='none'))\n", "\n", "ax[0].set_title('Default')\n", "\n", "# Umbral óptimo\n", "ax[1].imshow(test_image, cmap='gray')\n", "ax[1].axis('off')\n", "\n", "for i, j in detecciones_optimo:\n", " ax[1].add_patch(plt.Rectangle((j, i), Nj, Ni, edgecolor='red',alpha=1, lw=1, facecolor='none'))\n", "\n", "ax[1].set_title('Óptimo')\n", "\n", "# Umbral adecuado\n", "ax[2].imshow(test_image, cmap='gray')\n", "ax[2].axis('off')\n", "\n", "for i, j in detecciones_adecuado:\n", " ax[2].add_patch(plt.Rectangle((j, i), Nj, Ni, edgecolor='red',alpha=1, lw=1, facecolor='none'))\n", "\n", "ax[2].set_title('Adecuado')\n", "\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Desempeño en varias escalas según umbral" ] }, { "cell_type": "code", "execution_count": 110, "metadata": {}, "outputs": [], "source": [ "# Escalas a testear\n", "test_scales = np.linspace(0.125, 2, 50)" ] }, { "cell_type": "code", "execution_count": 111, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 50/50 [01:12<00:00, 1.44s/it]\n" ] } ], "source": [ "raw_detections, detections = detections_by_scale(\n", " test_image,\n", " test_scales,\n", " step=2,\n", " thresholds=[0.5, thresholdOpt, thresholdAde]\n", " )" ] }, { "cell_type": "code", "execution_count": 116, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+UAAAGHCAYAAADWYPPyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAACJvklEQVR4nO3deXwT1d4G8GeaTtKktGzSBagFZVNAReFlUXbaAoIionjxCrh7QRS5LiCiRRFkEbleV7zKchUFFdCLCK2WRUQQEMQFARVKUSqCYKFJm0k67x8xoWmzbzOZPl8+/ZBMzsyck8nMb87MmXMEWZZlEBEREREREVHMJSidASIiIiIiIqK6ipVyIiIiIiIiIoWwUk5ERERERESkEFbKiYiIiIiIiBTCSjkRERERERGRQlgpJyIiIiIiIlIIK+VERERERERECmGlnIiIiIiIiEghrJQTERERERERKYSVciKNWrx4MQRBcPtr0qQJ+vTpgzVr1kR8fcuWLcOCBQsivlwiIiItqRmfExMT0bx5c9x666345ZdflM6eYsaOHYsWLVoonQ0iRbBSTqRxixYtwhdffIGtW7di4cKF0Ol0GDp0KP73v/9FdD2slBMREQXOGZ8LCwtx55134u2330bPnj1RXl6udNaIKMYSlc4AEUVXhw4d0LlzZ9f7gQMHomHDhnj77bcxdOhQj/PY7XbYbDYYDIZYZZOIiKhOqR6f+/btC7vdjqeeegqrV6/GzTffXCu92WyGyWSKdTaJKAZ4p5yojklKSoJer4coigCAw4cPQxAEzJkzBzNmzEDLli1hMBiwYcMGVxO7w4cPuy1j48aNEAQBGzduBAD06dMHH330EYqLi92a5Dn98ccfGDduHJo1awa9Xo8LLrgAU6dORWVlZayKTUREpGrdunUDABQXF2Ps2LGoV68evvnmG+Tm5iIlJQX9+/cHEHhMraqqwr///W9cdtllMBqNaNCgAbp164YPP/zQLd3y5cvRvXt3JCcno169esjLy8Pu3bvd0vz888+46aab0LRpUxgMBqSnp6N///7Ys2eP23Jyc3ORmZkJo9GIiy66CJMnT/Z453/x4sVo27YtDAYDLrroIixdutTjd8LzB6oreKecSOOcd71lWcZvv/2GuXPnory8HKNGjXJL9/zzz6NNmzaYN28eUlNT0bp1a5SWlga0jpdeegl33XUXfvrpJ6xatcrts4qKCvTt2xc//fQTpk+fjksuuQSfffYZZs2ahT179uCjjz6KWFmJiIji1Y8//ggAaNKkCQ4cOACr1YprrrkGd999NyZPngybzRZUTB07dizefPNN3H777XjyySeh1+vx1VdfuV1onzlzJh577DHceuuteOyxx2C1WjF37lz07NkTX375JS6++GIAwODBg2G32zFnzhycf/75OHHiBLZu3YrTp0+7lnXw4EEMHjwYEydORHJyMn744QfMnj0bX375JYqKilzpFi9ejFtvvRXXXnstnn32Wfz555/Iz89HZWUlEhLO3S/k+QPVKTIRadKiRYtkALX+DAaD/NJLL7nSHTp0SAYgX3jhhbLVavW4jEOHDrlN37BhgwxA3rBhg2va1VdfLWdnZ9fKxyuvvCIDkFesWOE2ffbs2TIAuaCgIOyyEhERxQtnbN22bZssSZJ85swZec2aNXKTJk3klJQUubS0VB4zZowMQH7jjTfc5g00pm7evFkGIE+dOtVrPo4cOSInJibKEyZMcJt+5swZOSMjQ77xxhtlWZblEydOyADkBQsWBFzGqqoqWZIkedOmTTIA+euvv5ZlWZbtdrvctGlT+fLLL5erqqpc6Q8fPiyLouh2HsHzB6pL2HydSOOWLl2KHTt2YMeOHfj4448xZswYjB8/Hi+88IJbumuuucbVpD2SioqKkJycjBEjRrhNHzt2LADg008/jfg6iYiI1K5bt24QRREpKSkYMmQIMjIy8PHHHyM9Pd2V5vrrr3ebJ9CY+vHHHwMAxo8f73X969evh81mw+jRo2Gz2Vx/SUlJ6N27t+sRtUaNGuHCCy/E3LlzMX/+fOzevRtVVVW1lvfzzz9j1KhRyMjIgE6ngyiK6N27NwBg3759AID9+/fj119/xahRo9wec8vOzkaPHj1CKiuRFrD5OpHGXXTRRbU6eisuLsbDDz+Mv//9767pmZmZUVn/yZMnkZGR4RZ8ASAtLQ2JiYk4efJkVNZLRESkZkuXLsVFF12ExMREpKen14rDJpMJqampbtMCjam///47dDodMjIyvK7/t99+AwB06dLF4+fOpuSCIODTTz/Fk08+iTlz5uCf//wnGjVqhJtvvhlPP/00UlJScPbsWfTs2RNJSUmYMWMG2rRpA5PJhJKSEgwfPhwWi8WVfwAe85WRkeHWtJ7nD1SXsFJOVAddcsklWL9+PQ4cOIC0tDQAqBX0AEencABqdahy4sSJgNfVuHFjbN++HbIsu63j+PHjsNlsOO+880IpAhERUVyredG8Jk9xOdCY2qRJE9jtdpSWlnq96O5M+9577yE7O9tnXrOzs/H6668DAA4cOIAVK1YgPz8fVqsVr7zyCoqKivDrr79i48aNrrvjANyeOXfmH4DHPmtqTuP5A9UlbL5OVAc5e0tt0qSJz3QtWrQAAOzdu9dtes2eWwHAYDC4roRX179/f5w9exarV692m+7sadXZmywRERH5FmhMHTRoEADg5Zdf9rqsvLw8JCYm4qeffkLnzp09/nnSpk0bPPbYY+jYsSO++uorAOcuINQcSvXVV191e9+2bVtkZmbi7bffhizLrunFxcXYunVrSGUl0gLeKSfSuG+//RY2mw2AoynYypUrUVhYiOuuuw4tW7asNdxZdV26dEHbtm3x4IMPwmazoWHDhli1ahW2bNlSK23Hjh2xcuVKvPzyy7jiiiuQkJCAzp07Y/To0XjxxRcxZswYHD58GB07dsSWLVswc+ZMDB48GAMGDIhW0YmIiDQl0Jjas2dP3HLLLZgxYwZ+++03DBkyBAaDAbt374bJZMKECRPQokULPPnkk5g6dSp+/vlnDBw4EA0bNsRvv/2GL7/8EsnJyZg+fTr27t2Le++9FzfccANat24NvV6PoqIi7N27F5MnTwYA9OjRAw0bNsQ999yDJ554AqIo4q233sLXX3/tlv+EhAQ89dRTuOOOO3DdddfhzjvvxOnTp5Gfn1+rSTvPH6hOUbafOSKKFk+9r9evX1++7LLL5Pnz58sVFRWyLJ/rfX3u3Lkel3PgwAE5NzdXTk1NlZs0aSJPmDBB/uijj2r1vv7HH3/II0aMkBs0aCALgiBXP7ycPHlSvueee+TMzEw5MTFRzs7OlqdMmeLKAxERUV3hjM87duzwmmbMmDFycnKyx88Cjal2u11+7rnn5A4dOsh6vV6uX7++3L17d/l///ufW7rVq1fLffv2lVNTU2WDwSBnZ2fLI0aMkD/55BNZlmX5t99+k8eOHSu3a9dOTk5OluvVqydfcskl8nPPPSfbbDbXcrZu3Sp3795dNplMcpMmTeQ77rhD/uqrr2QA8qJFi9zW+Z///Edu3bq1rNfr5TZt2shvvPGGPGbMmFqjuPD8geoKQZartR0hIiIiIiIiopjhM+VERERERERECmGlnIiIiIiIiEghrJQTERERERERKYSVciIiIiIiIiKFsFJOREREREREpBBWyomIiIiIiIgUkqh0BqKtqqoKv/76K1JSUiAIgtLZISIigizLOHPmDJo2bYqEBF4fDxdjPRERqU0wsV7zlfJff/0VWVlZSmeDiIiolpKSEjRv3lzpbMQ9xnoiIlKrQGK95ivlKSkpABxfRmpqqsK5CYwkSSgoKEBubi5EUVQ6O2FhWdRLS+VhWdRJS2UBIluesrIyZGVluWIUhYexXllaKgugrfKwLOqkpbIA2iqPUrFe85VyZzO21NTUuArUJpMJqampmvhhsywqZDZD7tYNV589C+PgwRDjZN/wRkvbhmVRr2iUh02tI4OxXllaKgugofIw1quWlsoCaKs8SsV6zVfKicgDWYawbx9SAUiyrHRuiIiIKNIY64niBnuXISIiIiIiIlIIK+VERERERERECmHzdSIiFZBlGTabDZWVlUhMTERFRQXsdrvS2QqLJEmaKQsQXHl0Oh0SExP5zDgREbloMdYD2or3SsV6VsqJiBRmtVpx7NgxmM1myLKMjIwMlJSUxH2FTktlAYIvj8lkQmZmJvR6fQxyR0REaqbVWA9oK94rFetZKSciUlBVVRUOHToEnU6Hpk2bIjExEeXl5ahXrx4SEuL7CaOqqiqcPXtWE2UBAi+PLMuwWq34/fffcejQIbRu3VoT5SciotBoOdYD2or3SsV6VsqJ6iJBgJydDYvZDDHOr2jGO6vViqqqKmRlZcFkMqGqqgqSJCEpKUkTgc1qtWqiLEBw5TEajRBFEcXFxa55iIhiirFeNbQc6wFtxXulYn18f2tEFBqTCbaDB1H42muAyaR0bgiI+yBGtXGbOsyaNQtdunRBSkoK0tLSMGzYMOzfv98tzdixYyEIgttft27dFMoxkUYw1qsO44L2RGqb8pdBREREUbNp0yaMHz8e27ZtQ2FhIWw2G3Jzc1FeXu6WbuDAgTh27Jjrb+3atQrlmIiIKLbYfJ2IPJNlQDL7TiOaADaJIyIf1q1b5/Z+0aJFSEtLw65du9CrVy/XdIPBgIyMjFhnr7bqxz5PxzgeG4mIKMJYKSeqiywW6Hr2RK8//wT69gVE0f1zWQbeyANKtvteTlY34LZ1PPmksC1cuBBPPfUUfvnlF8yfPx8TJ04Me5mHDx9Gy5YtsXv3blx22WVhL48i488//wQANGrUyG36xo0bkZaWhgYNGqB37954+umnkZaW5nEZlZWVqKysdL0vKysD4BjKRpKk8DJoLYc4N9uxvIeKAX3yuc9kGbqlVyPh6Jc+F1HVvCvso9f4PDY68xl2flVAS2UBNFQeiwUJffuiV1kZpKuuAlJTlc5RWOJ5u0iSBFmWUVVVhaqqKsiyDACuafEu0PIsXLgQTz/9NH755Rc8++yzuP/++8Ne9+HDh3HhhRdi165dEYn1wW4b5/aUJAk6nc7ts2B+q6yUE9VFVVVI2LULDQFIng44ktl/hRwASrY50lY/aaU6Y+zYsViyZAkAIDExEY0aNcIll1yCv/3tbxg7dmzAyykrK8O9996L+fPn4/rrr0f9+vWjkt+NGzeib9++OHXqFBo0aBCVdZBvsixj0qRJuOqqq9ChQwfX9EGDBuGGG25AdnY2Dh06hGnTpqFfv37YtWsXDAZDreXMmjUL06dPrzW9oKAApjCfndXZKzHkr9fr1xfArjO4f+anQg4ACUe3Y+2a1W7zelNYWBhqVlVHS2UB4r88uooKDPnqKzQEsOaTT2DXSIeT8bhdEhMTkZGRgbNnz8JqtbqmnzlzRsFcBWbcuHF4++23ATjK0bBhQ7Rv3x7XX389Ro0a5fZMta/ylJWV4b777sOMGTNwzTXXIDU11XVBNRxnz54FAJSXl6OsrAxbtmzB0KFDcfjw4bDOJwLdNlarFRaLBZs3b4bNZnP7zGz206qqGlbKici3B38E9DVOcq1mYF4rZfJDqjJw4EAsWrQIdrsdv/32G9atW4f7778f7733HlavXh3QMo4cOQJJknD11VcjMzMzuhkmRd17773Yu3cvtmzZ4jZ95MiRrtcdOnRA586dkZ2djY8++gjDhw+vtZwpU6Zg0qRJrvdlZWXIyspCbm4uUsO9G2gtB/Y6Xubl5bpfdKz2mTRxn6OZenWSGeKCizzPW4MkSSgsLEROTg7Emq2V4oyWygJoqDzV+m3o168fxDi/GBnP26WiogIlJSWoV68ekpKSIMsyzpw5g5SUFNWP6y2KIvLy8vDGG2+4Yv369esxZcoUfPTRR/jggw+g0+n8lscZ66+//nq0bNkyYvmrV68eACA5ORmpqamuC7MpKSkhxYNgt01FRQWMRiN69epVq/f1YC46sFJORL7pTbwTHkOyLMNitSPRaot5L61GURf0yUH154CbNWuGyy+/HN26dUP//v2xePFi3Hjjjfjzzz/xyCOPYPXq1aioqEDnzp3x3HPP4dJLL8XixYtx6623AgAuuOACAMChQ4dgt9sxadIkbNu2DeXl5bjoooswa9YsDBgwwLVuQRCwatUqDBs2zDWtQYMGWLBgQa079YcPH0bfvn0BAA0bNgQAjBkzBosXLw6qvBS6CRMm4MMPP8TmzZvRvHlzn2kzMzORnZ2NgwcPevzcYDB4vIMuimL4J+vyuflFUXR/vKf6Z6b6tY+NVh/zehGRPKuElsoCaKA8ovvvMa7LUk08lsVut0MQBCQkJCAhIcHV5Nki2VUf6wVBQFJSEpo2bQoAyMrKQufOndG9e3f0798fS5cuxW233YY///wTDz30ED744AOfsb5VK8dNnUjFeuf3l5CQgCNHjqB///4AgMaNGwMIPtY7m6w7t5c/CQkJEATB4+8ymN8pK+VERCpikezoPn+bIuv+/sk8mPThh4V+/frh0ksvxapVq3DDDTdg6NChaNSoEdauXYv69evj1VdfRf/+/XHgwAGMHDkSWVlZGDBgAL788ktkZWWhSZMm+PbbbzF48GDMmDEDSUlJWLJkCYYOHYr9+/fj/PPPDzpPWVlZeP/993H99ddj//79SE1NhdFoDLus5J8sy5gwYQJWrVqFjRs3BnSH5OTJkygpKWHLCSLSrAqpCp1mx74pfqRj/cqVK3Hrrbdi5MiRaNKkCWN9iDgkGhERRVy7du1QXFyMzz77DN988w3effdddO7cGa1bt8a8efPQoEEDvPfeezAaja6r2U2aNEFGRgZ0Oh0uvfRS3H333ejYsSNat26NGTNm4IILLsCHH34YUn50Op2rY7G0tDRkZGRE7dl1cjd+/Hi8+eabWLZsGVJSUlBaWorS0lJYLBYAjucBH3zwQXzxxRc4fPgwNm7ciKFDh+K8887Dddddp3DuiYjIm3bt2uHw4cPYsGEDvv/+e6xYsYKxPkS8U05EpCJGUYcvJnVDSmqKIk3aIkWWZQiCgD179uDs2bOuYOxksVjw008/eZ2/vLwc06dPx5o1a/Drr7/CZrPBYrHgyJEjEcsjxcbLL78MAOjTp4/b9EWLFmHs2LHQ6XT45ptvsHTpUpw+fRqZmZno27cvli9fjpSUFAVyTEQUfUliAr7Nz9FErP/qq69QXl6OJk2auH3OWB84VsqJ6ij5vPNgtVrZXEZlBEGAUa+DSZ8Y80AdSfv27UOLFi1QVVWFzMxMbNy4sVYaXz2gP/TQQ1i/fj3mzZuHVq1awWg0YsSIEW691gqC4Bq6xCkeh8rRuprbqCaj0Yj169fHKDdEdQtjvXoJgqCJWN+yZUtUVVUhIyMDGzZsqFUexvrAsFJOFC5ZdgwL5o1oUt843snJsP36K9atXYvByezEjSKrqKgI33zzDe6//340atQIpaWlSExMRIsWLQJexmeffYaxY8e6mi+fPXsWhw8fdkvTpEkTHDt2zPX+4MGDPocf0ev1ABwd7hARaR5jPUWRM9Y/8MADaNq0KX777TckJia6Om0NBGP9OayUE4VDloE38nyP6Z3VDbhtnfoq5kQRUFlZidLSUrch0WbNmoUhQ4Zg9OjROHv2LLp3745hw4Zh9uzZaNu2LX799VesXbsWw4YNQ+fOnT0ut1WrVli5ciWGDh0KQRAwbdo0V4+oTv369cMLL7yAbt26oaqqCo888ojPnk6zs7MhCALWrFmDwYMHw2g0uoZSISIiIs/8xXoA6NKlC4YPH85YH6L4bS9BpAaS2XeFHABKtvm+k04Ux9atW4fMzEy0aNECAwcOxIYNG/D888+7xi11BsZevXrhtttuQ5s2bXDTTTfh8OHDSE9P97rc5557Dg0bNkSPHj0wdOhQ5OXl4fLLL3dL8+yzzyIrKwu9evXCqFGj8OCDD7rGJ/WkWbNmmD59OiZPnoz09HTce++9EfseSKOsZsfY5K4/HsuJqO4JJNavWLECPXv2ZKwPEe+UE0XKgz86xvR2spqBea2Uy48vFgt0AwfiypMngb59AxpLl6imxYsX+xz703m1OyUlBc8//zyef/55j+kuu+yyWs+LtWjRAkVFRW7Txo8f7/a+adOmtZ5FPn36tNsyai532rRpmDZtmtc8E7lR6zGcKBCM9RQB/mK9U0pKCv71r3/h3//+t8fPGet9Y6WcKFL0JkAfJ89sVVUhYfNmnAdAqtFMiIioThNNjseOSrZ5T5PVzZGOSM0Y64niBivlRERERE6C4OgHJN468CQiorjFSjkRERFRdYIQPy2fiIgo7rGjNyIiIiIiIiKFsFJOREREREREpBBWyomIiIiIiIgUwmfKieoo2WSC3W5XOhtEREQUJYz1RPFB0TvlNpsNjz32GFq2bAmj0YgLLrgATz75pGtsWwCQZRn5+flo2rQpjEYj+vTpg++++07BXBNpQHIybKdP46Ply4FkdmZERESkOYz1RHFD0Ur57Nmz8corr+CFF17Avn37MGfOHMydO9dt0Pk5c+Zg/vz5eOGFF7Bjxw5kZGQgJycHZ86cUTDnRERU0zfffON2/CYiIiJtYayPDkUr5V988QWuvfZaXH311WjRogVGjBiB3Nxc7Ny5E4DjLvmCBQswdepUDB8+HB06dMCSJUtgNpuxbNkyJbNORETVSJKEv//977jggguUzgoRERFFAWN99Cj6TPlVV12FV155BQcOHECbNm3w9ddfY8uWLViwYAEA4NChQygtLUVubq5rHoPBgN69e2Pr1q24++67ay2zsrISlZWVrvdlZWUAHD8iSZKiW6AIceYzXvLri+bLIkkQq38uBPiZ0ioqkHDDDeh64gSknj2BlBT3z/3lXWVli+ffmSRJkGUZVVVVqKqqgizLAOCaFi9++OEH/POf/8SgQYNc+Y7XsngTbHmc21OSJOh0OrfP4vG3SkRxpqICuuHD0fX4caBfP0AU/c9D5MOBAwfw0EMP4eqrr1Y6K5qjaKX8kUcewZ9//ol27dpBp9PBbrfj6aefxt/+9jcAQGlpKQAgPT3dbb709HQUFxd7XOasWbMwffr0WtMLCgpgMpkiXILoKiwsVDoLEaPVsujslRjy1+v16wtg1xkC+kxpuooKDFm/HhkA1hQWwp6U5P65n7yrtWzx+DtLTExERkYGzp49C6vV6poeb4/oZGVlISsry3UhtLpQy/LMM8/go48+wmeffRZu9iIq0PJYrVZYLBZs3rwZNpvN7TOz2RyNrBERnWO3I+Hjj5EBQGJnbxQB7du3R/v27SO6zPz8fKxevRp79uyJ6HLjjaKV8uXLl+PNN9/EsmXL0L59e+zZswcTJ05E06ZNMWbMGFc6QRDc5pNludY0pylTpmDSpEmu92VlZcjKykJubi5SU1OjU5AIkyQJhYWFyMnJgRjnVzU1XxZrObDX8TIvLxfQV+tIxddnkSLLgOTn5F40ATX3l/Jy18t+/fpBbNDA/XN/ea/+eb+rHOsIdN1REM+/s4qKCpSUlKBevXpISkqCLMs4c+YMUlJSvB7n1KSkpATTp0/HunXrcOLECWRmZuLaa6/FtGnT0KhRo4DLotPp8P7772PYsGGuaY8++ij++c9/qubYHey2qaiogNFoRK9evZBU48KXp4sXREREalRSUoL8/Hx8/PHHrlg/bNgwPP7442jcuHHAyxEEAatWrXKL9Q8++CAmTJgQhVzHF0Ur5Q899BAmT56Mm266CQDQsWNHFBcXY9asWRgzZgwyMjIAOO6YZ2ZmuuY7fvx4rbvnTgaDAQZD7bt2oijG3cl6PObZG82WRRbdprs1DfP1WSTIMvBGHlCy3Xe6rG7AbevcK8eie95qbRt/ea/++YKLglt3FMXj78xut0MQBCQkJCAhIcHVLNo5Tc1+/vlndO/eHW3atMHbb7+Nli1b4rvvvsNDDz2EdevWYevWrUhMTAy4LM7vwEktlXGnYLdNQkICBEHw+LuMt98pERHVTb5i/ccff4xt27ahQc2bO0GoV68e6tWrF7kMxylFz/jMZnOtExudTuc68WnZsiUyMjLcmqRarVZs2rQJPXr0iGleiVRHMvuvkANAyTb/d9ODJZocFW4l1k2qMX78eOj1ehQUFKB37944//zzMWjQIHzyySf45Zdf8NhjjwEALrjgAjz11FMYNWoU6tWrh6ZNm7r13NqiRQsAwHXXXQdBEFzv8/Pzcdlll7nSjR07FsOGDcPMmTORnp6OBg0aYPr06bDZbHjooYfQqFEjNG/eHG+88YZbPr/55hv069cPRqMRjRs3xl133YWzZ89G9bshIiLSAn+xfurUqQCASy65BDNmzGCsD5Gid8qHDh2Kp59+Gueffz7at2+P3bt3Y/78+bjtttsAOO5GTJw4ETNnzkTr1q3RunVrzJw5EyaTCaNGjVIy60Tq8uCPgL5GE3KrGZjXKjrrEwTHHXBvFe5orlvrnI8kWHVArO+UB/G4wR9//IH169fj6aefhtFodPssIyMDN998M1asWIFZs2YBAObOnYtHH30U+fn5WL9+PR544AG0a9cOOTk52LFjB9LS0rBo0SIMHDiwVqdo1RUVFaF58+bYvHkzPv/8c9x+++344osv0KtXL2zfvh3Lly/HPffcg5ycHGRlZcFsNmPgwIHo1q0bduzYgePHj+OOO+7Avffei8WLF4f8VREREYVFlh2PA8Z5rF++fDleeOEFAMC8efMY60OkaKX83//+N6ZNm4Zx48bh+PHjaNq0Ke6++248/vjjrjQPP/wwLBYLxo0bh1OnTqFr164oKChASs3eoonUzOrjbnEknrvWm6LzzLovghD7ddYFkhkNXvTxSEA0PfprwNv04MGDkGUZF13kOa8XXXQRTp06hRMnTgAArrzySkyePBkA0KZNG3z++ed47rnnkJOTgyZNmgAAGjRo4HpsyZtGjRrh+eefR0JCAtq2bYs5c+bAbDbj0UcfBeDoV+SZZ57B559/jptuuglvvfUWLBYLli5diuRkR9leeOEFDB06FLNnz/b6KBQREVFU2SxIeEaBeB+FWP/7778DAHr06MFYHyJFK+UpKSlYsGCBawg0TwRBQH5+PvLz82OWL6KI83XXOMbPXRPFgnP4MGeHaN27d3f7vHv37j6P/d60b9/e7bGn9PR0dOjQwfVep9OhcePGOH78OABg3759uPTSS11BGnBcIKiqqsL+/fvjIlATERGpEWN95ChaKSfSNOdz1yXbfKdzPncdy7vOycmQrFasXbsWg5N5t1tVRBNOj9+H1JSU2Hf05q0XfQ9atWoFQRDw/fffu/Wi6vTDDz+gYcOGPntlDaV3+ZodpDk7Uqs5rfpY6d7WEw+92xMRhYyxXt0SjaiafFQTsf68887zugzG+sCwUk4ULWp67tpT83lJgs5e6XimidRDEBwBU58c++fMgtC4cWPk5OTgpZdewgMPPOD2rFlpaSneeust3HLLLa5guG2b+8Wpbdu2oV27dq73oijCHoVxdC+++GIsWbIE5eXlrivon3/+ORISEtCmTZuIr4+IiCggzscA4zzWjx49mrE+AtT7KyDSAucB1+Nf4FcqwzavFTCzqdufODcbQ/beCd3SIayYU0heeOEFVFZWIi8vD5s3b0ZJSQnWrVuHnJwcNGvWDDNmzHCl/fzzzzFnzhwcOHAAL774It59913cf//9rs9btGiBTz/9FKWlpTh16lTE8njzzTcjKSkJY8aMwbfffosNGzZgwoQJuOWWW+KiORsREZGS/MX6p59+2pV269atjPUhYqWcSKsCHLYs4eh2DltGIWndujV27tyJCy+8ECNHjsSFF16Iu+66C3379sUXX3yBRo0audL+85//xK5du9CpUyc89dRTePbZZ5GXl+f6/Nlnn0VhYSGysrLQqVOniOXRZDJh/fr1+OOPP9ClSxeMGDEC/fv3d/UUS0SkWRUV0N10EzrPmQNUVCidG4pTwcT6SZMmMdaHiM3XifxxDlHlbO5tLQfkv55r8dWrutJ8NZ8vNwPN04GHYjCKQbR7nidFZWdnY9GiRR4/cz7rBQCpqalYvny51+UMHToUQ4cOdZtWs5NPT8OabNy4sda0w4cPu73v2LEjioqKvK6biEiT7HYkrFyJZgCkKDQZprrDV6yvjrE+dKyUE/kiy8AbeUDJdogAhgDAXoXzFAxvw5ZJAKQYNVlnz/NERERERF6x+TqRL5IZKNnuP11Wt6B6s9S8AJvOu3qeJyIiIiKqo3innChA0sR9WF+0BXl5ubWGZWAz7BrU1PM8Ke7nn3+O/ZAvREREFDN79+5Famqq0tmIW6yUEwVKNMGuMziag9eslFNt3prOExERERGRC29dEBERERERESmElXIiIiIiIiIihbBSTqQGVrNjqDVPf3IUekk3mSD98ouP9bPzNSIiorhmMkE6dQpr3nkHMLEzWiI14zPlRGoQ62HDBME9QLPTNSIiIm0RBCA5GfakJHZGS6RyvFNOpBSlhw0TTTiZ3Np3Gg71RkREREQUVbxTTqQUJYcNq6yE7s47UX40BanvHYRYz0sv6RzqjSIoPz8fq1evxp49e5TOik+HDx9Gy5YtsXv3blx22WVKZ4eIKDR/xfpOR48C/ftz5BiKGcb74PFOOZGSnMOGefyL4h1qmw0J//0vzt+wEUjQe88DK+Tkx9atW6HT6TBw4ECls0JERNW5Yv0GwGZTOjcU5xjvo4uVciIiCtkbb7yBCRMmYMuWLThy5IjS2SEiIqIoYLyPLlbKieKBx97Z2UM6Kau8vBwrVqzAP/7xDwwZMgSLFy92+3z27Nlo06YN6tevj9tvvx0VFRW1lrFo0SJcdNFFSEpKQrt27fDSSy+5fX706FHcdNNNaNSoEZKTk9G5c2ds374dADB27FgMGzbMLf3EiRPRp08f1/t169bhqquuQoMGDdC4cWMMGTIEP/30k9s8X375JTp16oSkpCR07twZu3fvrpXPTZs2oVu3bkhPT0ezZs0wefJk2HjniYiI6oC6Fu/79+8Po9GIzMzMmMV7PlNOFA/YO3qdIcsyLDYLEqVEJCTE9rqpMdEIIYhHFpYvX462bduibdu2+Pvf/44JEyZg2rRpEAQBK1asQH5+PubOnYucnBy89dZbeP7553HBBRe45n/ttdfwxBNP4IUXXkCnTp2we/du3HnnnUhOTsaYMWNw9uxZ9O7dG82aNcOHH36IjIwMfPXVV6iqqgo4j+Xl5Zg0aRI6duyI8vJyPP7447juuuuwZ88eJCQkoLy8HEOGDEG/fv3w5ptv4tChQ7j//vvdlvHLL79g8ODBGDNmDF544QUcPXoUd999N5KSkpCfnx9wXoiIiJxkWYZZMqs+1gN1K94PGTIEf/vb3/Df//4XBw4cwJ133hmTeM9KOZFaOXtnL9nmOx17SNcUi82C3I9yFVn39lHbYQrit/T666/j73//OwBg4MCBOHv2LD799FMMGDAACxYswK233orRo0cjNTUVM2bMwCeffOJ29fypp57Cs88+i+HDhwMAWrZsie+//x6vvvoqxowZg2XLluH333/Hjh070KhRIwBAq1bBXaC6/vrra+U5LS0N33//PTp06IC33noLdrsdb7zxBkwmE9q3b4+jR4/iH//4h2uel156CVlZWfj3v/+NM2fOoHPnzigtLcUjjzyCxx9/POYnVEREFP8q7BXo9U6vmK832FgP1L14P3fuXNSvXx8XX3wxfv3115jEe1bKidTKX+/sTuwhnRSwf/9+fPnll1i5ciUAIDExESNHjsQbb7yBAQMGYN++fbjrrrvc5unevTs2bNgAAPj9999RUlKC22+/HXfeeacrjc1mQ/369QEAe/bsQadOnVwBOhQ//fQTpk2bhm3btuHEiROuq+5HjhxBhw4dsG/fPlx66aUwmc6doHTv3t1tGfv27UP37t3d7ixceeWVOHv2LI4ePYrzzz8/5PwRERGpWV2L9926dVMk3rNSTqRmzt7Zqc4wJhpRcHUBUlJSFGnSFqjXX38dNpsNzZo1c02TZRmiKOLUqVN+53cGy9deew1du3Z1+0yn0znyY/Sdn4SEBMiy7DZNkiS390OHDkVWVhZee+01NG3aFFVVVejQoQOsVqsrz/7IslyrqZ9zvmCbABIREQFAki4JX9z0hapjPcB4H6t4z0o5UV1kMkH65Rd88sknGGBi03c1EQQBxkQjTKJJtc2ibTYbli5dimeffRa5ue5N7a+//nq89dZbuOiii7B9+3a3jlm2bTv3KIazw7Sff/4ZN998s8f1XHLJJfjPf/6DP/74w+PV8yZNmuDbb791m7Znzx6If43Fe/LkSezbtw+vvvoqevbsCQDYsmWLW/qLL74Y//3vf2GxWFwnBdXz6Uzz/vvvuwX0rVu3IiUlxe0khYhIVRjrVU0QBFXHeoDxHohdvFfvr4AoUmTZQ8/lNf4CuHqmKYIANGkCa/36bPpOQVuzZg1OnTqF22+/HR06dHD7GzFiBF5//XXcf//9WLRoEd58800cOHAATzzxBL777ju35eTn52PWrFn417/+hQMHDuCbb77BokWLMH/+fADA3/72N2RkZGDYsGH4/PPP8fPPP+P999/HF198AQDo168fdu7ciaVLl+LgwYN44okn3IJ2w4YN0bhxYyxcuBA//vgjioqKMGnSJLc8jBo1CgkJCbj99tvx/fffY+3atZg3b55bmnHjxqGkpAT33XcfDhw4gA8++ABPPPEEJk2apOqTKbWYNWsWunTpgpSUFKSlpWHYsGHYv3+/WxpZlpGfn4+mTZvCaDSiT58+tX4vRBQkxnoKU12N9w8//DB++OGHmMZ7nk2Qtsky8EYeMLOp7783Bta9ijlRiF5//XUMGDDA9SxYdddffz327NmD1q1bY9q0acjPz0eXLl1QXFzs1pkKANxxxx34z3/+g8WLF6Njx47o3bs3Fi9ejJYtWwIA9Ho9CgoKkJaWhsGDB6Njx4545plnXM3d8vLyMG3aNDz88MPo0qULzpw5g9GjR7uWn5CQgHfeeQe7du1Chw4d8MADD2Du3LlueahXrx7+97//4fvvv0enTp0wdepUzJ492y1Ns2bNsHbtWuzYsQM9e/bEuHHjcPvtt+Oxxx6LyPepdZs2bcL48eOxbds2FBYWwmazITc3F+Xl5a40c+bMwfz58/HCCy9gx44dyMjIQE5ODs6cOaNgzomI6ra6GO/XrFmDr776Cp06dcI999wTs3gvyIE0sI9jZWVlqF+/Pv7880+kpqYqnZ2ASJKEtWvXYvDgwa5mGfFK8bJYyx2V7kA8+mvt57erzS89VIy1n2zSxHZBZSXsEyfiSHExmq9YAbFevdiuv/p28fS9B0nx31kYKioqcOjQIbRs2RJJSUmoqqpCWVkZUlNT4/4urJbKAgRfnprbtrp4jE2R8vvvvyMtLQ2bNm1Cr169IMsymjZtiokTJ+KRRx4BAFRWViI9PR2zZ8/G3Xff7XeZqvk+qx/bHvwR0HtvMixJEtavL0BeXm7t41acdeAZz8dgTzRTHqVjfYTF83bRcqwHtBXvlYr1fKac6g5PJ0hWc90cA9xmg+6VV9ASgGSzKZ0bIqpD/vzzTwBwPTd46NAhlJaWuj2vaDAY0Lt3b2zdutVjpbyyshKVlZWu92VlZQAcJ+01O/+JKUmCq6rgJ7aIAIYAwN7an1U17wr76DVxUzF3fueKfvcRpJnyWCwQ/4r1ZosFMBiUzlFY4nm7SJIEWZZRVVWFqqoq1zPLzmnxTkvlCbYszu0pSZLrzr5TML9VVsqp7tCb2JM5EZGCZFnGpEmTcNVVV6FDhw4AgNLSUgCOzoCqS09PR3FxscflzJo1C9OnT681vaCgwG24m5iTZVyV3BqNyw+GtZiEo9uxds1q2HXxVYkqLCxUOgsRFe/l0VVUOC78ACgqKoK9xl28eBWP2yUxMREZGRk4e/asqzdwAJp7REdL5Qm0LFarFRaLBZs3b4atxo0us9nPsMbVsFJOREREMXHvvfdi7969tXrFBWoPN+NpaBqnKVOmuHXiU1ZWhqysLOTm5ir/OIA8GJLk/0RMkmwoKipCv379IIp/nY5JZogLLgIA5OXlxs2FZEmSUFhYiJycnLhrVuyJZspTrd+Gfv36QWzQQLm8REA8b5eKigqUlJSgXr16SEpKgizLOHPmDFJSUjQxtKaWyhNsWSoqKmA0GtGrVy+PzdcDxUo5ERERRd2ECRPw4YcfYvPmzWjevLlrekZGBgDHHfPMzEzX9OPHj9e6e+5kMBhg8NAUVxRFdZys6/X+00gS7DoDxOT65/JsPZd3URQBNZQlCKr5/iMk7ssjuv+e4ros1cRjWex2OwRBQEJCAhISElzNop3T4p2WyhNsWRISEiAIgsffZTC/0/j+1ogiyWr2MFxa4M1OiMKh8T436yRuUwdZlnHvvfdi5cqVKCoqcvW269SyZUtkZGS4NUm1Wq3YtGkTevToEevsEhFFDeOC9kRqm/JOOZFTXezwjRTnvIpqNpthNBoVzg1FkvNZsni7oxNp48ePx7Jly/DBBx8gJSXF9Qx5/fr1YTQaIQgCJk6ciJkzZ6J169Zo3bo1Zs6cCZPJhFGjRimceyKi8DHWa1ekYj0r5VS3iSYgqxtQss13uqxujrREEabT6dCgQQMcP34cAJCUlASr1YqKigpNNAHTSlmAwMsjyzLMZjOOHz+OBg0a1OqNta55+eWXAQB9+vRxm75o0SKMHTsWAPDwww/DYrFg3LhxOHXqFLp27YqCggKkpKTEOLdERJGn5VgPaCveKxXrWSmnuk0QgNvWAf465RFNgJaGDjMaIR04gA0bNqCvWq/YynJg2yXOOxQBzj1Te/z4cciyDIvF4rqDGM+0VBYg+PI0aNDAtW3rskCa9gmCgPz8fOTn50c/Q0R1RTzE+jpEq7Ee0Fa8VyrWs1JOJAhx08NtxCQkAC1awJKe7nitNrIMvJEHlGz3nS6rm+OiSpwTBAGZmZlIS0uDxWLBpk2b0KtXr7hv9ixJEjZv3qyJsgDBlUcUxTp/h5yIFKb2WF/HaDXWA9qK90rFelbKiUh9JLP/CjngeOxAMgNCAD0dxwGdTgeDwQCbzYakpKS4D2w6nU4zZQG0Vx4iIoo9rcV6QFvxUamysFJOVBdZrUiYMgUX//wzMGCAuofdefBHQF/jeX6rmR3zERER+RJPsZ6ojmOlnKgukiTo5s9Hazia6aia3lT3Hi8gIiIKVzzFeqI6jg+YEBERERERESmElXIiIiIiIiIihbD5OkWGt+GrJAk6eyVgLQcS60dn+CpfQ2dZ/QypRcrztI243YiIiIiojmClnMLnY/gqEcAQANiLc8NXRbJiHujQWaRe7LCNiIiIiOowNl+n8AU7fJUS687qBogm/+koNkSTY5v4w+1GRERERBrHO+UUmECbiNcYvkqSJHzy8f8w6Nt7o5zB2ut2I5qi03SeQiMIjlYT/i7ScLsRERERkcaxUk7+BdNEvObwVYIEe4IhennztW7yzmiEtHs3PvvsM/Q0GpXJgyBwexEREUWLGmI9EQWEzdfJPzYR156EBKB9e5w5/3zHayIiItIWxnqiuME75RQcNhEnIiIiIiKKGFbKKThsIq4NVisSnnoKbQ8eBAYMAERR6RwRERFRJDHWE8UNtmUhqoskCboZM9Bu+XJAkpTODREREUUaYz1R3OCdclK/QHt+JyIiIiIiijOslJO6BdPzOxERERERUZxh83VSN/b8TkREREREGsY75RQ/2PM7eWI1A4IEnb0SsJYDcrWObPi7ICIiIiKVY6Wc4gd7fidP5rWCCGAIAOyt8VlWN+C2dayYExEREZFqKd58/ZdffsHf//53NG7cGCaTCZdddhl27drl+lyWZeTn56Np06YwGo3o06cPvvvuOwVzTESKE02OCrc/Jdu8dxJIRERERKQCit4pP3XqFK688kr07dsXH3/8MdLS0vDTTz+hQYMGrjRz5szB/PnzsXjxYrRp0wYzZsxATk4O9u/fj5SUFOUyTxTPkpJg27oVn3/+OXokJSmdm+AJguMO+F8VbkmSsH59AfLyciGKoqNJ+7xWCmeSiIhIQfEe64nqEEUr5bNnz0ZWVhYWLVrkmtaiRQvXa1mWsWDBAkydOhXDhw8HACxZsgTp6elYtmwZ7r777lhnmUgbdDrInTvj9PHjgE6ndG5CIwjnHmcQJNh1Bsd7UfQ9HxERUV2ghVhPVEcoWin/8MMPkZeXhxtuuAGbNm1Cs2bNMG7cONx5550AgEOHDqG0tBS5ubmueQwGA3r37o2tW7d6rJRXVlaisrLS9b6srAyA406aJElRLlFkOPOpmvxKEkTXSwkQAs9XzTIEO38464401W2XMGmpPLXKoqLfTbA0vV3iXCTLo5XvhIiIiMKnaKX8559/xssvv4xJkybh0UcfxZdffon77rsPBoMBo0ePRmlpKQAgPT3dbb709HQUFxd7XOasWbMwffr0WtMLCgpgMsXXkFmFhYVKZwEAoLNXOjrRArB+fYHjjmQw81d7Hez84a47GtSyXcIhSBIuXLMGrQB8IkmQNXJ32blt1Pi7CZYWfmdOWioLEJnymM3s64CIosxqRcL8+Wj1ww/AgAFsSUakYopWyquqqtC5c2fMnDkTANCpUyd89913ePnllzF69GhXOqFGz8myLNea5jRlyhRMmjTJ9b6srAxZWVnIzc1FampqFEoReZIkobCwEDk5OY7nY5VmLXf1ap2XlxtUD+iSJKFo3RrX+2DnD2fdkaa67RKO8nKIN9wAAGg5dy7Eav04xKNa20ZFv5tgael3pqWyAJEtj7MVFxFR1EgSdFOmoD0AacECpXNDRD4oWinPzMzExRdf7Dbtoosuwvvvvw8AyMjIAACUlpYiMzPTleb48eO17p47GQwGGAy174qJohh3J4WqyXO1cZ9FUQzrSmvQ80dw3ZGimu0SDtH9e4378vzFVRYV/m6CpcntohGRKI+Wvg8iIiIKj6JDol155ZXYv3+/27QDBw4gOzsbANCyZUtkZGS4NRW0Wq3YtGkTevToEdO8EhEREREREUWaonfKH3jgAfTo0QMzZ87EjTfeiC+//BILFy7EwoULATiarU+cOBEzZ85E69at0bp1a8ycORMmkwmjRo1SMutEREREREREYVO0Ut6lSxesWrUKU6ZMwZNPPomWLVtiwYIFuPnmm11pHn74YVgsFowbNw6nTp1C165dUVBQwDHKiYiIiIiIKO4pWikHgCFDhmDIkCFePxcEAfn5+cjPz49dpoiIiIiIiIhiQPFKORFRVFlDHHpKNAFeRnkgIiIiIooUVsqJ6qKkJNgKC7Ft2zZ0TUpSOjfRNa9VaPNldQNuW8eKORERxae6FOuJ4hwr5UR1kU4HuXdvnCwvB3Q6pXMTeaLJUaku2Rb6Mkq2AZI5rsY4JyIictF6rCfSEFbKyUGWHRUQT0Jt/kukFEFw3OX29pv2xWoO/e46EREREVGQWCknR4X8jTygZLvSOaFYkSQkvPwyWn73HZCTA4ii0jmKPEHgXW4iIqq76kKsJ9IIVsrJcTcxkAp5VjdHs2CKf1YrdPffj0sASLNnAyZuVyIiVQmnlRo7qiSAsZ4ojrBSTu4e/BHQezloM8gTERHFRjiP0bCjSiKiuJIQykwlJSU4evSo6/2XX36JiRMnYuHChRHLGClEb3I0+fX0x+BORFSnMN7HmLOTynA5O6okIqK4ENKd8lGjRuGuu+7CLbfcgtLSUuTk5KB9+/Z48803UVpaiscffzzS+SQiIqIYY7yPsXA6qQTYUSURUZwK6U75t99+i//7v/8DAKxYsQIdOnTA1q1bsWzZMixevDiS+SMiIiKFMN4rwNlJZUh/fGaYiCgehVQplyQJBoMBAPDJJ5/gmmuuAQC0a9cOx44di1zuiIiISDGM90RERNEXUqW8ffv2eOWVV/DZZ5+hsLAQAwcOBAD8+uuvaNy4cUQzSERERMpgvCciIoq+kCrls2fPxquvvoo+ffrgb3/7Gy699FIAwIcffuhq5kZEKmYwwLZ6NbY99hjw110wIqKaGO+J4hhjPVHcCKmjtz59+uDEiRMoKytDw4YNXdPvuusumDgGIvnia9xVDrkWO4mJkAcPxm9/vSYi8oTxniiOMdYTxY2Q7pQDgCzL2LVrF1599VWcOXMGAKDX6xmkybd5rYCZTT3/vTEQkGWlc0hERNWEG+83b96MoUOHomnTphAEAatXr3b7fOzYsRAEwe2vW7cIDAtGREQUJ0K6bFZcXIyBAwfiyJEjqKysRE5ODlJSUjBnzhxUVFTglVdeiXQ+KY7ZE/Soat4VCUe3+07oHFdVnxybjNVlkgRh6VJkff01kJMDiKLSOSIiFYpEvC8vL8ell16KW2+9Fddff73HNAMHDsSiRYtc7/V6fcTKQFRnMdYTxY2QKuX3338/OnfujK+//tqto5frrrsOd9xxR8QyRxohCLCPXoMESJ4/57iqsWe1IvGOO3A5AOnJJwG2cCEiDyIR7wcNGoRBgwb5TGMwGJCRkRFWXqkGb4+L8VGxuoOxnihuhFQp37JlCz7//PNaV7Kzs7Pxyy+/RCRjpDGCAIi8A05EFE9iFe83btyItLQ0NGjQAL1798bTTz+NtLQ0r+krKytRWVnpel9WVgbAMYSbJHm5AKwyznxGNL+SBNe9UC8Xu6uad4V99JqIVsyjUhYFaaY81X4PkiQBcV4ezWwXaKssgLbKE8myBLOMkCrlVVVVsNvttaYfPXoUKSkpoSySiIiIVCYW8X7QoEG44YYbkJ2djUOHDmHatGno168fdu3a5RojvaZZs2Zh+vTptaYXFBTEXd82hYWFkVuYLOOq5NZoXH7Qa5KEo9uxds1q2HWR7407omVRgXgvj66iAkP+el1UVAR7UpKi+YmUeN8u1WmpLIC2yhOJspjNPjq4riGkSnlOTg4WLFiAhQsXAgAEQcDZs2fxxBNPYPDgwaEskoiIiFQmFvF+5MiRrtcdOnRA586dkZ2djY8++gjDhw/3OM+UKVMwadIk1/uysjJkZWUhNzcXqampEclXtEmShMLCQuTk5ECM5LO+8mBIkocTQckMccFFAIC8vNyI9t8StbIoRDPlKS93vezXrx/EBg2Uy0sEaGa7QFtlAbRVnkiWxdmKKxAhVcqfe+459O3bFxdffDEqKiowatQoHDx4EOeddx7efvvtUBZJ0SbLjk7UPPE1TBkREdVZSsT7zMxMZGdn4+BB73d7DQaDx7vooijG3QlhVPLsqaM867l1iKIYlU6/4vH79yXuyyO6b/O4Lks1LIt6aak8kShLMPOHVClv2rQp9uzZg7fffhtfffUVqqqqcPvtt+Pmm2+G0WgMZZEUTbIMvJEHlPjp/ZyIiKgaJeL9yZMnUVJSgszMzKgsn4iISG1CqpQDgNFoxG233YbbbrstkvmhaJDMgVXIs7o5emUlIiL6S7jx/uzZs/jxxx9d7w8dOoQ9e/agUaNGaNSoEfLz83H99dcjMzMThw8fxqOPPorzzjsP1113XaSKQEREpGohV8oPHDiAjRs34vjx46iqqnL77PHHHw87YxQlD/4I6L1UvDlMSt1hMMC2bBl2796Ny7x0pEREBIQf73fu3Im+ffu63jufBR8zZgxefvllfPPNN1i6dClOnz6NzMxM9O3bF8uXL2fHsUThYqwnihshVcpfe+01/OMf/8B5552HjIwMCNUqcoIgsFKuZnpTRDt3oTiVmAh5xAj8ajLhssSQr80RkcZFIt736dMHsix7/Xz9+vURySsR1cBYTxQ3QtpDZ8yYgaeffhqPPPJIpPNDREREKsF4T0REFH0hVcpPnTqFG264IdJ5IardEzx7ho8Omw3Ce++h6e7dQG5uVHrh1YRwfn98HIQ0gPGeKI4x1hPFjZAq5TfccAMKCgpwzz33RDo/VNfNa6V0DuqGykokjhqFLgCkRx8FOGqCZ+H8HrO6AbetY8Wc4hrjPVEcY6wnihshVcpbtWqFadOmYdu2bejYsWOtMdjuu+++iGSO6gjR5KjAlGzznoY9w1OsBPJ7DETJNsfIB+zDgeIY4z0REVH0hVQpX7hwIerVq4dNmzZh06ZNbp8JgsAgTcERBMcdRclHU2E2BaZYCeT36IvVzBYfpBmM90RERNEXUqX80KFDkc4H1XWCwDuKpB78PRIBYLwnIiKKhYRwFyDLss+hToiIiCj+Md4TERFFR8iV8qVLl6Jjx44wGo0wGo245JJL8N///jeSeSMiIiKFMd4TERFFV0jN1+fPn49p06bh3nvvxZVXXglZlvH555/jnnvuwYkTJ/DAAw9EOp9EREQUY4z3RERE0RdSpfzf//43Xn75ZYwePdo17dprr0X79u2Rn5/PIE2kdno9bP/5D/Z+/TU66vVK54aIVIrxniiOMdYTxY2Qmq8fO3YMPXr0qDW9R48eOHbsWNiZIqIoE0XIo0ejpH9/oMYQR0REToz3RHGMsZ4oboRUKW/VqhVWrFhRa/ry5cvRunXrsDNFREREymO8JyIiir6Qmq9Pnz4dI0eOxObNm3HllVdCEARs2bIFn376qcfgTUQqY7NBWLsW6Tt3Arm5vIJORB4x3hPFMcZ6orgRUqX8+uuvx/bt2/Hcc89h9erVkGUZF198Mb788kt06tQp0nkkokirrETisGHoBkD65z8Bo1HpHBGRCjHeE8UxxnqiuBFSpRwArrjiCrz55puRzAsRERGpDOM9ERFRdAVcKS8rK0NqaqrrtS/OdERERBRfGO+JiIhiK+BKecOGDXHs2DGkpaWhQYMGEAShVhpZliEIAux2e0QzSURERLHBeE9ERBRbAVfKi4qK0KhRIwDAhg0bopYhCpEsA5LZ82dWL9OJiIhqYLwnIiKKrYAr5b179/b4mlRAloE38oCS7UrnhIiI4hzjPRERUWyFNE75okWL8O6779aa/u6772LJkiVhZ4qCJJkDq5BndQNEU/TzQ0REmsB4T0REFH0h9b7+zDPP4JVXXqk1PS0tDXfddRfGjBkTdsYoRA/+COi9VLxFE+Dh2UCqg/R62P/1L3z33Xe4SK9XOjdEpFKM90RxjLGeKG6EVCkvLi5Gy5Yta03Pzs7GkSNHws4UhUFvAvTJSueC1E4UUfWPf+DQ2rW4SBSVzg0RqRTjPVEcY6wnihshNV9PS0vD3r17a03/+uuv0bhx47AzRURERMpjvCciIoq+kCrlN910E+677z5s2LABdrsddrsdRUVFuP/++3HTTTdFOo9EFGl2O4RNm9D4m28ADmlERF4w3hPFMcZ6orgRUvP1GTNmoLi4GP3790diomMRVVVVGD16NGbOnBnRDBJRFFRUIDEnB1cBkO69F0hKUjpH2uRrOEL28UBxgPG+jvE1vKoTj13xg7GeKG6EVCnX6/VYvnw5ZsyYgT179sBoNKJjx47Izs6OdP6IiOLXvFbeP8vqBty2jie3pGqM93VIoMOr8thFRBRxIVXKnVq3bo3WrVtHKi9ERPFPNDlOWku2+U5Xss1xR4odM1IcYLyvAwIdXpXHLiKiiAupUj5ixAh07twZkydPdps+d+5cfPnllx7HNCUiqhMEwXEXyVsTUKvZ9x10IhVhvK+jPA2vymMXEVHUhNTR26ZNm3D11VfXmj5w4EBs3rw5pIzMmjULgiBg4sSJrmmyLCM/Px9NmzaF0WhEnz598N1334W0fCKimBEEx10kj38m//MTqUQ04j3FAefwqjx2ERHFREiV8rNnz0Kv19eaLooiysrKgl7ejh07sHDhQlxyySVu0+fMmYP58+fjhRdewI4dO5CRkYGcnBycOXMmlGwTERFRECId74mIiKi2kCrlHTp0wPLly2tNf+edd3DxxRcHtayzZ8/i5ptvxmuvvYaGDRu6psuyjAULFmDq1KkYPnw4OnTogCVLlsBsNmPZsmWhZJuIiIiCEMl4T0RERJ6F9Ez5tGnTcP311+Onn35Cv379AACffvop3n777aCfLxs/fjyuvvpqDBgwADNmzHBNP3ToEEpLS5Gbm+uaZjAY0Lt3b2zduhV33323x+VVVlaisrLS9d55JV+SJEiSFFTelOLMZ8D5lSSI1ecV1FPOoMuiYloqCwDIM2bg4MGDaAkAcV6muNo2fvbXuCqLH1oqCxDZ8sTLdxLJeE9EMSaKsM+ahR9++AFtRNF/eiJSTEiV8muuuQarV6/GzJkz8d5778FoNOKSSy7BJ598gt69ewe8nHfeeQdfffUVduzYUeuz0tJSAEB6errb9PT0dBQXF3td5qxZszB9+vRa0wsKCmAyxdfzUIWFhQGl09krMeSv1+vXF8CuM0QvUyEKtCzxQDNl6dAB6NABP27apHROIiYetk2g+2s8lCVQWioLEJnymM1+xoJWiUjFeyJSgF6Pqn/+Ez+uXYs2Hh5DISL1CHlItKuvvtpj5y+BKikpwf3334+CggIkJSV5TSfUGAdTluVa06qbMmUKJk2a5HpfVlaGrKws5ObmIjU1NeT8xoQsA5IZkmRDUVER+vXrB1GssYlEU+2xQa3lwF7Hy7y8XFUNUyJJEgoLC5GTkwMxzq/SaqksgLbKE1dl8bO/xlVZ/NBSWYDIlieenscON94TERGRbyFXyk+fPo333nsPP//8Mx588EE0atQIX331FdLT09GsWTO/8+/atQvHjx/HFVdc4Zpmt9uxefNmvPDCC9i/fz8Axx3zzMxMV5rjx4/XuntencFggMFQ+86TKIrqPimUZeCNPKBkO0TAcSdtr4d0Wd0cwy1Vr5jL58oliiKgwnKq/vsPgibKYrdD+PprNDh4EGJeXvyX5y9xsW0C3F/joiwB0lJZgMiUJ56+j3DjPREpxG6HsHMnGhw8CNjtqjw/JCKHkCrle/fuxYABA1C/fn0cPnwYd9xxBxo1aoRVq1ahuLgYS5cu9buM/v3745tvvnGbduutt6Jdu3Z45JFHcMEFFyAjIwOFhYXo1KkTAMBqtWLTpk2YPXt2KNlWN8kMlGz3n65kmyOtiu6GUxyqqEBijx7oDUC64w7AR2sVIqq7IhHviUghjPVEcSOkSvmkSZMwduxYzJkzBykpKa7pgwYNwqhRowJaRkpKCjp06OA2LTk5GY0bN3ZNnzhxImbOnInWrVujdevWmDlzJkwmU8DriFfSxH1YX7QFeXm55+6mWM3AvFbKZoyIIsvq4bliSYLOXuloPUOksEjEeyIiIvItpEr5jh078Oqrr9aa3qxZM1cHbZHw8MMPw2KxYNy4cTh16hS6du2KgoICtxMDTRJNjs6f9MlsakSkZR4utDkfX6n64z/A7etr9yFBFEOxivdERER1WUiV8qSkJI+d1Ozfvx9NmjQJOTMbN250ey8IAvLz85Gfnx/yMomIVEU0OfqGKNnmM1nC0e18VIUUF614T0REROeEVCm/9tpr8eSTT2LFihUAHJXnI0eOYPLkybj++usjmkEiIk0RBEdnjZLnIbEk858QF1wU40wRecZ4T0REFH0Jocw0b948/P7770hLS4PFYkHv3r3RqlUrpKSk4Omnn450Hqkmq9kxrJLrLz7Gu6X4IssyzFabzz+Zzz2HRhAcd8A9/YkmpXNH5MJ4T0REFH0h3SlPTU3Fli1bUFRUhK+++gpVVVW4/PLLMWDAgEjnjzxhh28UZbIsY8QrX2BX8Smf6TpnN8S793SHwOeeiTSJ8Z6IiCj6QqqUL126FCNHjkS/fv3Qr18/13Sr1Yp33nkHo0ePjlgG6S+BPIea1Y132Sgwogj7Y4/h4MGDuNBDZ4IWye63Qg4AO4tPwSLZYdKHdCghIpVjvCeKY35iPRGpR0hn0rfeeisGDhyItLQ0t+lnzpzBrbfeyiAdDX6eQwXgqJDzjiUFQq9H1eOPY//atbhQr/eZdOdjA2DS69ymma12dJ7xSTRzSEQqwHhPFMeCiPVEpKyQKuWyLHtsrnr06FHUr18/7EyRF87nUIliyKTX8U44UR3FeE9ERBR9QZ1pd+rUCYIgQBAE9O/fH4mJ52a32+04dOgQBg4cGPFMElGEVVUB332HlCNHHK+JiKqJZLzfvHkz5s6di127duHYsWNYtWoVhg0b5vpclmVMnz4dCxcuxKlTp9C1a1e8+OKLaN++faSLRVS3MNYTxY2gKuXOILpnzx7k5eWhXr16rs/0ej1atGjBIVKI4oHFArFTJ/QDIN1yC2AwKJ0jIlKRSMb78vJyXHrppbj11ls9zjNnzhzMnz8fixcvRps2bTBjxgzk5ORg//79SElJiUh5iOokxnqiuBFUpfyJJ54AALRo0QIjR45EUlJSVDJFREREyolkvB80aBAGDRrk8TNZlrFgwQJMnToVw4cPBwAsWbIE6enpWLZsGe6+++6Q10sKkGXHUK2+sP8bIqJaQnpQdMyYMTh9+jTefPNN/PTTT3jooYfQqFEjfPXVV0hPT0ezZs0inU8iIiKKsWjH+0OHDqG0tBS5ubmuaQaDAb1798bWrVu9VsorKytRWVnpel9WVgYAkCQJkiSFladYceYzZvmVJIiulxIgSBH7XJIkQJaRsGQw8MsOn9moat4V9tFrVF0xj/m2iZaa2yzOy6OZ7QJtlQXQVnkiWZZglhFSpXzv3r0YMGAA6tevj8OHD+POO+9Eo0aNsGrVKhQXF2Pp0qWhLFb7ZNl77+lWH72qE6mY2Wr3+plR1HEMc6I4Fu14X1paCgBIT093m56eno7i4mKv882aNQvTp0+vNb2goAAmU3wNDVpYWBiT9ejslRjy1+v16wtg1xki+3mVFTo/FXIASDi6HWvXrK41vxrFattEi66iwrXNioqKYNdIC9d43y7VaaksgLbKE4mymM2B1+9CqpQ/8MADGDt2LObMmeP2vNegQYMwatSoUBapfbIMvJEHlGxXOidEEeVraLTO2Q3x7j3dWTEnilOxivc1jxHeen13mjJlCiZNmuR6X1ZWhqysLOTm5iI1NTVi+YomSZJQWFiInJwciLEYQ9paDux1vMzLy609mksYn0uShKJ1a869n7jP0Uy9OskMccFF3pevIjHfNtFSfu5Rgn79+kFs0EC5vESAZrYLtFUWQFvliWRZnK24AhFSpXznzp1YuHBhrenNmjVzXfWmGiRzYBXyrG61AxmRyhhFHTpnN8TO4lM+0+0sPgWLZOeQakRxKtrxPiMjA4DjjnlmZqZr+vHjx2vdPa/OYDDA4KHTKlEU4+6EMGZ5ls+tQxRFoOY6w/28GtFU30OlPvD51SIef09uRPfvPK7LUg3Lol5aKk8kyhLM/CGdKSclJXms+e/fvx9NmjQJZZF1y4M/AnovFW/RBNhssc0PUZAEQcC793SHRfLcdN1stfu8g05E8SHa8b5ly5bIyMhAYWEhOnXqBACwWq3YtGkTZs+eHfbyiYiI4kFIlfJrr70WTz75JFasWAHAcYJ+5MgRTJ48uW4PiRboM+N6k6qbbVEdIIqwT5qEn37+GelyAkSr+4UgX8+JOwmCwDvgRBoXiXh/9uxZ/Pjjj673hw4dwp49e9CoUSOcf/75mDhxImbOnInWrVujdevWmDlzJkwmEx+HIwrXX7H+559/RguN3L0k0qqQzqjnzZuHwYMHIy0tDRaLBb1790ZpaSm6d++Op59+OtJ5jA98ZpziiV4P+6xZuHtuAQ7N/kzp3BCRSkUi3u/cuRN9+/Z1vXc+Cz5mzBgsXrwYDz/8MCwWC8aNG4dTp06ha9euKCgo4BjlROHS61H1zDP4fu1atNDrlc4NEfkQUqU8NTUVW7ZswYYNG7Br1y5UVVXh8ssvx4ABAyKdv/jBZ8YpzlgkOw6d8d0BW+fshjCKuhjliIjUJhLxvk+fPpBl2evngiAgPz8f+fn5EcgxERFR/Am6Ul5VVYXFixdj5cqVOHz4MARBcD0T5q+31DrD3zPj/I5IaVVVQPER19udjw2ASV+78h2JIc04ZBpRfGK8J4pzVVXA4cMw/vab4zURqVZQlXJZlnHNNddg7dq1uPTSS9GxY0fIsox9+/Zh7NixWLlyJVavXh2lrMYRPjNOamexQLzsUmDS+wAAk14XtefDOWQaUfxhvCfSAIsFYps2yAUg3Xgj4GHEAiJSh6DOwhcvXozNmzfj008/dXs+DACKioowbNgwLF26FKNHj45oJokovnDINKL4xnivcVYPndJ6mhbo/JIEXVVleOt3YotCIqqDgjoTfvvtt/Hoo4/WCtAA0K9fP0yePBlvvfUWgzRRHcch0yLE24krT1opyhjvNW5eq4jOLwIYFKn1Z3UDblvHYxwR1SkJwSTeu3cvBg4c6PXzQYMG4euvvw47U0QU/5xDpnn+Y+dxAZnXCpjZtPbfGwMdIz4QRQnjvQaJJkeF1x9vHdLGav6Sbd6HlyUi0qig7pT/8ccfSE9P9/p5eno6Tp3y3VyViIh8EE04mdwajcsPek/jPGll3xUUJYz3GiQIjjvQ/iq83lri+JhfkiSsX1+AvLxciKb6Qc8PwNEyKNw7+EREcSqoSrndbkdiovdZdDodbDZb2JkiosiQZdlzE3KrHWYxKfYZIv8EAVtaP4bBOX0giqL7ZzxppRhhvNcoQQjvYp63+QUJdp3B8ZmvZufhrp+ISKOC7n197NixMHjpvbGyMohOPogoqmRZxohXvsAub52tTXgrthmiwDlPXGtWyolihPGeiIgodoKqlI8ZM8ZvGnb6QqQOFsnuvUJezRXNU2EU+Yw3EZ3DeE+kAYmJsN9zD44UF6O5j5YvRKS8oPbQRYsWRSsfRBRFOx8bUKtzNeczgMOGdOU44UTkhvGeSAMMBlQ9/zz2rl2L5hyjnEjVeNmMqA4w6XW1xgKXBBkGHVghJyIiIiJSUFBDohGRRsgy8Pvv0P/5J4fWIiIi0iLGeqK4wTvlRHWR2QyxWTMMAiBdcw2g1yudIyIiIookxnqiuMFKOZGKeR3SLABma2jzERERERFR7LBSTqRSfoc0IyIiIiKiuMdnyolUKtAhzfzpnN2QQ54REREREakU75QHSpYByez9c6uPz4i88NU8vXrzc09DmgXKKOrYwzoRERERkUqxUh4oyQzMbKp0LkhDgmme7mlIMyIiIiIiin9svh5pWd0A0aR0LigOBNo8nc3PiYiIiIi0i7feAiWagEd/DSwdmwpTkHw1T49K8/PERFTdcguOHj2KzEQeBoiIiDSHsZ4obnAPDZQgAPpkpXNBGhXz5ukGA+yvv47da9ci02CI3XqJiIgoNhjrieIGm68TERERERERKYSVcqK6SJaB8nLoKiocr4mIiEhbGOuJ4gabrxPVRWYzxIYNMQSAdOoUoNcrnSMiIiKKJMZ6orjBSjkRERERqYfV7Hk6O9MlIo1ipZyIiIiI1GNeK8/Ts7oBt61jxZyINIfPlBMRERGRskSTo9LtS8k2QPJyF52IKI7xTjkRERERKUsQHHfBPVW6rWbvd8+JiDSAlXIiIiIiUp4gAPpkpXNBRBRzrJQTkaLMVrvXz4yiDgKfHfTMW0dIADtDIiIiIoojrJQT1UU6HaqGD8ex0lKk6XSKZqXzjE+8f5bdEO/e050Vc098NeVkZ0hERKSiWE9EvrGjN6K6KCkJ9nfewc6HHwaSkmK+eqOoQ+fshn7T7Sw+BYvk/U56nRNIR0gAO0MiIiLFYz0RBY53yoko5gRBwLv3dPda4TZb7T7voNdZvjpCAtgZEhEREVEcYqWciBQhCAJMeh6CgsaOkIiIiIg0hWfERHVReTnEevVwLQDp1CmgQQOlc0RERESRxFhPFDdYKSeKIlmWfTbRVjNZlmGxWXymMSYa2QkbEREREVEYFK2Uz5o1CytXrsQPP/wAo9GIHj16YPbs2Wjbtq0rjSzLmD59OhYuXIhTp06ha9euePHFF9G+fXsFc07knyzLGPHKF9hVfErprARNlmWM/ng09vy+x2e6TmmdsGTgElbMiUhTfF1QBcIbrtG5bEmyodIOmK02iLL7spQaDtJfuQEVDFXpazjIcHE4SSJSiKKV8k2bNmH8+PHo0qULbDYbpk6ditzcXHz//fdITnY8MzlnzhzMnz8fixcvRps2bTBjxgzk5ORg//79SElJUTL7RD5ZJHtAFfLO2Q1hFNU1VInFZvFbIQeA3cd3w2KzwCSaop8pIqIYCOSCaqjDNdZediIe/rIoYssPR6AXkhUfqjKanVk6h5MkIooxRSvl69a5H/gWLVqEtLQ07Nq1C7169YIsy1iwYAGmTp2K4cOHAwCWLFmC9PR0LFu2DHfffbcS2a6T4uLquUK8fTfVm6fvfGwATHrPFW+1f28bb9wIY6LRbZrFZkGfFX2UyRARURQFckHVOVxjsJ1VBnqxNtTlh0PNeXMNB1myLbrrcQ4nKeijux4iohpU9Uz5n3/+CQBo1KgRAODQoUMoLS1Fbm6uK43BYEDv3r2xdetWj5XyyspKVFZWut6XlZUBACRJgiRJ0cx+xDjzqZb8yrKMm/6zA18dOe0z3RXnN8Dbd3Rxq2CqrSzh8FSWQL8bUaiCKCR4/Mxms0UsjwGTJIiulxJQY/tUz5P41z+3z2FzSyshsttXkmzVXkuQBNlPem3/zoKY2X27Csp+H1raLkBky6OV70Tral5QjeRwjdse6Y3NGz5FXl4uRFGM+PLD4elCsqJ58zccZLg4nCQRKUw1lXJZljFp0iRcddVV6NChAwCgtLQUAJCenu6WNj09HcXFxR6XM2vWLEyfPr3W9IKCAphM8dXEtrCwUOksAAAq7cBXR/z/VHYdOY3Vaz6GwcMNYbWUJRKqlyWQ76ZliowNhQWqekxNV1GBIX+9Lioqgj0pye1zq2x1vV6/fj30Ne4a+Ps8XJV2wHl4Wr++wONvyhOt/s4CpbNXurbr+vUFsOsMkc1UiLS0XYDIlMdsjuJzsRQxJr0uaneEjXodDDrApE+EKKrmdAxAdMsdMg4HSUQappoj7r333ou9e/diy5YttT6r2bRXlmWvzX2nTJmCSZMmud6XlZUhKysLubm5SE1NjWymo0SSJBQWFiInJ8d19VxJZqvN9czbtkd6w1jj6rnFake32ZsAAHl5uW6BXG1lCYensvj7bgCVNk+vqIA9Lw+/nziBfjk5EGv0z2CxWfDkiicBAHl5eR6br/v6PFzVv9eavylPtP47C5i1HNjreJmXl6v4CayWtgsQ2fI4W3EREUWNToeqQYNw/PhxNNapq+8aInKnikr5hAkT8OGHH2Lz5s1o3ry5a3pGRgYAxx3zzMxM1/Tjx4/XunvuZDAYYDDUvjskimLcnRSqJc/Ve4VNTU6qVUESxWpNnUXR4xV/tZQlEqqXxd93o1qiCOl//8P2tWsxOCWl1rap3hw9MTEx6M/Dzl6171WSEyDJni9q1LzgodXfWcDkc+lFUQRU8l1oabsAkSmPlr4PIlKppCTYP/jAEetrtIgjInVRtAYhyzImTJiAVatWYePGjWjZsqXb5y1btkRGRgYKCwvRqVMnAIDVasWmTZswe/ZsJbJMRDHm6xlGZy/ARERERETxStFK+fjx47Fs2TJ88MEHSElJcT1DXr9+fRiNRgiCgIkTJ2LmzJlo3bo1WrdujZkzZ8JkMmHUqFFKZp2Iosgo6tA5uyF2BtgDsqiypwOIiIiIiAKlaKX85ZdfBgD06dPHbfqiRYswduxYAMDDDz8Mi8WCcePG4dSpU+jatSsKCgo4RjlFTKDDvWlKeTkS09Iw2G6H5eghSPXru31ssVkUypiDIAh4957uXreLWnooJqLIyM/Pr9VJa3p6uutiPRGF4K9Yf7XdDrm0FGjQQOkcEZEXijdf90cQBOTn5yM/Pz/6GaI6R5ZljHjlC79js3bObohlt3eOUa5ixGzGbVNbYs9Huf7TKkAQhPh5Rp+Iwta+fXt88sm5i206dkxFFDbBbEYiEOGBS4ko0njGS3WaRbL7rZAD55pJa4lFL2BPa9+9c3dK6xTxntWJiDxJTEx0dfAaz6qqqnCqotzjZ2arHRCsbp0yRpq/1l+qHBFETaxmQJCgs1c6RrSI5LYSTVDV+KhEpBqslJPqBdq8PNyTjJ2PDYCpxpBmam8mLctyaE3NbRZYDAmutxtv3Oix8m1MNPLkjYhi4uDBg2jatCkMBgO6du2KmTNn4oILLvCYtrKyEpWVla73ziHmJEmCJIV3T1CSbNVeS5AEOaDPAEeF/Kq3bkSF7mevy09pB9jM2bBae7mWE+jy/ZFlGTf9Zwe+OnLaa5orzm+At+/oUuvY7m/dvr8XqVZZ4ookwVX1ntcKIoAhgGuIyUipat4V9tFrYlcxr1YuSZKAeN0+f4n731k1WioLoK3yRLIswSyDlXJStWCal797T/ewKpAmvS6umkvLsozRH4/Gnt/3hLaAf1/kemlMNMIkmiKTMSKiIHXt2hVLly5FmzZt8Ntvv2HGjBno0aMHvvvuOzRu3LhW+lmzZtV6Bh0ACgoKYDKFdyyrtAPO06P16wtg0AX2GQCcsVl9VsidEk3F2LBxPQwJehQWFga8/EDy/tUR33Fs15HTWL3m41rL9rfuQPJWvSxxRZZxVXJrNC4/GNXVJBzdjrVrVsOuqz10bzToKiocFxcAFBUVwa6RYdHi9nfmgZbKAmirPJEoi9lsDjht/NRAqE4Ktnl5PFWqw2WxWUKvkFdzWaOObKJORIoaNGiQ63XHjh3RvXt3XHjhhViyZAkmTZpUK/2UKVPcppeVlSErKwu5ublITU0NKy+yLCMvz9E6q2YrLLPVhoe/LAIA5OXl1oo5J81nMHv1kwCAFXkfoaGxntvnFTYLhq4ZCADo378ftmzYgpycHNe49f6W70/1+bc90hvGaq2/LFY7us3e5HXZ/tbt63NJklBYWOhWlrgjD4YkOU6gJcmGoqIi9OvXD6IYgfMKyQxxgeNCeF5eLqD3/ehYxJSfe4yiX79+EOO8ozdN/M7+oqWyANoqTyTL4mzFFYi6U4MhRcmyDLPV5jONvybo8di8PFa8NT/3ymwG0tIAAImlm8NqYeCr+TybvxNRKJKTk9GxY0ccPOj5zqXBYIDBUPtuoyiKETkh1Os9Txflc8czx7rcT6OqrzsttSEam9xHijFL5lppq+fZ3/L9qT5/anKSW8VZFG3VXnvIu7+yBZC3SH3/inFueEmCXWeAmFw/MuWxnluGKIpArL4j0X29cb1tqmFZ1EtL5YlEWYKZn5VyijpZht9n3AD/TdDjrXl5LAXd/FwvoKpbT/xx8iTqh9nDcZ8Vfbx+1imtE5YMXMKKOREFpbKyEvv27UPPnj2VzgpR/EpIQFWvXo5Yn5DgPz0RKYZ7KEWdtQp+K+SANns4Vy2jEfZPPsHnTz8NGINvum5MNKJTWie/6XYf3634mOdEpH4PPvggNm3ahEOHDmH79u0YMWIEysrKMGbMGKWzRhS/woz1RBQ7vO1IMRXNJuhma/AV+mDmsVjtqLQ7nqtzNuMLZZ1aIAgClgxc4rXCbbFZXHfQ2bydiPw5evQo/va3v+HEiRNo0qQJunXrhm3btiE7O1vprBEREUUdK+UUU9Fsgh7tZ8sdHeQkujq6qesEQQioyTybtxORP++8847SWSAiIlIMm69TXDOKOnTObhj2cjpnN4RRrP1sdaDL9za/apWXI7FpUwwcPdqtd9ZIYfN2IiIihUU51hNR5PBOOcU1QRDw7j3dw34W3VvP79WXL0kS1q8vQF5ebq3eFP31HK9GwokTMACQorHsIJq3ExERUXREM9YTUeSwUl5HyLLst+IaiYplzWesJckGa1VYi/RLEISo9sruXL4kyDDoAJM+MTLjlmpcoM3bKUqsZu+fiSYgzi4iEZGDr3geaD8nntJFoo+USAx/qnm+js2++DpuyzIgeViu1QyI1dIQkWqxZlEHyLKMEa98gV3Fp3ym8zckWSA8P9fNnxlRzM1r5f2zrG7AbetYMSeKM4HGc3+i0QdLpIY/1Txfx2ZfvB23ZRl4Iw8o2e55vkdTAQC6d0cAd37C4z6RSvGZ8jrAItkDCuChDkmm2eeuieKNaHKcuPlTss3zXRUiUrVA47mneBvtWM3hT30I9Njsi7fjtmT2XiGvJuHXnTzuE6kYb2HWMf6GJAulSZuv57qrP4edakqqu1fGiWJBEBx3UrydeFnNod+lISJV8RTPnTw1EQ+0D5ZINC+P5vCnccnfsdmXYI7bD/4I6Ks9NlZuBpqnAw+lBL9eIoopVsrrGH9DkoUaML091139OWxWyIliQBAAfbLSuSCiKAtliNFo98HiFM3hT+NWLI7NepP7OiQAEp8lJ4oHbL5ObH5eFyUkoOqKK3CqVSsggYcBIiIizUlIQFUn/8OTEpHyeBmTYtqkjVTCaIT9iy+wee1aDDYalc4NERERRZrRCHtRERLmZiudEyLyg5VyAhC7Jm1ERERERER0DtutEhERERERESmEt0ZJVWr29O6v53e1k2UZFpvFZxpjotHrYwG+5ve3XJ/MZiRefDFyzGbg4EGgfv3Ql0VERETqYzYj8dJLgb8rnREi8oeVclIVLQ2XIssyRn88Gnt+3+MzXae0TlgycEmtinmg84eYOQjFxTABkGT2zEpERKQ5sgzhyBEAqUrnhIj8YKWcFOfs/X1n8SmvaeKx53eLzRJQhXr38d2w2CwwiSa36YHO3ymtE4yJ7KyNiCiWPLXkimTrrmgvPxw18yFJNlirwl+uLMs+O5311eGsv3kDEU6HtpFYv0dWG1xnB1YP45x7muZ1WT7SiibHsG1EpAhWyklxgfT+Hu89v2+8cWOtirPFZkGfFX1Cnt/JV/N3IiKKDo8tuwQrUtpFcfkq4Tlv4Z1SyrKMEa98gV1+LtC/e093jy3L/M0bCOfygxWp9XtiRAX2Jf31Zl6r8Bbma/6sbsBt61gxJ1IIK+Uq4rzKKkk2VNoBs9UGUXY/OHqrnPq6QquWK+u+aL33d2Oisdad8Oo8PR9efZq/+esys9UOUajyuM/E+8UcIlKXQFp2OSUlBt+XbqDLV6L1WLTzZpHsfiu1O4tPwSLZa50vBDJvIJzLF4MMG5Fav8dlw4AdVW3QJeGA74RZ3Rx3u2uSAByxAef7Occq2QZIZkCfHHJeiSh02q0FxZnaV1kT8fCXRbXSebpKHM0rtBQbgd4xp9rO3bGpvc94u6tCRBQKfy27LDYL+rz7uCttpJfvpMQFR195kyQJ69cXIC8vF6mmpLDztvOxATDpz1XszVZ7wC0Has4biGCWH431++LIG2BEJXY9NsD7DQxfzc8XmSEd/wWip05drebw78ATUdhYKVeJQK+yerpKHOi88fhctpYZE43olNYJu4/v9pmOz4zXFugdG293VYiIQuWzZZcQfoxVc8sxb3mTBBkGHWDSJ0bkYoFJrwv5Owhn3kiIzvoFWJDkuIsd6rJFE++CE6mYOo/6ddy2R3pj84ZPkZeXC1EUAQR+FdfXFVolm/LKsgyz5Lszkrr2bLQgCFgycElYQ6aFsXLIF12EM2fPwhiH33nNOzbV79KIohjRux5ERERxKc5jPVFdwkq5Chn1OtcVZ1EMbhMpfYXYE1mWcVvhbfj6xNc+03kbGkzLBEFQ5llxkwm2r7/GhrVrMdgUn8+qV79jU/0uTbD7DBERkSZpINYT1RXB90JCFCQJkt8KOXBuaDAiIiIiIqK6greUKCJkWfZYobbZbLDKVtd7f0ODeauU17Wm7UREREREVDewUk5hk2UZoz8ejT2/7/Gb1t/QXt56Ia+LTdujymxGYufO6Hv2LNCnD+CpR1YiIiKKX4z1RHGDzdcpbBabJaAKubdexJ29kPvCpu0RJssQ9u1DakkJIMtK54aIiIgijbGeKG7wTnkMybLsdexRs9X3mKTxombzdJvNhvXr1yMvLw8pSSke73T76oW8etN2pTib5jub4ltsFkiQ/M7HiwikalbfoyH45Gs8XKI4V/1xLCUenfL2OFikRLNMvkZasdjsgGAFZDHUpQOChJPms7DY3EeZMVvDXbb7skShCpV2wGy1QZT9f1exOocLej1WOyAaAACJgVTKfcUFHveJooqV8hiRZRkjXvkioPHE41nN5ukSJOgFvd+TAMV6IffDU9P8J1c8qVyGiCJlXqvQ583qBty2jidopEkWmwVdl3UFAGwftT2msSmYx8FCFa3HwQIZaSWlHWAzZ0OW84Jetin7FehMxRj8QWSXXdO54TQT8fCXRWEtK9JCGupz0vsAgCve+gbvje/pe7v7igs87hNFFZuvx4hFsgdUIe+c3RBG0fM44xR7gTbN98Vbs32imBNNjhOrcJVsA7zcDSOi0EUi5vgTrcfBAh1pJdFUjAp7RXALF6zQmYoDWjYEq990NRlFHTpnNwx6vpqicQ4XqbztOnrGc2vNQOMCj/tEUcU75UHw1fzcySjqfFyFdDS9+uyRvjDpPR+0GyYlw27XRlN2rflk+CfY/Olm5OXlITEx8F2HPcfXPeEfK6K0bEFw3OkI9cTKag7vDjsRBczTaCXhiOXjYJ7y/oflLAat6h/S8qofzz6+7lOPo7g4lx3KcVUQBLx7T3fXsVWSJKxfX4C8vFyIYuBN4kM9rgeTt6CUm2Fufj46T3jL1wp8xwUe94ligpXyAAXa/LxzdkO8e0/3WgflQJpeAY67qv/p/59IZJkizJhodDXFDyZIU90S7rEi6ssWBECfHPA6iUgZ/kYrUTNPeQ+pUulBI2O9Wss2S+HfnRYEASa947RYEmQYdIBJnwhRVP5UuXregiLpACmAVgmMC0SKY/P1AAXa/Hxn8SmPgafCXhFQ06vdx3cH36yLKFiCADk7G+YmTfh8WISFe6xQatlERKQxggA563ylc0FEAVD+8l8c2vnYgFrNz81We8AdcHx83adoZKznNk0NvYxTHWIywXbwIArXrsVgU3zeiYkH4R4rlFo2ERFpgMkE296vgafU1WEdEdXGSnkITHpdaM2I/hJuk7SaQ2IEMkRGIEOs+Hr22df8sRr6y9d6+Nw2xVKgwxuGeqyQZc9D8URi2URERESkLjyji0PB3gkLdIgVb8OkxGKIlkD4akkQrSFeiGqK9vCGsizjX9/pMHEb72wQERER1QV8pjxOBDIkhrehOAIdYsXbMCmBzh+Nob+MiUZ0SuvkN120hnjRLIsFuu7d0evBBwELv7dgRHt4Q4tkx6Ezvi8ucehEIiLyy2KBrm8/pXNBRAHgnfIAGUUdvn8yz/U61gIZEiOQoTg8DVNS/Xl2b5VyX/O71h+FJuSCIGDJwCU+m87zWfwQVFUhYdcuNAQgVVUpnZuo8vZ4RySGrvH0XHcwy/eUN0u1ad6WH41hd4iISGOqqpCwZzfAejmR6rFSHqCQh6NQWR78Pc/ur4KrxBAtgiDE7bAwpDxvj3uEMiRZTeE+1+3vURQ+N05ERESkfTzbI1cT8d3Hd/tMF43m6UTR4HzcY6ePZubOYcNiXekNJG8AcMX5DdhEnShY5eWAzsN+o9MBSUnu6bypqnS9tNgsgNnsPW1CgttyLWf+OPeZ2QwkyufeCwIgwi2t3VIGy58nIIniufV5YrEAvlo1JSf7T1tt2a71VFYCdh+dxVYfncNHWpskwVrte4PVClhl90TVvsc/ys9UW64VsNlgluyAYHXk78+TgLOVUFISLNWXXfN79VY2SXL8eZOU5Nh+HtLaJMl921RPa7M5yueNwXDuNxhMWrvd8R17o9cDiYnBpbVZYNELru/15InjsNSMK6II6MVzy62osVzJDONfF68tv/8CJKc6pldV1U5bXWLiueUGk1aWAYv70MBJuiQIggBJklBlPgvz2T8hiqLHtG50OsCgP/fe7L5/ybJ8bhhiP2ndJCQASYaA0iaJJgjGasceSwUgy46ylJ3GyWOHITq3qyAANdImJRg83zyombaistZ+b0xMODdvcrV92WIBqmrsQ9U504om/8eIaseeBKvVcWwVRc9pTaZzw/BWVjr2D2+CSWs0nts/rVbf+30gaSUJuooKR7mdZfG33KSkc/uyJJ3b733FmhpYKY8CT01SA+khPRzh9I7ur4m4k9p7OA/nmXK1l03LotGrvq/HPaoPGxbKfhnuvuzvURRJkrB+fQGGDenC3yRRsJo29Tx98GDgo4/OvU9L817Z7t8LuMXxMqzHo9LS3CumF18M7Nnhejvg46EAgCc+muN/Wb16ATt3ev7svPOA338/937QIGDTptrp9AKwsD2AMMsViAkTgEVvuk9LTgJebAUAGL42z+NsKe0c//dZ62PZNb9XIGplC2jbqN2LrZCCxwEAgwtDXEaLLMf/n1wfmTwFqVNFBZYcOw4TgOsAYH/4y5QBjM5Mx57qlesocOa9ZjSXAazMTMfjG3yv39v8MZHVDVipA9Z+7D2NfG5fvHzBAog33ug97dmz5yrxd98NLFniPe3x40CTJo7XkyYBL73kPe2hQ0CLFo7XU6cC8+Z5T/vtt0B7x7ECM2cC06fXSiICGALAtnUr0L27Y+K//gU8/LD35W7YAPTp43i9cCFw773e03rBSnkUeGySKlhdwSbSItE7uhaaiIcTiNl7u3Ki1at+II97KDWmt6+8SYIMgw78LRIpxGhDQK3HfOl0oBzGmhVHBNEyrdgW+Y5TrTI6/ViB3a2S/CcOQ6e0TjBW1T5+NSyvgPFUE1ga/u5hrgCXXd7A8/dqldHpQDl2t0n2MBfFu91JSbAIAkyyj7u7QbIIQtQr5ID3vAe6/miUPWAl24CE7rFfbx3FSnmEBNokFQCSEiPb6b2SvaMrLdATHH+cvbfH+4WJeBHodovGdglmX/WFPaATqdCvvwKpqbWn12zSfvy410UICQlYkpR0rhVPEM3XYbEAsgyjLgnCozUqpoLg1jLNVlaGTwoLMWDAACTWaO5Zq5XQ5s2+m69X9/HHHtMKAJbIMiyGaucgEWy+vv6zz5A3cCBSklIg9LMCL7rf2UoAsK2qCqcqzIDJWK1pqtWtaWqSmOBe9mpNx41VOghjajdjdZVNhNcm6bX4ab7+ySefnNs28dp83WwG0tIgAzjz/Q8QU+vXTuuv+TrguBtqs4TeJD3E5usWewUGFTnuvFru3A1JTkTR5s3oNzAv7ObrFpsFKLwGAPBxvxUw6pMj2nzdLe/3/wA4z7//ar5eVnEG2DD83Pp1SW5N0i22Cgz6aKir7Kh5/u6j+bpZsqPnv7cBAHZNuhImURdc83URwDxHqxa89RagC+xC3lcTJyLto48c28aT6seTV18FXnzR+8Kqp50/H5jjo9WKsdp38/TTQH5+YGkffRR46KFaSRwtFtcjr1O10Z/uvx8YN877cqvHgbvuAsaOdbwuK/PegqsGVsoDVL15uKcmtf6apFpsFvR593FX2nDzUHPZTrHuHV1pgTa996Yu994un3cerFarIuMiKtmrfiAjGQRC7T2g+2pmr/a8E4UsOdn9+Wpf6XwQgHMXA+sHcVEwgAuIzpZpUqoInTEVxvrneT+JdTIGcUHdR1oBgFsOg7ng6SOtJEnQJxjOnWcYDI6/GhIANE5JcZ8Y7DVXD8sFPJUtiGXWSCtJkvdtIwIIdHMEmzYpxW+yoNImypBTG8NqtaJx4zSIDRr4nyfALETVXyMAm6VzF8SMTdIhQkSCqR5M9eqf2y7B5LdetYsS1ZbdKCO79sX/BkEs10Nat7wnp55b/l95sFnOrc/T+muW3e/NiXrVXlttsOCvSmKD84CaLfP0fo6R1mrPQScl+U//lyq93nFs9Xc8A7weI8JOq9c7/sJJK0mwV39GPNjliuK578DXRc8aWCkPkMVmQddlXQEA20dt97hz+GwuK4R3Ry3QJupK9I6uNC00vY+55GTYfv0V69auxeBATmCjQMntpobRFKLNV9P8SPQ8T0REKqeCWE9EgVHiJhmFIJAm6lpsnk5EgXM2zffH2fM8ERERESlP27eKNMpbE3UtNk8nosD5a5pfved5IiIiIlIHVspDEMrzy8HMY7FZYJWtsNgskCDVmr8uNlGPBX/P62uKxQLdwIG48uRJoG/fwJ7/UUg0hkzzx9cQg5HiK+/O9Tv3/2DmrQtN84mIKABxFOuJ6rq4OHN76aWXMHfuXBw7dgzt27fHggUL0LNnT8XyE+2OwQasHAAAeHLFk1FdD7mrUx2+VVUhYfNmnAdACrRHX4UEMmRaJEViiMFAeBvuTZZlvHb2NUxbMS3oeYnindriPVFci6NYT1TXqf6Z8uXLl2PixImYOnUqdu/ejZ49e2LQoEE4cuRITPPhHMIpXN6e+w50+XxuPLKC+d6TAhwSgsIX6HZxDpkWSYEOMRgub3mvsFfgiN338S0a5SZSmlriPRERUayp/k75/Pnzcfvtt+OOO+4AACxYsADr16/Hyy+/jFmzZsUsH+EOveXkrdmp29ilNptjfLy8PCQmJgY0P4Um0O1qTDTCZqs9NipFRzBDpllsFthgq/XIR6gCHWIwnOVXz3sw6/c3r/912wHBMWbuSfNZWGxBjgphLYfxr+OP5c/f/A6nJEkSzNYzOHm61P+QT3HAWZ4qu53NQKNALfGeiNQnmrE+2sJ9PDLYvMY61gPaivdKxXpVV8qtVit27dqFyZMnu03Pzc3F1q1bPc5TWVmJyspK1/uysjIAji9YksLbgQFADGrgy9r8VexEiIAM6AU9EuXEWuuLt4qh8zuPxHcfTf62q81mi5uyBESSXCWWJAlQaZm8bRcbzu0H1Zu3R/qRD/Gvf5HkLe+BrD+Yeb1Jaef4f/AHIc0OtMhy/L/22oBnmbl2dogrU6erTl2FjPOahbUMTRxHIijYeB/tWB8LWoopWioLoKHyxEms96b6OW80Y73NZgu7ku9pmU7+4rWn9QczvydKxHpAW/E+1rFe1ZXyEydOwG63Iz093W16eno6SktLPc4za9YsTJ8+vdb0goICmEzx1TlaYWGh0lmIGJZFXXQVFRjy1+uioiLYk+Krab4syzhfd77fZt7hOF93PorWF0W8ZUqgefe0/liUm/zbsmULTPqUsJZhNpsjlBttCDbeM9ark5bKAsR/eRjr/VNjrA9mfoqeWMd6VVfKnTz9UL3tPFOmTMGkSZNc78vKypCVlYXc3FykpqZGNZ+RIkkSCgsLkZOTo4kmICyLCpWXu17269cPYoMGyuUlRIPlwaiwVwBwbJuioiJHWSK0bZJ0SVF7VKR63mtylmVwzmDo9fqg5g2ELMvhjVEuy4AUWJCRbHZs2bIFV111FcTEIJvPqZCzPEMHXgtDmCe3zju75C7QeM9Yry5aKgugofIw1vul1ljvb35/YhnrAW3Fe6Vivaor5eeddx50Ol2tq+THjx+vdTXdyWAwwGAw1JouimLcHVjjMc/esCwqI4qQTSbY7fa4Lo8ejkAmJUrQC3qkGlPjpizOvNfkLIter/daFm/zBqp+WHMDQOOAUkmSBJM+BRnnNYub7eKLszyGpKSwy6OF7yOSgo33jPXqpKWyABooD2O94sKJ9b7mD0SsYj2grXivVKxXde/rer0eV1xxRa3mQ4WFhejRo4dCuSLSgORk2E6fxkfLlwPJyUrnhojqOMZ7oihgrCeKG6q+Uw4AkyZNwi233ILOnTuje/fuWLhwIY4cOYJ77rlH6awRERFRhDDeExFRXaX6SvnIkSNx8uRJPPnkkzh27Bg6dOiAtWvXIjs7W+msERERUYQw3hMRUV2l+ko5AIwbNw7jxo1TOhtE2lFRAd3w4eh6/DjQrx/HXCYiVWC8J4ogxnqiuBEXlXIiijC7HQkff4wMAJI9jN45iYiISJ0Y64nihqo7eiMiIiIiIiLSMlbKiYiIiIiIiBTCSjkRERERERGRQlgpJyIiIiIiIlIIK+VERERERERECtF87+uyLAMAysrKFM5J4CRJgtlsRllZGcQ4H76CZVGp8nLXS6msDGJCfF+f09K2YVnUK5LlccYkZ4yi8DDWK0tLZQE0VB7GetXSUlkAbZVHqViv+Ur5mTNnAABZWVkK54RIpbKzlc4BUZ115swZ1K9fX+lsxD3GeiI/GOuJFBNIrBdkjV+mr6qqwq+//oqUlBQIgqB0dgJSVlaGrKwslJSUIDU1VenshIVlUS8tlYdlUSctlQWIbHlkWcaZM2fQtGlTJMT53Ss1YKxXlpbKAmirPCyLOmmpLIC2yqNUrNf8nfKEhAQ0b95c6WyEJDU1Ne5/2E4si3ppqTwsizppqSxA5MrDO+SRw1ivDloqC6Ct8rAs6qSlsgDaKk+sYz0vzxMREREREREphJVyIiIiIiIiIoWwUq5CBoMBTzzxBAwGg9JZCRvLol5aKg/Lok5aKgugvfKQsrT0e9JSWQBtlYdlUSctlQXQVnmUKovmO3ojIiIiIiIiUiveKSciIiIiIiJSCCvlRERERERERAphpZyIiIiIiIhIIayUExERERERESmElfIYeOmll9CyZUskJSXhiiuuwGeffeY17cqVK5GTk4MmTZogNTUV3bt3x/r1693SLF68GIIg1PqrqKiIdlGCKsvGjRs95vOHH35wS/f+++/j4osvhsFgwMUXX4xVq1ZFuxguwZRn7NixHsvTvn17Vxqlts3mzZsxdOhQNG3aFIIgYPXq1X7n2bRpE6644gokJSXhggsuwCuvvFIrjRLbJtiyqHmfCbYsat5ngi2LmveXWbNmoUuXLkhJSUFaWhqGDRuG/fv3+51PrfsMqQfjvfqOXQBjvRqPW4z16t1ftBLv4y3Ws1IeZcuXL8fEiRMxdepU7N69Gz179sSgQYNw5MgRj+k3b96MnJwcrF27Frt27ULfvn0xdOhQ7N692y1damoqjh075vaXlJSkqrI47d+/3y2frVu3dn32xRdfYOTIkbjlllvw9ddf45ZbbsGNN96I7du3R7UsQPDl+de//uVWjpKSEjRq1Ag33HCDWzoltk15eTkuvfRSvPDCCwGlP3ToEAYPHoyePXti9+7dePTRR3Hffffh/fffd6VRatsEWxY17zPBlsVJjftMsGVR8/6yadMmjB8/Htu2bUNhYSFsNhtyc3NRXl7udR417zOkDoz36jx2Mdar87jFWK/O/QXQTryPu1gvU1T93//9n3zPPfe4TWvXrp08efLkgJdx8cUXy9OnT3e9X7RokVy/fv1IZTFgwZZlw4YNMgD51KlTXpd54403ygMHDnSblpeXJ990001h59efcLfNqlWrZEEQ5MOHD7umKbVtqgMgr1q1ymeahx9+WG7Xrp3btLvvvlvu1q2b672S28YpkLJ4opZ9prpAyqL2fcYplO2i1v1FlmX5+PHjMgB506ZNXtPEyz5DymG8V+exi7Fe/cctxvra1LBdZFlb8V7tsZ53yqPIarVi165dyM3NdZuem5uLrVu3BrSMqqoqnDlzBo0aNXKbfvbsWWRnZ6N58+YYMmRIrSuFkRZOWTp16oTMzEz0798fGzZscPvsiy++qLXMvLy8gL+fUEVi27z++usYMGAAsrOz3abHetuEwtv3vnPnTkiS5DNNtLdNuNSyz4RDjftMuNS8v/z5558AUOs3U52W9xkKH+O9g9qOXYz12j1uqWV/CYfa9pdIUes+o/ZYz0p5FJ04cQJ2ux3p6elu09PT01FaWhrQMp599lmUl5fjxhtvdE1r164dFi9ejA8//BBvv/02kpKScOWVV+LgwYMRzX91oZQlMzMTCxcuxPvvv4+VK1eibdu26N+/PzZv3uxKU1paGtb3E6pwt82xY8fw8ccf44477nCbrsS2CYW3791ms+HEiRM+00R724RLLftMKNS8z4RDzfuLLMuYNGkSrrrqKnTo0MFrOi3vMxQ+xnt1HrsY67V73FLL/hIKte4vkaDWfSYeYn1iWHNTQARBcHsvy3KtaZ68/fbbyM/PxwcffIC0tDTX9G7duqFbt26u91deeSUuv/xy/Pvf/8bzzz8fuYx7EExZ2rZti7Zt27red+/eHSUlJZg3bx569eoV0jIjLdR1L168GA0aNMCwYcPcpiu5bYLlqew1pyu5bUKhxn0mGPGwz4RCzfvLvffei71792LLli1+02pxn6HIYrx3UNuxi7H+HC0ct9S4vwRD7ftLONS6z8RDrOed8ig677zzoNPpal05OX78eK0rLDUtX74ct99+O1asWIEBAwb4TJuQkIAuXbpE9WpTOGWprlu3bm75zMjICHuZoQinPLIs44033sAtt9wCvV7vM20stk0ovH3viYmJaNy4sc800d42oVLbPhMpatlnQqXm/WXChAn48MMPsWHDBjRv3txnWi3uMxQ5jPe1qeHYxVivveOW2vaXSFHD/hIute4z8RLrWSmPIr1ejyuuuAKFhYVu0wsLC9GjRw+v87399tsYO3Ysli1bhquvvtrvemRZxp49e5CZmRl2nr0JtSw17d692y2f3bt3r7XMgoKCoJYZinDKs2nTJvz444+4/fbb/a4nFtsmFN6+986dO0MURZ9por1tQqHGfSZS1LLPhEqN+4ssy7j33nuxcuVKFBUVoWXLln7n0do+Q5HFeF+bGo5djPXaOm6pcX+JFDXsL+FS2z4Td7E+rG7iyK933nlHFkVRfv311+Xvv/9enjhxopycnOzqkXDy5MnyLbfc4kq/bNkyOTExUX7xxRflY8eOuf5Onz7tSpOfny+vW7dO/umnn+Tdu3fLt956q5yYmChv375dVWV57rnn5FWrVskHDhyQv/32W3ny5MkyAPn99993pfn8889lnU4nP/PMM/K+ffvkZ555Rk5MTJS3bdsW1bKEUh6nv//973LXrl09LlOpbXPmzBl59+7d8u7du2UA8vz58+Xdu3fLxcXFHsvy888/yyaTSX7ggQfk77//Xn799ddlURTl9957z5VGqW0TbFnUvM8EWxY17zPBlsVJjfvLP/7xD7l+/fryxo0b3X4zZrPZlSae9hlSB8Z7dR67GOvVedxirFfn/hJKeZzUts/EW6xnpTwGXnzxRTk7O1vW6/Xy5Zdf7tYV/5gxY+TevXu73vfu3VsGUOtvzJgxrjQTJ06Uzz//fFmv18tNmjSRc3Nz5a1bt6quLLNnz5YvvPBCOSkpSW7YsKF81VVXyR999FGtZb777rty27ZtZVEU5Xbt2rkdlKItmPLIsiyfPn1aNhqN8sKFCz0uT6lt4xxew9vvxlNZNm7cKHfq1EnW6/VyixYt5JdffrnWcpXYNsGWRc37TLBlUfM+E8pvTK37i6dyAJAXLVrkShNP+wypB+O9+o5dssxYr8bjFmO9evcXrcT7eIv1wl+ZJiIiIiIiIqIY4zPlRERERERERAphpZyIiIiIiIhIIayUExERERERESmElXIiIiIiIiIihbBSTkRERERERKQQVsqJiIiIiIiIFMJKOREREREREZFCWCknIiIiIiIiUggr5UQUEWPHjsWwYcOUzgYRERFFCWM9UXSwUk6kIWPHjoUgCLX+Bg4cqHTWiIiIKAIY64m0J1HpDBBRZA0cOBCLFi1ym2YwGBTKDREREUUaYz2RtvBOOZHGGAwGZGRkuP01bNgQAJCfn4/zzz8fBoMBTZs2xX333eear7KyEg8//DCysrJgMBjQunVrvP766wAAu92O22+/HS1btoTRaETbtm3xr3/9y2c+1q1bh6uuugoNGjRA48aNMWTIEPz000+uz61WK+69915kZmYiKSkJLVq0wKxZs6LwjRAREWkLYz2RtvBOOVEd8d577+G5557DO++8g/bt26O0tBRff/216/PRo0fjiy++wPPPP49LL70Uhw4dwokTJwAAVVVVaN68OVasWIHzzjsPW7duxV133YXMzEzceOONHtdXXl6OSZMmoWPHjigvL8fjjz+O6667Dnv27EFCQgKef/55fPjhh1ixYgXOP/98lJSUoKSkJCbfBRERkRYx1hPFJ0GWZVnpTBBRZIwdOxZvvvkmkpKS3KY/8sgjSE5Oxquvvopvv/0Woii6fX7gwAG0bdsWhYWFGDBgQEDrGj9+PH777Te89957rnWfPn0aq1ev9pj+999/R1paGr755ht06NAB9913H7777jt88sknEAQh+MISERHVQYz1RNrD5utEGtO3b1/s2bPH7W/8+PG44YYbYLFYcMEFF+DOO+/EqlWrYLPZAAB79uyBTqdD7969vS73lVdeQefOndGkSRPUq1cPr732Go4cOeI1/U8//YRRo0bhggsuQGpqKlq2bAkArnnGjh2LPXv2oG3btrjvvvtQUFAQwW+BiIhIuxjribSFlXIijUlOTkarVq3c/ho1aoSsrCzs378fL774IoxGI8aNG4devXpBkiQYjUafy1yxYgUeeOAB3HbbbSgoKMCePXtw6623wmq1ep1n6NChOHnyJF577TVs374d27dvBwDXPJdffjkOHTqEp556ChaLBTfeeCNGjBgRuS+CiIhIoxjribSFz5QT1SFGoxHXXHMNrrnmGowfPx7t2rXDN998g44dO6KqqgqbNm3y2KTts88+Q48ePTBu3DjXtOodudR08uRJ7Nu3D6+++ip69uwJANiyZUutdKmpqRg5ciRGjhyJESNGYODAgfjjjz/QqFGjCJSWiIio7mGsJ4o/rJQTaUxlZSVKS0vdpiUmJmLNmjWw2+3o2rUrTCYT/vvf/8JoNCI7OxuNGzfGmDFjcNttt7k6fykuLsbx48dx4403olWrVli6dCnWr1+Pli1b4r///S927NjhaqZWU8OGDdG4cWMsXLgQmZmZOHLkCCZPnuyW5rnnnkNmZiYuu+wyJCQk4N1330VGRgYaNGgQra+GiIhIExjribSFzdeJNGbdunXIzMx0+3MOV/Laa6/hyiuvxCWXXIJPP/0U//vf/9C4cWMAwMsvv4wRI0Zg3LhxaNeuHe68806Ul5cDAO655x4MHz4cI0eORNeuXXHy5Em3K+k1JSQk4J133sGuXbvQoUMHPPDAA5g7d65bmnr16mH27Nno3LkzunTpgsOHD2Pt2rVISOBhiYiIyBfGeiJtYe/rRERERERERArhZSoiIiIiIiIihbBSTkRERERERKQQVsqJiIiIiIiIFMJKOREREREREZFCWCknIiIiIiIiUggr5UREREREREQKYaWciIiIiIiISCGslBMREREREREphJVyIiIiIiIiIoWwUk5ERERERESkEFbKiYiIiIiIiBTy/7YNg3N8YNndAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "number_faces = 1\n", "\n", "fig, ax = plt.subplots(1,2, figsize=(12,4))\n", "\n", "ax[0].set_title('Bruto')\n", "ax[0].axvline(x=true_scale, ls = '--', color='red')\n", "ax[0].step(test_scales, raw_detections[:,0], label = 'Default')\n", "ax[0].step(test_scales, raw_detections[:,1], label = 'Óptimo')\n", "ax[0].step(test_scales, raw_detections[:,2], label = 'Adecuado')\n", "ax[0].grid(True)\n", "ax[0].set_xlabel('Escalas')\n", "ax[0].set_ylabel('Detecciones')\n", "ax[0].legend()\n", "\n", "ax[1].set_title('Procesado')\n", "ax[1].axvline(x=true_scale, ls = '--', color='red')\n", "ax[1].axhline(y=number_faces, ls = '--', color='red')\n", "ax[1].step(test_scales, detections[:,0], label = 'Default')\n", "ax[1].step(test_scales, detections[:,1], label = 'Óptimo')\n", "ax[1].step(test_scales, detections[:,2], label = 'Adecuado')\n", "ax[1].grid(True)\n", "ax[1].set_xlabel('Escalas')\n", "ax[1].set_ylabel('Detecciones')\n", "ax[1].legend()\n", "plt.show()" ] } ], "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.8.15" } }, "nbformat": 4, "nbformat_minor": 2 }