diff --git "a/notebooks/04_baseline_v2.ipynb" "b/notebooks/04_baseline_v2.ipynb" new file mode 100644--- /dev/null +++ "b/notebooks/04_baseline_v2.ipynb" @@ -0,0 +1,1040 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 🤖 Notebook 04 — Modelo Baseline\n", + "\n", + "Entrenamos el modelo más simple posible que funcione bien:\n", + "**Logistic Regression** sobre TF-IDF.\n", + "Este es nuestro punto de referencia — cualquier modelo más complejo\n", + "debe superar estas métricas para justificar su complejidad.\n", + "\n", + "**Usamos Logistic Regression como baseline:**\n", + "- Funciona excepcionalmente bien con matrices TF-IDF sparse\n", + "- Coeficientes interpretables: podemos ver exactamente qué palabras usa\n", + "- Rápido de entrenar y difícil de sobreajustar con regularización\n", + "- En NLP, LR bate a modelos más complejos sorprendentemente seguido\n", + "\n", + "### Alerta del notebook anterior\n", + "El análisis de features detectó nombres propios (`stefan`, `peggy`, `hubbard`)\n", + "con alto peso en la clase no-tóxica. Analizaremos si el modelo los aprende\n", + "y tomaremos acción si es necesario.\n", + "\n", + "### Output\n", + "- Métricas baseline: F1, Precision, Recall, ROC-AUC\n", + "- Análisis de coeficientes (qué aprendió el modelo)\n", + "- Análisis de errores (qué falla y por qué)\n", + "- Experimento en MLflow: `04_baseline`\n", + "- Modelo guardado: `models/lr_baseline.joblib`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 0. Imports y configuración" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "kernel\n" + ] + } + ], + "source": [ + "print(\"kernel\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/under/miniconda3/envs/py310/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PROJECT_ROOT: /mnt/c/Users/under/Documents/F5/3_Projects/Project_9_Equipo3/Project_YT\n" + ] + } + ], + "source": [ + "import sys\n", + "import yaml\n", + "import json\n", + "import joblib\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import mlflow\n", + "import mlflow.sklearn\n", + "from pathlib import Path\n", + "from sklearn.feature_extraction.text import TfidfVectorizer\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.model_selection import train_test_split, StratifiedKFold, cross_validate\n", + "from sklearn.metrics import (\n", + " classification_report, confusion_matrix,\n", + " f1_score, precision_score, recall_score,\n", + " roc_auc_score, RocCurveDisplay\n", + ")\n", + "from sklearn.pipeline import Pipeline\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "PROJECT_ROOT = Path.cwd().parent\n", + "sys.path.insert(0, str(PROJECT_ROOT))\n", + "\n", + "plt.rcParams['figure.figsize'] = (12, 5)\n", + "plt.rcParams['axes.spines.top'] = False\n", + "plt.rcParams['axes.spines.right'] = False\n", + "\n", + "print(f'PROJECT_ROOT: {PROJECT_ROOT}')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LR config: {'C': 0.4, 'max_iter': 1000, 'class_weight': 'balanced', 'solver': 'lbfgs'}\n", + "CV folds : 5 | random_state: 42\n" + ] + } + ], + "source": [ + "CONFIG_FEAT = PROJECT_ROOT / 'configs' / 'features.yaml'\n", + "CONFIG_PIPE = PROJECT_ROOT / 'configs' / 'pipeline.yaml'\n", + "CONFIG_MOD = PROJECT_ROOT / 'configs' / 'models.yaml'\n", + "\n", + "with open(CONFIG_FEAT) as f: feat_cfg = yaml.safe_load(f)\n", + "with open(CONFIG_PIPE) as f: pipe_cfg = yaml.safe_load(f)\n", + "with open(CONFIG_MOD) as f: mod_cfg = yaml.safe_load(f)\n", + "\n", + "tfidf_cfg = feat_cfg['vectorization']['tfidf']\n", + "lr_cfg = mod_cfg['models']['logistic_regression']\n", + "TARGET = pipe_cfg['data']['target_binary']\n", + "SUBLABELS = pipe_cfg['data']['target_multilabel']\n", + "RAND = pipe_cfg['pipeline']['random_state']\n", + "TEST_SIZE = pipe_cfg['pipeline']['test_size']\n", + "CV_FOLDS = pipe_cfg['pipeline']['cv_folds']\n", + "\n", + "print('LR config:', lr_cfg)\n", + "print(f'CV folds : {CV_FOLDS} | random_state: {RAND}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Carga de datos y split\n", + "\n", + "Mismo split que en vectorización — `random_state` fijo desde YAML\n", + "garantiza que train/test son idénticos en todos los notebooks." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train: 800 | Test: 200\n", + "Train positivos: 370 (46.2%)\n", + "Test positivos : 92 (46.0%)\n" + ] + } + ], + "source": [ + "PROCESSED = PROJECT_ROOT / 'data' / 'processed' / 'v2' / 'comments_preprocessed.csv'\n", + "\n", + "df = pd.read_csv(PROCESSED)\n", + "df['clean_text'] = df['clean_text'].fillna('').astype(str)\n", + "\n", + "X = df['clean_text']\n", + "y = df[TARGET]\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " X, y, test_size=TEST_SIZE, random_state=RAND, stratify=y\n", + ")\n", + "\n", + "print(f'Train: {len(X_train)} | Test: {len(X_test)}')\n", + "print(f'Train positivos: {y_train.sum()} ({y_train.mean()*100:.1f}%)')\n", + "print(f'Test positivos : {y_test.sum()} ({y_test.mean()*100:.1f}%)')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Pipeline sklearn\n", + "\n", + "Encadenamos TF-IDF + Logistic Regression en un `sklearn.Pipeline`.\n", + "\n", + "### ¿Por qué Pipeline y no pasos separados?\n", + "- En cross-validation, el Pipeline hace `fit` del TF-IDF **dentro** de cada fold\n", + " usando solo los datos de ese fold de entrenamiento\n", + "- Si vectorizáramos fuera del Pipeline, el TF-IDF vería todos los folds → data leakage\n", + "- Además, el Pipeline es directamente serializable con `joblib` y deployable\n", + "\n", + "### Parámetros de Logistic Regression\n", + "- `C=1.0` → regularización L2 por defecto (penaliza coeficientes grandes)\n", + "- `class_weight='balanced'` → compensa si hay desbalance entre clases\n", + "- `max_iter=1000` → suficiente para convergencia con datos sparse\n", + "- `solver='lbfgs'` → eficiente para problemas medianos con L2" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pipeline creado:\n", + "Pipeline(steps=[('tfidf',\n", + " TfidfVectorizer(max_features=5000, min_df=3,\n", + " ngram_range=(1, 2), strip_accents='unicode',\n", + " sublinear_tf=True)),\n", + " ('clf',\n", + " LogisticRegression(C=0.4, class_weight='balanced',\n", + " max_iter=1000, random_state=42))])\n" + ] + } + ], + "source": [ + "pipeline = Pipeline([\n", + " ('tfidf', TfidfVectorizer(\n", + " max_features = tfidf_cfg['max_features'],\n", + " ngram_range = tuple(tfidf_cfg['ngram_range']),\n", + " sublinear_tf = tfidf_cfg['sublinear_tf'],\n", + " min_df = tfidf_cfg['min_df'],\n", + " analyzer = 'word',\n", + " strip_accents= 'unicode',\n", + " )),\n", + " ('clf', LogisticRegression(\n", + " C = lr_cfg['C'],\n", + " max_iter = lr_cfg['max_iter'],\n", + " class_weight = lr_cfg['class_weight'],\n", + " solver = lr_cfg['solver'],\n", + " random_state = RAND,\n", + " ))\n", + "])\n", + "\n", + "print('Pipeline creado:')\n", + "print(pipeline)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Cross-Validation — evaluación real\n", + "\n", + "Con 1000 muestras un solo split train/test no es fiable.\n", + "StratifiedKFold k=5 divide en 5 partes manteniendo la proporción de clases,\n", + "entrena en 4 y valida en 1, rotando las partes.\n", + "\n", + "**Resultado:** 5 métricas → tomamos la media y la desviación estándar.\n", + "La std alta indica que el modelo es inestable con este dataset pequeño.\n", + "\n", + "> La rúbrica exige diferencia train/test < 5 puntos porcentuales.\n", + "> Calculamos ambas para verificarlo." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ejecutando 5-fold cross-validation...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Completado.\n", + "\n", + "Métrica Train Val Gap(pp) Std Val\n", + "----------------------------------------------------------------------\n", + " f1 0.8839 0.7015 18.24 pp 0.0312 ⚠️ Alto gap\n", + " precision 0.8841 0.7033 18.09 pp 0.0317 ⚠️ Alto gap\n", + " recall 0.8841 0.7025 18.16 pp 0.0308 ⚠️ Alto gap\n", + " roc_auc 0.9552 0.7737 18.15 pp 0.0200 ⚠️ Alto gap\n" + ] + } + ], + "source": [ + "cv = StratifiedKFold(n_splits=CV_FOLDS, shuffle=True, random_state=RAND)\n", + "\n", + "# Métricas que queremos en cada fold\n", + "scoring = {\n", + " 'f1' : 'f1_weighted',\n", + " 'precision': 'precision_weighted',\n", + " 'recall' : 'recall_weighted',\n", + " 'roc_auc' : 'roc_auc',\n", + "}\n", + "\n", + "print(f'Ejecutando {CV_FOLDS}-fold cross-validation...')\n", + "cv_results = cross_validate(\n", + " pipeline, X_train, y_train,\n", + " cv=cv,\n", + " scoring=scoring,\n", + " return_train_score=True, # para detectar overfitting\n", + " n_jobs=-1\n", + ")\n", + "\n", + "print('Completado.\\n')\n", + "print(f\"{'Métrica':20} {'Train':>10} {'Val':>10} {'Gap(pp)':>15} {'Std Val':>10}\")\n", + "print('-' * 70)\n", + "\n", + "for metric in ['f1', 'precision', 'recall', 'roc_auc']:\n", + " train_mean = cv_results[f'train_{metric}'].mean()\n", + " val_mean = cv_results[f'test_{metric}'].mean()\n", + " val_std = cv_results[f'test_{metric}'].std()\n", + " gap_pp = abs(train_mean - val_mean) * 100\n", + "\n", + " flag = '⚠️ Alto gap' if gap_pp > 5 else '✅ Estable'\n", + " print(f' {metric:18} {train_mean:>10.4f} {val_mean:>10.4f} {gap_pp:>11.2f} pp {val_std:>10.4f} {flag:>10}')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Guardado en reports/v2/09_cv_metrics.png\n" + ] + } + ], + "source": [ + "# Visualizacion de métricas por fold\n", + "fig, axes = plt.subplots(1, 2, figsize=(13, 5))\n", + "\n", + "metrics = ['f1', 'precision', 'recall', 'roc_auc']\n", + "colors_train = '#7F77DD'\n", + "colors_val = '#5DCAA5'\n", + "\n", + "# F1 por fold\n", + "folds = range(1, CV_FOLDS + 1)\n", + "axes[0].plot(folds, cv_results['train_f1'], 'o-', color=colors_train,\n", + " label='Train F1', linewidth=2, markersize=8)\n", + "axes[0].plot(folds, cv_results['test_f1'], 's-', color=colors_val,\n", + " label='Val F1', linewidth=2, markersize=8)\n", + "axes[0].axhline(cv_results['test_f1'].mean(), color=colors_val,\n", + " linestyle='--', alpha=0.5, label=f'Media val: {cv_results[\"test_f1\"].mean():.3f}')\n", + "axes[0].set_title('F1-weighted por fold', fontweight='bold')\n", + "axes[0].set_xlabel('Fold')\n", + "axes[0].set_ylabel('F1 score')\n", + "axes[0].set_ylim(0.5, 1.0)\n", + "axes[0].legend()\n", + "axes[0].set_xticks(list(folds))\n", + "\n", + "# Comparativa train vs val todas las métricas\n", + "x = np.arange(len(metrics))\n", + "width = 0.35\n", + "train_means = [cv_results[f'train_{m}'].mean() for m in metrics]\n", + "val_means = [cv_results[f'test_{m}'].mean() for m in metrics]\n", + "val_stds = [cv_results[f'test_{m}'].std() for m in metrics]\n", + "\n", + "axes[1].bar(x - width/2, train_means, width, label='Train', color=colors_train, alpha=0.8)\n", + "axes[1].bar(x + width/2, val_means, width, label='Validación', color=colors_val,\n", + " alpha=0.8, yerr=val_stds, capsize=4)\n", + "axes[1].set_title('Train vs Validación (media 5 folds)', fontweight='bold')\n", + "axes[1].set_xticks(x)\n", + "axes[1].set_xticklabels(['F1', 'Precision', 'Recall', 'ROC-AUC'])\n", + "axes[1].set_ylim(0.5, 1.0)\n", + "axes[1].legend()\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig(PROJECT_ROOT / 'reports' / 'v2' / '09_cv_metrics.png', dpi=150, bbox_inches='tight')\n", + "plt.show()\n", + "print('Guardado en reports/v2/09_cv_metrics.png')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Evaluación final en test\n", + "\n", + "Entrenamos el modelo en todo el train y evaluamos **una sola vez** en test.\n", + "Este es el número que reportamos como resultado final del baseline.\n", + "\n", + "> ⚠️ El test set no se toca hasta este momento.\n", + "> Usarlo antes contamina la evaluación final." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=======================================================\n", + "RESULTADOS FINALES — LOGISTIC REGRESSION BASELINE\n", + "=======================================================\n", + "F1-weighted Train : 0.8623\n", + "F1-weighted Test : 0.7531\n", + "Train-Test Gap : 10.91 pp\n", + "\n", + "CV F1 Mean : 0.7015\n", + "CV-Test Gap : 5.17 pp\n", + "Rubrica CV/Test : ⚠️ Alto gap\n", + "\n", + " precision recall f1-score support\n", + "\n", + " No toxico 0.75 0.82 0.78 108\n", + " Toxico 0.77 0.67 0.72 92\n", + "\n", + " accuracy 0.76 200\n", + " macro avg 0.76 0.75 0.75 200\n", + "weighted avg 0.76 0.76 0.75 200\n", + "\n" + ] + } + ], + "source": [ + "# Entrenar en todo el train\n", + "pipeline.fit(X_train, y_train)\n", + "\n", + "# Predecir en test\n", + "y_pred = pipeline.predict(X_test)\n", + "y_pred_proba = pipeline.predict_proba(X_test)[:, 1]\n", + "y_pred_train = pipeline.predict(X_train)\n", + "\n", + "# Métricas train vs test (chequeo de overfitting para rúbrica)\n", + "f1_train = f1_score(y_train, y_pred_train, average='weighted')\n", + "f1_test = f1_score(y_test, y_pred, average='weighted')\n", + "\n", + "\n", + "train_test_gap_pp = abs(f1_train - f1_test) * 100\n", + "\n", + "cv_f1_mean = cv_results['test_f1'].mean()\n", + "cv_test_gap_pp = abs(cv_f1_mean - f1_test) * 100\n", + "\n", + "print('=' * 55)\n", + "print('RESULTADOS FINALES — LOGISTIC REGRESSION BASELINE')\n", + "print('=' * 55)\n", + "\n", + "print(f'F1-weighted Train : {f1_train:.4f}')\n", + "print(f'F1-weighted Test : {f1_test:.4f}')\n", + "print(f'Train-Test Gap : {train_test_gap_pp:.2f} pp')\n", + "\n", + "\n", + "print()\n", + "\n", + "print(f'CV F1 Mean : {cv_f1_mean:.4f}')\n", + "print(f'CV-Test Gap : {cv_test_gap_pp:.2f} pp')\n", + "\n", + "status = '✅ Estable' if cv_test_gap_pp < 5 else '⚠️ Alto gap'\n", + "print(f'Rubrica CV/Test : {status}')\n", + "\n", + "print()\n", + "print(classification_report(y_test, y_pred, target_names=['No toxico', 'Toxico']))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKoAAAHqCAYAAAAkgKbYAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAw2ZJREFUeJzs3XdcVfX/B/DXvXDvZckFZCPLHAwH5KQc5SLLlWauEs3MypGS5UpRM7Es03KlOVNzZ5nmojQ1tdx7K7hAFC+bC9x7fn/w5f64DGXcy7lcXs8e5xH3c88598WVC+e+72dIBEEQQEREREREREREJDKp2AGIiIiIiIiIiIgAFqqIiIiIiIiIiMhEsFBFREREREREREQmgYUqIiIiIiIiIiIyCSxUERERERERERGRSWChioiIiIiIiIiITAILVUREREREREREZBJYqCIiIiIiIiIiIpNgKXYAIiKx3bx5E6tXr4atrS0++ugjyOVysSMRERERERFVS+xRRVTISy+9BIlEAolEgtu3bxv1saZOnap7rJUrVxr1sUzB3LlzERAQAIVCAYlEgpCQEKM91sqVK3XP7dSpU0vcLysrC7169cLs2bPRpEkTFqmIiIiIiIhExEIVGV3BYoxEIkGnTp2K7HPixAm9fSQSCbKyssr1eNu2bcPUqVMxdepUoxeaqoKkpCRMnz4dzZs3h6OjI6ytrVG3bl307t0b27ZtgyAIlZJj/fr1GDNmDK5cuYLs7OxKeczSGDFiBK5evYrt27ejXbt2YscptUGDBhV5zZS0Pa1QV17lfZ1pNBp8//33aNKkCezs7GBlZQUvLy+88MILGDlyJC5fvlzuTPv379dlOn36dLnPQ0REZGrS09Px7bffok2bNqhZsyasrKzg7++PLl26YM2aNSZ1bVURhd83SCQSWFpawtXVFa+88gr++OOPEo89e/Ys3nnnHdSuXRvW1taoUaMGGjVqhPHjxyMhIaHE40zxuS3ueShpGzRokMEfvyLXVGvWrEGrVq1gb28PhUIBDw8PNG3aFO+99x6OHj1a7kynT5/WZdq/f3+5z0NVA4f+UaWLiYlBbGwsfH19dW1Lly412Pm3bduGVatWAcjrHeXn51em47///nskJycDADw8PAyWSwwHDx5Er169kJiYqNd+/fp1XL9+HZs3b8aTJ0/g4OBg9Cy///677uspU6agY8eOsLOzM9rjvfrqqzh48CAAwMfHp9h9EhIS4O3tjd27d6NVq1ZGy2KOyvs6e/fdd4v0Hrx//z7u37+PI0eOoEWLFggICChXpv3792PatGkAAD8/P6P22CMiIqosFy9eRNeuXXHz5k299tu3b+P27dvYsWMHGjRoYLZ/9zQaDRITE7F7927s2bMHv/zyC7p37663z3fffYcxY8ZAq9XqtZ87dw7nzp3D0qVLsW3bNrRu3Vrv/ur+3JakvNdU06ZNK/IBaXx8POLj43HixAn4+PigZcuW5cp0+vRpXSYg7/qTzBcLVVTptFotli1bhunTpwPI+xRj3bp1IqfKy2Fra4uGDRuKHcUgbty4ga5du+qKbvXr10dkZCTq1q2LR48eYc+ePVizZk2l5bl//77u60GDBsHf39+oj+fq6gpXV9en7uPm5oaoqCij5jCWSZMm4d1339Xdnjlzpu5TxsGDB+Odd97R3VdSoa6yXbt2TVekcnZ2xowZM1C3bl0kJCTg8uXL+OWXX8QNSEREZGKSkpLQuXNnxMXFAQA8PT3xySefoGHDhkhNTcWBAwewYsUKgz9udnY2pFIpLC3Fe7vYuXNnTJw4EY8ePcLUqVNx5swZCIKA77//Xq9QtWPHDnz00Ue624MHD0afPn2QlpaGefPm4eDBg0hKSkKPHj1w9uxZeHl5ARDvuS2Nd955Bx06dNDdXr58uS5L/vOSz83NrdLzFSctLQ3R0dEAAGtra3z++ecICQlBUlISrl27hu3bt0MikYickqoMgcjIoqKiBAACAKFGjRoCAKFWrVqCRqMRBEEQli1bpndf/paZmak7R2RkpBAWFia4u7sLcrlcsLW1FUJDQ4XZs2cLOTk5giAIwq1bt/SOL7z99ddfgiAIutu+vr7C2bNnhQ4dOgi2trZC27ZtBUEQhLZt2+r2uXXrVpHvobhtxYoVz3weNmzYIAQFBQkKhUIIDg4WNmzYoHfewuc4c+aM0LdvX8Hd3V2QyWSCp6enMGTIEOHOnTulet779eunO3ft2rWF5OTkIvvcuHFDUKvVutvJycnCxIkThYCAAMHKykqws7MTmjdvLixevFjQarV6xxZ8Hq9evSp07dpVsLW1FRwdHYVhw4bp/v3++uuvEp+3iIgIvX+3/H+DfL6+vrr7Clq8eLHQpEkTwdbWVpDL5YKnp6fQvn174csvv9Tts2LFCt2xUVFResdfu3ZNGDRokFCrVi1BJpMJTk5OQufOnYV9+/bp7Vcwe0REhLBr1y6hadOmgkKhELy9vYV58+aV6t+iMkRERJT4/Wq1WmH58uXCCy+8INSoUUOwsrISGjVqJMydO1f3Osx3+vRpoVu3boKLi4tgaWkpODk5CY0bNxaGDRsmxMbGlvp1Vpz169fr9ouMjCx2n/T09HJlr+jrk4iIyBRNmDBB9/dMqVQKd+/eLbJPQkKC8PjxY0EQhBKvLQtf0+QreP2wc+dOITIyUnB3dxckEonwzTff6O4bNWqU3mMePnxYd1/v3r0FQRCEc+fOCf379xcCAwMFR0dHwdLSUnBxcRFeffVV4cCBA6X6fgvmL5hzy5YtuvZ69erpHdOwYUPdfYMGDdK7LysrS6hfv77u/pEjR5b7uRVTSc9Lvm3btgnt27cXHBwcBLlcLtSrV0+YOnWqkJGRobffrVu3hH79+gkeHh6CpaWloFQqhcDAQGHQoEHCmTNnBEEo/zXV0aNHdfv17Nmz2H0KX+eVNnvB9wSFt8LXvWQeWKgioyv4i3XQoEGCTCYTAAg7duwQBEEQWrRoIQAQ3nvvvRILVQqFosRfToMHDxYEoeyFKqVSKdSsWbNIkcQYhaqNGzcKEomkyHGNGjUq9hw7d+4s8Xt2d3cXbt68+dTHy8rKEqytrXXHrFy58pn/TklJSUJAQECJ32Pfvn319s9vt7e313se87dJkyYJgmD4QtXq1atLPJ+Xl5duv5IKVceOHStSFM3fJBKJsHDhQt2+BbP7+voKUqm0yDF79+595nNbGZ5WqBo4cGCJz1mfPn10+z169EhwcXEpcd+9e/dWqFC1Y8cOvX+rNWvWCA8fPnzq91Xa7BV5fRIREZmq2rVr6/6eTZ069Zn7V6RQVfCxAAiXL18WHBwcBCDvQ+aCH1qOGTNGt9+vv/4qCIIg/PzzzyX+LZZKpcKff/5ZpvwFc27evFnX/tJLL+nar1+/rvc458+fL3LO77//Xne/j49PuZ9bMT2tUDV58uQSn/fWrVvrPpTOyckR6tWrV+K+S5cuFQSh/NdUFy5c0Ht/sHjx4md+wF7a7CxUVT+cTJ0qlZubG7p06QIA+PHHH3Hu3DkcO3YMAPSGMRU2adIk/Pzzz9i1axf279+PrVu3okWLFgDyVne7e/cuPDw8cPDgQXTu3Fl33HfffYeDBw/i4MGDCA0N1TtncnIyLCwssGTJEuzevfupj//OO+/oznPw4EHMmTNHd59SqURYWFiJx2o0GowZM0Y3aXnfvn2xY8cOjBkzBmfPni2yf0ZGBiIiIqBWq2FpaYkvvvgCe/bswaeffgogb5z3hx9+WOLjAXlDrDIzM3W3C4/HL87EiRN1E1k3bNgQW7duxY8//ghHR0cAeZOhb9iwochxKSkpcHFxwZYtW/D555/r2n/44QcAQGhoKA4ePKg3tn3Tpk04ePAgJk2a9Mxchf36668AAEtLSyxevBgxMTFYu3YtPv7442cOJxQEAYMHD0ZqaioA4I033sCOHTswefJkSKVSCIKA0aNH486dO0WOjY2NRdeuXbF9+3b07du3yPdpqjZv3ozVq1cDyBv++fPPP2P79u26+QE2bNig+3c9cuSIbj6zfv36Ye/evdi2bRu+/vprtG3bFhYWFmV+nRXUvHlz1KhRAwBw7949vPXWW3B1dUWdOnUwfPhwXLhwodzZDx48iMGDB+uOnThxoi7Tq6++Wv4nkIiISCRpaWl6cyeV5nquIm7evIlRo0Zh165d+OGHH+Ds7Iw33ngDAHD37l29ibC3bNkCAKhZs6bumqB+/fr45ptvsG3bNvz555+IiYnBokWLoFAooNVqdcPCSuvhw4c4dOgQtm3bpneNOWzYMN3XFy9e1H0tl8sRFBRU5DwFr0Hj4uKQlpZW6c+tsfz333+658bDwwPLli3Drl278NprrwHIuz769ttvAQCXL1/G1atXAQAdOnTArl278Pvvv+P7779H586doVAodMeU55qqbt26uukmUlJS8P7778Pb2xve3t4YPHgwjhw5Uu7smzdv1hvuOHjwYF2mgtNdkPngHFVU6d5991388ssv+P333yGTyQAAjRo1QrNmzUo8pl27dpg9ezaOHTuGR48eITc3V3efIAg4efIkunXrhlatWunNS9SwYcOnTpK9Zs0adOzY8ZmZfXx8dL94Y2NjdX+0LS0tsWnTJtSvX7/EY0+cOIF79+4ByBv7/tNPP8HS0hKvvvoq/v33Xxw+fFhv/z179uiKBR07dkSbNm0AAF27dsXGjRtx+/Zt7N69G48ePYKzs3Oxj5k/L1U+T0/Pp35/Wq1Wrwi1bt06NGjQAACQmZmJkSNHAgB+/vln9OnTp8jxP//8M0JCQtCzZ0+sXbsWly9fxqNHj5CcnAylUolWrVpBqVTq9m/atKlu8u2yrsyY/zMjl8tRp04dNG3aFPb29ujfv/8zjz19+rTugsbd3R3r1q2DTCbDq6++iosXL2LLli3Izs7Gli1bMHr0aL1jXV1dsWHDBigUCjRr1gzr168HkDcx/dMkJyfj3LlzZfoe87m5uaFu3brlOjZfwXnIhg8fjlq1agEAhgwZorvgXLNmDfr06aN7bgHA29sb9evXR61atSCRSPDxxx/r7ivr6yyfs7Mzli9fjsGDByMtLU3XfuPGDSxcuBBLlizBhg0b0LNnzzJnb9WqFfbt26fbv27dupwgn4iIqrSyXs9VVP/+/TFv3jy9tgEDBuDHH38EkFcsCAsLw7///qub16l379561/N///03vvjiC1y+fBlpaWl6q0sfP368THn++OMPvVX+XF1dMXv2bL0PDFNSUnRf16xZs9g5kFxcXPRuF35egfI/t2q1Gv/991+5jlUqlRWeG3ft2rW6rwcPHox69eoBAN5//33s2LEDQN610rhx4/Su8zw8PFC3bl34+flBKpVixIgRuvvKe00lk8nw008/oXfv3nj48KGu/e7du1i5ciVWrlyJefPmYdSoUWXO3rRpU5w/f163v4+PD6/zzBwLVVTpXnnlFXh7e+POnTvYuHEjAGDo0KEl7v/vv//i5ZdfRk5OTon7qFSqMuewsrIqVZGqoOTkZLz22mu6JW7nz5//zHMU/LQmJCREb1LK5s2bFylU5X/SART9A51PEARcvny5xF/QBYtCQN5E5rVr1y4xY2JiIp48eQIAsLGx0RWp8jMWly2fvb293idVNWvW1H2tUqmKZKmowYMHY8OGDcjIyNBNMlmrVi20bdsWo0ePRtOmTUs8tmD+559/Xu8PdvPmzXWfDhb3fbZs2VL3SVPh7/FpTp06hZdffvnZ31gxIiIiiqyQV1YFv5f8C4PCLl26BCDv08S6devi2rVr+Oqrr/DVV1+hRo0aeP755zFgwAAMGTIEUmnFOuK+8cYbaNWqFTZu3IidO3fin3/+0fVwy83NxciRI3WFqrJkJyIiMjfFXc+Vd2Xc0ujatWuRtrZt2+qu27ds2YJvvvkGmzdv1t3/1ltv6b6OjIzEd999V+L5y3O9XlBiYmKR3tf29va6rx8/fgxBEIoUqwqvfl3ctWl5n9sHDx6UuzdW27ZtsX///nIdm6/gtdLMmTMxc+bMIvvkj5ioW7cuWrdujYMHD+Knn37CTz/9BGtrazRu3Bg9e/bEqFGjdNe65dWmTRtcuXIFW7Zswfbt23Ho0CE8fvxYd//48eMxcOBAODg4lCk7VT8c+keVTiqV6nUntbKy0vsjV9jixYt1RaouXbpg586dOHjwIAYOHKjbp/BStKXxrBXhCsvJyUGvXr10fyAjIyP1uh6XR0VWvkhPTy/xvrp168La2lp3u3AxrCyZnpUxf2hgvoKFuIKfopXm8TQajd59jx49KrJ/p06dcPjwYQwdOhShoaGwsbHB3bt3sXbtWrRt27bI8sKlVZbvs6zfo6nL/1mysbHB4cOHMX36dLRr1w7u7u66VW/ee+89fPXVVwZ5PHd3d93QgsePH2PlypW65//+/fuIj48vc3YiIiJzY2dnp/dBY2mu50q6rirumqqw4laPk0gkul7rsbGx+O+//3Qf7Pn7++OFF14AkLdK4JIlSwDkXSfNmjULf/31Fw4ePKgbAVDWa6aIiAjk5ORg165dsLGxgSAI+Oqrr7B9+3bdPgWH+mVnZ+sNBcx35swZ3dfe3t6ws7Mr13NbVeXm5kKtVkMqlWLnzp345ptv8Morr8DHxweZmZk4evQoPv30U72VEyvCwcEBQ4YMwbZt2/Dw4UPs2LFD974kMzOzTMWn/OxU/bBQRaJ45513dD0zevXqBQcHhxL3zR82BwDR0dHo3LkzWrVqpevVVFjBHh9PK2CVtUg0bNgwxMTEAAC6d++O2bNnl+q4gn8ET58+rXfRkD8/V0H53V6BvD/QQt6iB3pbeno6wsPDS3xMhUKBHj166G5PmzZN12uloJs3byI7OxsuLi66f4P09HS9T6sKZiyYzVAKfqpVsEBx6NChYosQgiAgLCwMS5YswcmTJ5GamopvvvkGQN78Xrt27SrxsQrmP3XqlN4QUmN9ny+99FKx/4al2SramwrQ/17++uuvYh/nxo0bAPKeWxcXF0yePBkxMTF48OABbt68CTs7OwDA1q1bdecq7eusoNu3bxe5gJTJZIiIiND7HZD/GilL9vJmIiIiMmUFp1yYM2cO7t+/X2Sfhw8fIikpCUDJ11VPuz7KV9K18YABA3RfT5o0SfehYP/+/XXHPH78GFlZWQCAxo0bY9y4cXjppZdQu3ZtXbbysLS0RHh4uG6uVgCYPHmy7uvnnntObyRAwXlkgbzi1fz583W3C14fl/W5LY6fn1+5r/Mq2psK0L9WWrFiRYnvGxQKBQRBgJ2dHSIjI/HHH38gNjYWDx8+1M3xWtHrvKSkJL15zPLP8+qrr+r1VivuOu9Z2cubiaouDv0jUfj6+mLBggWIj4/Xzff0tH3zRUdHIyIiAn/88Qd2795d7P4Fe76sWbMGFhYWsLCwqNA45i+//BIrVqwAkDfO/YMPPsA///yju79evXol9tBq0qQJvLy8cO/ePdy/fx8DBw7EW2+9hZiYmGI/venYsSNcXFyQmJiI1atXw8nJCR07doRGo8Ht27dx+PBhnDlzpthPjAr6/PPPsXPnTiQnJ+PGjRto3rw5IiMjUadOHTx+/Bi7d+/GmjVr8ODBAzg4OKBv375YvHgxgLwLkqioKDx58gRRUVG6c/br16/Mz92zODg4oGbNmnj8+DGuX7+O999/H/Xr18fXX39d7P6jRo3CgwcP0LFjR3h7e8PS0hIHDx7U3f+0T11CQkIQGBiIS5cu4cGDBxgwYAAGDRqEY8eO4ZdffgGQN/dVr169DPtNimjAgAG6CejffvttTJo0CXXr1kViYiKuXbuGHTt2oHPnzoiKisI///yDUaNGoVevXqhbty6cnZ1x9uxZZGRkANB/bsvzOrt+/To6deqE9u3bo0uXLggMDIQgCNiyZYtu6Kmnpye8vLzKnL1wpi1btsDf3x8ymQzNmjWrcFd2IiIiMYwdOxZr165FXFwcVCoVWrRogbFjx6Jhw4ZITU3F/v37sWLFCuzfvx9OTk6oU6eO7tg5c+bAzs4O169fx/Lly8udoWHDhmjUqBHOnj2LvXv36toLjohwc3ODlZUVsrKycO7cOSxZsgRubm74/PPPDVJUGDlyJL766itkZGTgzJkz2LNnDzp16gQgb9hYt27dAADLly+HRCJB7969kZ6eju+++07Xg8fR0VGv4FXW59YUFZxXbMyYMUhKSkKjRo2gUqlw48YN7NmzB76+vli+fDnu3buHDh064M0330RQUBDc3Nxw69Yt3dDIkq7zSntNlZSUhLCwMLRs2RKvv/46GjZsCJlMhj///BOnT58GkPdheqNGjcqcvXCmXbt2oU2bNrCyskLDhg0NPtUImYCKLRpI9GwFl1MdN27cU/dFgaVGMzMzBUEQhGPHjgkSiUTvPolEIoSFhRW7VOr27duLXbq08GP4+voWm6Ft27a6fW7dulWkrbjtaUu1CkLJy/XWqVOn2HPs2LFDUCgUJT5eSdkL+/vvvwUXF5enZn/y5IkgCILw+PFjISAgoMT9+vbtq7cscUlZinv+ntYuCIIwYcKEIo/n4eGhWxK54L/fkCFDSsxobW0t3LhxQxAEQVixYkWxy9YeO3ZMqFGjRrHHSyQSYeHChbp9S1rK+Wnfv1gKLi9deJnegQMHPvVnIH//gwcPPnW/6Oho3Tmf9Torzt69e596/uJeS6XNLgiCcPbs2SK/K4r7eSMiIqpKLly4INSuXfupfw9PnTolCIIgZGdnCz4+PkXuDwwMLPaapuD1w19//VVihi+//FLvfM8//3yRfYYPH17kcevWrSu4urqW6jpBEPTfNxS+9ip4/g4dOujd98033whSqbTE58fBwaHY768sz62Ynva8TJ48+an58/e/c+fOU/cbNmyY7pzluaa6du3aM6/zpk6dWq7sgiAIiYmJxb4/etrPLVVdHPpHJq958+b45Zdf0LBhQ1hZWSE4OBibNm3SfYpSWJcuXfD111/jueee05tLSEx9+/bFzz//jMDAQMjlctSvXx/Lly/X60pd0Kuvvorjx4/j7bffRq1atSCTyeDs7IyQkBBERkZi06ZNpXrc1q1b49KlS5g2bRqaNm0KpVIJhUIBf39/9OjRA1u2bNF9AuHk5ISjR49iwoQJqF+/PhQKBWxtbdGsWTMsWrQI69atq9CcWk8zZcoUvPfee3BwcICtrS26d++Ow4cPF/vpyIABAxAREYH69etDqVTCwsICrq6u6NGjBw4ePPjUSeOBvJ+nEydOICIiAl5eXrC0tISjoyNeeeUV7NmzBx988IFRvkcxrVq1CqtXr0bbtm2hVCohl8vh4+OD9u3b47vvvsOHH34IIK9n4Lhx49CyZUu4ubnB0tISdnZ2aNasGRYsWIBx48bpzlme11nLli2xdu1aDBw4EA0aNEDNmjVhaWkJZ2dnvPLKK/jjjz8waNCgcmUH8j7xXb16NQIDA9mDioiIzEZQUBDOnj2LOXPmoFWrVnBycoJcLoe3tzfCw8OxatUq3VxNMpkM27ZtQ1hYGORyOWrVqoVp06Y9dZLz0ujfv7/e0Kvi5pf9+uuvMXr0aHh4eMDOzg7dunVDTEyM3rypFTF69Ghdhn379uHUqVO6+yIjI3HixAkMGjQIfn5+uuvYBg0a4NNPP8XFixfx0ksvFTlnWZ5bUzV9+nT8/vvveOWVV1CzZk3IZDJ4eXmhVatWmDVrFqZNmwYg71o/KioKbdu2hYeHB2QyGaytrdGoUSPMmDED33//ve6c5bmm8vX1xdatWzFs2DCEhITA1dUVlpaWcHBwwEsvvYS1a9fqjdQoS3Ygb/Xobdu2ITQ01GA/U2S6JIJgBjMBExERERERERFRlcceVUREREREREREZBJYqCIiIiIiIiIiIpPAQhUREREREREREZkEFqqIiIiIiIiIiMgksFBFREREREREREQmgYUqIiIiIiIiIiIyCSxUERERERFVY4IgICUlBYIgiB2FiIgIlmIHICIiIjIm69ARBj9n5qn5Bj8nEQD8/fffmD17Nk6cOIEHDx7gl19+QY8ePZ56zP79+xEZGYkLFy7A29sbn332GQYNGlTqx0xNTYVSqURycjLs7e0r9g0QERFVkNkWqoxxUUpElS/z1Hxk5YqdgogMwcpsrzqIDCc9PR2NGzfGO++8g549ez5z/1u3buG1117D+++/j7Vr1yImJgbvvvsuPDw8EB4eXgmJiYiIDIuXjERERGTeJJzpgKqOzp07o3PnzqXef/HixfD398c333wDAAgMDMShQ4fw7bffslBFRERVEgtVREREZN4kErETEBnNkSNH0KFDB7228PBwjB49usRj1Go11Gq17nZKSoqx4hER0VPk5Gjx+y+PkKyq2kNIGoXa4flmhhs6zkIVEREREVEVFR8fDzc3N702Nzc3pKSkIDMzE9bW1kWOiY6OxrRp0yorIhERlSD2VhbOnEwTO0b5SNIAZAGCM7x9rQx6ahaqiIiIyLxx6B+RngkTJiAyMlJ3OyUlBd7e3iImIiKqnrTavP87OFmiQ7iTuGHKID09GXfu3oRWq0WtWm54ro6dQc/PQhURERERURXl7u6OhIQEvbaEhATY29sX25sKABQKBRQKRWXEIyKiUrC2lqJBY8MWe4xFpVLh7NkbcHa1hJOTExo08IZUatgPBVmoIiIiIvPGOarIjIWFhWHnzp16bXv37kVYWJhIiYiIqgatVsCl8+lITdGIliHxYbZoj10eeUWqs9Bqtf8rUjUweJEKYKGKiIiIzB2H/lEVkpaWhuvXr+tu37p1C6dPn4aTkxN8fHwwYcIE3Lt3D6tXrwYAvP/++5g/fz4+/fRTvPPOO/jzzz+xceNG7NixQ6xvgYioSoi9lYVN6x6KHQMAYGlp+h+qVVaRCmChioiIiIjIZBw/fhwvv/yy7nb+XFIRERFYuXIlHjx4gLi4ON39/v7+2LFjB8aMGYN58+ahVq1a+PHHHxEeHl7p2YmIqpKMjLyeVDa2UtSuU/xQ6coglUrwfLMaoj1+aWRlZVVakQpgoYqIiIjMHYf+URXy0ksvQRCEEu9fuXJlscecOnXKiKmIiMyXs4scb/Rze/aO1ZiVlRV8fX2RnJxs9CIVwEIVERERmTsO/SMiIhKdRiMgJTlX7Bg66WnizU1VVQiCAMn/PvDz9fXVu21MLFQRERERERERkdFotQIWf3cXiQk5YkehUlKpVIiLi0NQUBAsLfNKR5VRpAJYqCIiIiJzx6F/REREotJoBF2RylImgan8ZZZKgeCGtmLHMDkFJ06Pi4tD7dq1K/XxWagiIiIiIiIiokrxyWe+UCg4LN9UFV7dz8/Pr9IzsFBFRERE5o1zVBERERE9U+EiVWVMnF4cFqqIiIjIvHHoHxERkUFcvpiOAzFPoC3jPORPW82UTIOpFKkAFqqIiIiIiIiIqBSOH0vBg3vZ5T7e1s4Clpb8AMnUaLVaXL582SSKVAALVURERGTuOPSPiIjIIPI7Rr3YVonadazLfLybuxwWFixUmRqpVIoGDRogLi4OAQEBohapABaqiIiIyNxx6B8REZFBubrJ8VxdG7FjUAVpNBpYWFgAAOzs7BAUFCRyojwsVBERERERERFRETk5Wpz8LxXpaXmTUiU9yhE5ERmKSqXChQsXEBwcDAcHB7Hj6GGhioiIiMwbh/4RERGVy5VLGfjjt8dF2mVy/m2tygpOnH7v3j0WqoiIiIgqFQtVRERE5aLO0gIAHBwtUTcgb6ifnZ0F6tYv+/xUZBoKr+4XGBgodqQiWKgiIiIiIiIiohK5ucvxWndnsWNQBRUuUom9ul9JWKgiIiIi8yblZOpEREQl0WoFPEzIhlZb9L5kVW7lByKjqCpFKoCFKiIiIiIiIqJqa9f2x/j3SMrTd+JnPlXe/fv3q0SRCmChioiIiMwd56giIiIq0aPEvJX8rKylkMuLVqQsLCRoFGpX2bHIwAICAmBrawtvb2+TLlIBLFQRERGRuZPwY2AiIqJnebW7MxqFsCBlTjIyMmBtbQ2JRAKpVApfX1+xI5WKaZfRiIiIiIiIiIioTFQqFY4fP47r169DEASx45QJe1QRERGReePQPyIiqsYEQcDWDYmIvZVZ7P3paZpKTkTGVnDi9MzMTAiCAEkV6mHOQhURERGZtyp0YUZERGRomZlanDud9vSdJEBNZ1nlBCKjqkqr+5WEhSoiIiIiIiIic1Vg1NfQEV7Ffn5ja2cBpZLlgarOHIpUAAtVREREZO449I+IiAgA4OEph1TKnsbmyFyKVAALVURERERERETllpmpwZGDycjM1IodpVi5OVVrIm0qn+zsbLMoUgEsVBEREZG54xxVRERkROfPpOPvP1Vix3gmuULCP4lmzNXVFTKZDEqlskoXqQAWqoiIiMjccegfEREZUXZ2Xk8qN3c5AoJtRE5TMr/a1lVq5Td6tuTkZFhZWUGhUAAAHB0dRU5kGCxUEREREREREVWQu6ccL3d0EjsGVRP5c1IpFAqEhIToilXmgIUqIiIiMm/89JiIiEoh6XEOniTllPm4x4/KfgxRRRScON3a2hoymUzsSAbFQhURERGZNw79IyKip9BoBOzf9wSH9qsgVGDecX4uQpXBnFb3KwkLVURERERERFQtPUrMxtYNibh/Vw0AcHGVQWpR9oqTTCZBSJMaho5HpKc6FKkAFqqIiIjI3PEjbiIiKkQQBJz4NxW7f3+MnBwBVtZSdO3pjOCGdmJHIypWcnJytShSASxUERERkbnj0D8iIiogLU2D37Yk4uqlDABA7TrW6NHbBfZKvj0m05W/up+1tbVZF6kAFqqIiIiIiIiomrh6OQO/bk5EepoGFhZAh1ec0OJFJaRS9r4l06ZQKBAaGgpLS0uzLlIBLFQRERGRuWOPKiKiai87W4s9O5Nw/GgKAMDVXY5efV3h5i4XORlRyVQqFdRqNdzc3AAAcnn1+HlloYqIiIiIiIjM1v27amzZ8BCPE3MAAC1bKdE+3BEyGT/IINNVcOJ0mUwGJycnsSNVGhaqiIiIyLxxMnUiompJqxVw+IAKf+19Aq0WqGFvgR69XfBcXRuxoxE9VeHV/RwcHMSOVKlYqCIiIiLzxqF/RETVzpOkHPyyMRFxt7MAAEENbdHldWfY2FiInIzo6QoXqcx94vTisFBFREREREREZkEQBJw9nYad2x5BrRYgl0vwandnNH7eDhL2sCUTxyJVnur3HRMREVH1IpEYfisljUaDyZMnw9/fH9bW1njuuefw+eefQxAE3T6CIGDKlCnw8PCAtbU1OnTogGvXrhnjmSAiMmuZGRps/vkhftmQCLVagLevAu9/VAshTWqwSEUmLyMjg0Wq/2GPKiIiIjJvIg79+/LLL7Fo0SKsWrUKwcHBOH78OAYPHgylUolRo0YBAL766it89913WLVqFfz9/TF58mSEh4fj4sWLsLKyEi07EVFVcutGJn7Z+BApyRpIpMBL7R3R6iUHWFiwQEVVg7W1NTw9PZGRkVGti1QAC1VERERERvPPP/+ge/fueO211wAAfn5++Pnnn/Hvv/8CyOtNNXfuXHz22Wfo3r07AGD16tVwc3PDtm3b0LdvX9GyExGZqvj7ajz63wp+AHA3LgtH/0kBBMDJWYaefVxQy5uFfqpaJBIJnnvuOQiCUK2LVAALVURERGTujDDcQ61WQ61W67UpFAooFAq9thdeeAFLlizB1atXUa9ePZw5cwaHDh3CnDlzAAC3bt1CfHw8OnTooDtGqVSiRYsWOHLkCAtVRESFpKdp8MP8exC0Re9r0rwGwrvUhFxevd/kU9WhUqlw7949BAYGQiqVQiKRcJgqWKgiIiIiM2eMC77o6GhMmzZNry0qKgpTp07Vaxs/fjxSUlIQEBAACwsLaDQafPHFFxgwYAAAID4+HgDg5uamd5ybm5vuPiIi+n/p6RoIWkAqBXz88npNWcokaNbCHvWDbEVOR1R6BSdOt7W1hZ+fn9iRTAYLVURERERlNGHCBERGRuq1Fe5NBQAbN27E2rVrsW7dOgQHB+P06dMYPXo0PD09ERERUVlxiYjMjpW1FIPe8xQ7BlG5FF7dz8fHR+xIJoWFKiIiIjJrxuhRVdwwv+J88sknGD9+vG4IX8OGDREbG4vo6GhERETA3d0dAJCQkAAPDw/dcQkJCQgJCTF4biIiY8vNFfRWNjU0Ta7xzk1UGQoXqar7xOnFYaGKiIiIyEgyMjKKXHxaWFhAq82bXMXf3x/u7u6IiYnRFaZSUlJw7NgxfPDBB5Udl4ioQnb8+gj/HUkROwaRyWKRqnRYqCIiIiLzJuKcpF27dsUXX3wBHx8fBAcH49SpU5gzZw7eeeedvGgSCUaPHo0ZM2agbt268Pf3x+TJk+Hp6YkePXqIF5yIqByuX82otMeqXce60h6LyBA0Gg0uXrzIIlUpsFBFREREZk3M1XO+//57TJ48GR9++CEePnwIT09PDBs2DFOmTNHt8+mnnyI9PR3vvfceVCoVWrVqhV27dsHKikurE1HV9PYQd9TyMe7vMIWCb/CparGwsEBwcDDu3r2rW+WPiicRjDmAWETWoSPEjkBEBpB5aj6ycsVOQUSGYCXSx2N2b640+DnTNg4y+DmJxJKSkgKlUonk5GTY29uLHYeqsHmz4/DkcS6GfOAJb18W24kAQKvVsihVRny2iIiIyKxJJBKDb0RERETPolKpcOzYMaSmpoodpUphoYqIiIjMGgtVREREVNnyJ05Xq9W4c+eO2HGqFBaqiIiIiIiIiIgMpPDqfgEBAWJHqlI4mToRERGZNfaAIiIiospSuEjF1f3KjoUqIiIiIiIiKrPsbC0unU+HWq0FAKiztCInIhIXi1SGwUIVERERmTd2qCIiMor/jqZg786kIu0WlvzFS9XTnTt3WKQyABaqiIiIyKxx6B8RkXFkpGsAAE41LeHmoQAA1HSWwd1DLmYsItEEBQUhLi4Ovr6+LFJVAAtVREREREREVG71A20R3qWm2DGIRJGVlQWFQgGJRAILCwv4+/uLHanKY6GKiIiIzBp7VBERGU5OjhaZGXlzUWWrBZHTEIkrf04qb29v+Pn58ZrDQFioIiIiIrPGi0YiIsPIzNDg+2/uICOdk6YTFZw4PTU1Vew4ZoWFKiIiIiIiInqmpKRcXZEqf/oduVyK5+pZi5iKqPIVt7ofPxgzHJMpVCUmJuLKlSsAgPr168PFxUXkRERERGQOeOFIRGRY9koLRE7wFTsGkSiKK1Jx4nTDEv3ZTE9PxzvvvANPT0+0adMGbdq0gaenJ4YMGYKMjAyx4xEREVFVJzHCRkRERNUOi1SVQ/RnNDIyEgcOHMBvv/0GlUoFlUqFX3/9FQcOHMDHH38sdjwiIiIiIiIiImRkZLBIVQlEH/q3ZcsWbN68GS+99JKu7dVXX4W1tTXefPNNLFq0SLxwREREVOVx6B8REREZgqenJ+RyOZycnFikMiLRn9mMjAy4ubkVaXd1deXQPyIiIiIiIiISTXJyMnJycnS3nZ2dWaQyMtGf3bCwMERFRSErK0vXlpmZiWnTpiEsLEzEZERERGQOJBKJwTciIiIyfyqVCmfOnMGZM2f0ilVkXKIP/Zs3bx7Cw8NRq1YtNG7cGABw5swZWFlZYffu3SKnIyIioqqOhSUioqc7fzYNjxOf/SY8NSW3EtIQmYaCE6fL5XJYWFiIHanaEL1Q1aBBA1y7dg1r167F5cuXAQD9+vXDgAEDYG1tLXI6IiIiIiIi8/UoMRub1z0s0zEyuegDc4iMiqv7iUv0QhUA2NjYYOjQoWLHICIiInPEDlVERCXKytQCAORyCRqG2D37AAkQ3LAU+xFVUSxSiU/0QlV0dDTc3Nzwzjvv6LUvX74ciYmJGDdunEjJiIiIyBxw6B9VNQsWLMDs2bMRHx+Pxo0b4/vvv0fz5s1L3H/u3LlYtGgR4uLi4OzsjDfeeAPR0dGwsrKqxNRU1dnYWaBrTxexYxCJikUq0yD6M/7DDz8gICCgSHtwcDAWL14sQiIiIiIiorKJi4vDwYMHsXv3bpw8eRJqtbpc59mwYQMiIyMRFRWFkydPonHjxggPD8fDh8UPzVq3bh3Gjx+PqKgoXLp0CcuWLcOGDRswceLEinw7RETVkkKhgEwmY5FKZKL3qIqPj4eHh0eRdhcXFzx48ECERERERGRO2KOKjOX27dtYtGgR1q9fj7t370IQBN19crkcrVu3xnvvvYdevXqV+s3OnDlzMHToUAwePBgAsHjxYuzYsQPLly/H+PHji+z/zz//4MUXX0T//v0BAH5+fujXrx+OHTtmgO+QiKh6sba2RmhoKORyOYtUIhL9mff29sbhw4eLtB8+fBienp4iJCIiIiJzIpFIDL4RjRo1Co0bN8atW7cwY8YMXLx4EcnJycjOzkZ8fDx27tyJVq1aYcqUKWjUqBH++++/Z54zOzsbJ06cQIcOHXRtUqkUHTp0wJEjR4o95oUXXsCJEyfw77//AgBu3ryJnTt34tVXXzXMN0pEZOZUKhUeP36su21lZcUilchE71E1dOhQjB49Gjk5OWjXrh0AICYmBp9++ik+/vhjkdMRERERERVla2uLmzdvombNmkXuc3V1Rbt27dCuXTtERUVh165duHPnDpo1a/bUcz569AgajQZubm567W5ubrrVsQvr378/Hj16hFatWkEQBOTm5uL9999/6tA/tVqtNzQxJSXlqbmIiMxV/pxUgiAgJCQESqVS7EgEEyhUffLJJ3j8+DE+/PBDZGdnA8irYI4bNw4TJkwQOR0RERFVdewBRcYQHR1d6n1feeUVo+XYv38/Zs6ciYULF6JFixa4fv06PvroI3z++eeYPHlyscdER0dj2rRpRstERFQVFJ44vUaNGmJHov8RvVAlkUjw5ZdfYvLkybh06RKsra1Rt25dKBQKsaMREREREVUaZ2dnWFhYICEhQa89ISEB7u7uxR4zefJkvP3223j33XcBAA0bNkR6ejree+89TJo0qdjhKxMmTEBkZKTudkpKCry9vQ34nRARmTau7mfaTOZfws7ODs2aNUODBg1YpCIiIiLDkRhhIyqFS5cuoXbt2qXeXy6Xo0mTJoiJidG1abVaxMTEICwsrNhjMjIyiry5srCwAAC9yd0LUigUsLe319uIiKoLFqlMnyg9qnr27ImVK1fC3t4ePXv2fOq+W7duraRUREREZI449I/Ekp2djdjY2DIdExkZiYiICDRt2hTNmzfH3LlzkZ6erlsFcODAgfDy8tINPezatSvmzJmD0NBQ3dC/yZMno2vXrrqCFRER5UlPT2eRqgoQpVClVCp1F42crIyIiIiIqqKCw+eKk5iYWOZz9unTB4mJiZgyZQri4+MREhKCXbt26SZYj4uL03tT9dlnn0EikeCzzz7DvXv34OLigq5du+KLL74o82MTEZk7GxsbuLq6Ijs7m0UqEyYRSuoTXMVZh44QOwIRGUDmqfnIyhU7BREZgpVIM2PW+nCbwc95d2EPg5+Tqh4LCwuEhISUOHQuLS0NJ0+ehEajqeRkZZOSkgKlUonk5GQOA6yG7sZl4ceF9+HgZInRn/qIHYfI6ARBgCAILFKZMNEnU798+TICAgKKvW/37t0IDw+v5ERERERkTjj0j4ylTp06GDNmDN56661i7z99+jSaNGlSyamIiKgglUqFhIQE1KtXDxKJRLeR6RK9hPj8889jwYIFem1qtRojRoxA9+7dRUpFRERERPR0TZs2xYkTJ0q8XyKRlDihORERGV/+xOkPHjzA3bt3xY5DpSR6j6qVK1figw8+wI4dO7BixQo8ePAA/fv3h1arxcGDB8WOR0RERFUdPzQlI/nmm2+gVqtLvL9x48bQarWVmIiIiPIVXt3Py8tL7EhUSqL3qHrzzTdx5swZ5OTkIDg4GGFhYWjbti1OnjyJZs2aiR2PiIiIiKhY7u7u8PX1FTsGEREVUrhIxYnTqxbRe1Tly87OhkajgUajgYeHB6ysrMSORERERGaA81AQERFVHyxSVX2i/2utX78eDRs2hFKpxNWrV7Fjxw4sWbIErVu3xs2bN8WORyKSSiWY8uFruPT7VCQdmYMLv0Vh/NBX9PZxdaqBJdPews09X+DxP3Pw6/wP8ZyPi0iJiehpThz/DyM/fB8dXmqFxsH18WfMPr37Hz96hMkTx6PDS63QokljfPDeEMTG3hYnLJmVghOnGmojIiIi05Obm4vz58+zSFXFif4vNmTIEMycORO//fYbXFxc0LFjR5w9exZeXl4ICQkROx6J6ONBHTH0jdYYM2sTQnrOwGff/YrIiA74sF9b3T4bv30P/rWc0Xv0D2jZbxbiHiRh5+KRsLGSi5iciIqTmZmB+vXrY8JnUUXuEwQBo0cNx927dzD3+4XYsPkXeHh6YdiQwcjIyBAhLRERERFVNZaWlggKCoKzszOLVFWY6EP/Tp48ifr16+u1OTk5YePGjfjpp59ESkWmoGXj2vj9wFnsOnQBABD3IAlvvtIUTYPz5oKo4+OKFo388XyvGbh0Mx4AMGrmBtzeNxNvdm6Clb8cES07ERXVqnVbtGrdttj7YmNv4+yZ09jy6++oU6cuAOCzKVPRru2L2LVzB3q+0bsyo5KZYQ8oIiIi8yYIgu7vvZOTE5ycnERORBUheqEqv0h14sQJXLp0CQAQFBSE559/Hm+//baY0UhkR8/cxJBeL6KOjyuuxz1Ew3peCAupjfHfbAUAKOR5P75Z2bm6YwRBQHZ2Ll4IeY6FKqIqJCc7GwCgkCt0bVKpFHK5HKdOnmChiiqEhSoiIn37diXh+NEUCAC0WkHsOEQVolKpcOXKFTRs2BA2NjZixyEDEL1Q9fDhQ/Tt2xf79++Hg4MDgLwftJdffhnr16+HiwvnG6quvl6xF/Z2Vjjzy2fQaARYWEgQteB3rP/jOADgyu14xD1Iwucju2HEjJ+RnpmNUW+9jFrujnB3VoqcnojKws+/Njw8PPHd3G8wOWo6rK2t8dPqlUiIj0diYqLY8YiInunvv/+GjY0NmjZtqms7fvw4MjIy0KZNGxGTERV19lQqsrK0em0eHpw6g6qeghOnx8XFISAgQOxIZACiF6pGjhyJ1NRUXLhwAYGBgQCAixcvIiIiAqNGjcLPP//81OPVajXUarVem0KhKGFvqkre6PQ8+nZuhkETV+HijQdoVN8Ls8e+gQeJyVi7/Rhyc7Xo+/FSLIoagAd/z0ZurgZ/HruCXYcugB+eE1UtMpkMc+Z9j6mTJ6H1C81hYWGBFi3D0Kp1GwgCP+mlCuLfBKoEL730EgICAnDx4kVd29tvv42rV69Co9GImIyoZH3ecoOre16BytFJ9LeGRGVSeHW/evXqiR2JDET030a7du3Cvn37dEUqIG/o34IFC9CpU6dnHh8dHY1p06bptUVFFZ2ol6qemaN74OsVe7Fp9wkAwIXr9+Hj4YRPBnfE2u3HAACnLt1By76zYG9nBbnMEo+epOHv1WNx4mKcmNGJqByCghtg49ZfkZqaipycHDg5OWFA394IDm4gdjSq4jj0jyrDrVu3IJPJ9NpiYmKQk5MjUiKiZ1M6WKKms+zZOxKZmMJFKk6cbl5E/5fUarVF/qgDeZ+ua7XaYo7QN2HCBCQnJ+ttEyZMMEZUqmTWVnJoBf2fAY1WKPYXUEpaFh49ScNzPi54PsgHv+8/W1kxicjAatSoAScnJ8TG3sbFC+fxUrv2YkciInomX19feHp66rV5enrC19dXpEREROaJRSrzJ3qPqnbt2uGjjz7Czz//rPvjfu/ePYwZMwbt2z/7zYlCoeBQPzO18+9zGDckHHcePMHFGw8QElALo956Gau3HdXt07NDKBKfpOFOfBIa1PXE15+8ge37zyLm6GURkxNRcTLS0xEX9/+9He/dvYvLly5BqVTCw9MTe3b/AUdHJ3h4eOLatSv4KnomXm7XAS+82ErE1GQO2KOKiIjIPAiCgFu3brFIZeZEL1TNnz8f3bp1g5+fH7y9vQEAd+7cQYMGDbBmzRqR05GYIr/chKgPu2DexD5wcbTDg8RkLNt8GDOX/KHbx93FHl9+3BOuNWsg/lEK1v5+DNFLdomYmohKcuHCebw7eKDu9tdfRQMAunV/HZ/PnIXExER8/dUsPH70GC4uLujSrTuGvf+hWHGJiJ7K0dGx1EXQpKQkI6chIqoeJBIJGjRogNjYWNSuXZtFKjMlEUxgllpBELBv3z5cvpzXCyYwMBAdOnSo0DmtQ0cYIhoRiSzz1Hxk5YqdgogMwUqkj8fqjP3j2TuV0fWvOxv8nFS1rFq1qtT7RkREGDFJxaWkpECpVCI5ORn29vZix6FKMCc6FinJGrw3wguetTg6hUyfWq3mSKpqRPQeVatXr0afPn3QsWNHdOzYUdeenZ2N9evXY+DAgU85moiIiOjpxBz65+fnh9jY2CLtH374IRYsWICsrCx8/PHHWL9+PdRqNcLDw7Fw4UK4ubmJkJbKwtSLT0Tx99VISir+076cHNH7KhCVWv6cVLVr10atWrXEjkOVQPRC1eDBg/HKK6/A1dVVrz01NRWDBw9moYqIiIiqrP/++w8ajUZ3+/z58+jYsSN69+4NABgzZgx27NiBTZs2QalUYsSIEejZsycOHz4sVmQqpxs3bmDFihW4ceMG5s2bB1dXV/zxxx/w8fFBcHCw2PGomnmSlIPF39175n4cNUWmruDE6UlJSfDy8uLck9WA6IUqQRCK/UG7e/culEqlCImIiIjInIh5Pevi4qJ3e9asWXjuuefQtm1bJCcnY9myZVi3bh3atWsHAFixYgUCAwNx9OhRtGzZUozIVA4HDhxA586d8eKLL+Lvv//GF198AVdXV5w5cwbLli3D5s2bxY5I1Uxqal6B3MJSAk8vebH7OLvI4epe/H1EpqC41f1YpKoeRCtUhYaGQiKRQCKRoH379rC0/P8oGo0Gt27dwiuvvCJWPCIiIjITxrioVavVUKvVem3PWok4Ozsba9asQWRkJCQSCU6cOIGcnBy9eTkDAgLg4+ODI0eOsFBVhYwfPx4zZsxAZGQkatSooWtv164d5s+fL2Iyqu6USgsM+cBL7BhEZVZckYoTp1cfohWqevToAQA4ffo0wsPDYWdnp7tPLpfDz88PvXr1EikdERERUcmio6Mxbdo0vbaoqChMnTq1xGO2bdsGlUqFQYMGAQDi4+Mhl8vh4OCgt5+bmxvi4+MNnJiM6dy5c1i3bl2RdldXVzx69EiERFRdaLXFzzUllNBOVBWwSEWiFaqioqIA5E0y2qdPH1hZWYkVhYiIiMyYMUYJTJgwAZGRkXptz1qNaNmyZejcuTM8PT0NH4hE5eDggAcPHsDf31+v/dSpU/DyYm8WMo7LF9Kxef1D5HJidDIzKSkpLFJVc6LPUcUVU4iIiMiYpFLDV6qeNcyvsNjYWOzbtw9bt27Vtbm7uyM7OxsqlUqvV1VCQgLc3d0NGZeMrG/fvhg3bhw2bdoEiUQCrVaLw4cPY+zYsVwYiIzm5o3MZxapfP2tKykNkeH4+PhAoVDAxcWFRapqSvRCFREREZG5W7FiBVxdXfHaa6/p2po0aQKZTIaYmBjddAdXrlxBXFwcwsLCxIpK5TBz5kwMHz4c3t7e0Gg0CAoKgkajQf/+/fHZZ5+JHY/MXMtWSrR52aHoHRLAxsai0vMQlUdKSgpsbGx0c1e7ubmJnIjExEIVERERmTWxFwjSarVYsWIFIiIi9BaPUSqVGDJkCCIjI+Hk5AR7e3uMHDkSYWFhnEi9ipHL5Vi6dCkmT56M8+fPIy0tDaGhoahbt67Y0agakMkksLFlQYqqrvw5qWrUqIFGjRrBwoI/z9UdC1VERERERrRv3z7ExcXhnXfeKXLft99+C6lUil69ekGtViM8PBwLFy4UISUZgo+PD7y9vQEYZ7VJIiJzU3DidAsLC/7uJACASQ34FAQBgsDJAImIiMhwJBKJwbey6NSpEwRBQL169YrcZ2VlhQULFiApKQnp6enYunUr56eqopYtW4YGDRrAysoKVlZWaNCgAX788UexYxERmSyu7kclMYmfgtWrV6Nhw4awtraGtbU1GjVqhJ9++knsWERERGQGJBLDb0QFTZkyBR999BG6du2KTZs2YdOmTejatSvGjBmDKVOmiB2PiMjksEhFTyP60L85c+Zg8uTJGDFiBF588UUAwKFDh/D+++/j0aNHGDNmjMgJiYiIiIhKtmjRIixduhT9+vXTtXXr1g2NGjXCyJEjMX36dBHTERGZFhap6FlEL1R9//33WLRokd7Svd26dUNwcDCmTp3KQhURERFVCOe7IGPLyclB06ZNi7Q3adIEubm5IiQiU6JWa3HlUgZysrUGPW9iQrZBz0dUWSwtLWFhYQEHBwcWqahYoheqHjx4gBdeeKFI+wsvvIAHDx6IkIiIiIjMCQtVZGxvv/02Fi1ahDlz5ui1L1myBAMGDBApFZmKwwdU+PtPldHOb2HB33FUtdjZ2SE0NBRWVlYsUlGxRC9U1alTBxs3bsTEiRP12jds2MAlfYmIiIjIJEVGRuq+lkgk+PHHH7Fnzx60bNkSAHDs2DHExcXpjRqg6ik9XQMAqOkig7OzzKDnVlhJEdLEzqDnJDIGlUoFAHBwcAAA2NjYiBeGTJ7ohapp06ahT58++Pvvv3VzVB0+fBgxMTHYuHGjyOmIiIioqmOHKjKGU6dO6d1u0qQJAODGjRsAAGdnZzg7O+PChQuVno1MU6MQO7Rt7yh2DKJKlz8nlUQiQUhICGrUqCF2JDJxoheqevXqhWPHjuHbb7/Ftm3bAACBgYH4999/ERoaKm44IiIiIqJi/PXXX2JHIBMiCAIy0oufgyo3R6jkNESmo/DE6ba2tmJHoipA9EIVkPcJ1Jo1a8SOQURERGaIc1QRkbH9vCoBVy9niB2DyKRwdT8qL5MoVBEREREZC+tUVBmOHz+OjRs3Ii4uDtnZ+quxbd26VaRUVFlib2c99X6FlRR+z1lXUhoi8bFIRRUhWqFKKpU+8xNOiUTCJX2JiIiIyKStX78eAwcORHh4OPbs2YNOnTrh6tWrSEhIwOuvvy52PKpEIz6uBWcXudgxiESVlpbGIhVViGiFql9++aXE+44cOYLvvvsOWm3x47yJiIiISotD/8jYZs6ciW+//RbDhw9HjRo1MG/ePPj7+2PYsGHw8PAQOx4RUaWysbGBk5MTtFoti1RULqIVqrp3716k7cqVKxg/fjy2b9+OAQMGYPr06SIkIyIiInPCOhUZ240bN/Daa68BAORyOdLT0yGRSDBmzBi0a9cO06ZNEzkhGdq9O1nYtysJOf+bKD1bzQ/YifJJpVIEBQXpviYqK5P4qbl//z6GDh2Khg0bIjc3F6dPn8aqVavg6+srdjQiIiIioqdydHREamoqAMDLywvnz58HkDdHS0YGJ9g2Ryf/S8WtG1m4G6fG3Tg1BAGwsABsbS3EjkYkCpVKhRs3bkAQ8oq3UqmURSoqN1EnU09OTsbMmTPx/fffIyQkBDExMWjdurWYkYiIiMjMcOgfGVubNm2wd+9eNGzYEL1798ZHH32EP//8E3v37kX79u3FjkdGkD9DScMQOwQ1tAUAuLjKYG3DQhVVPwUnTre2toanp6fYkaiKE61Q9dVXX+HLL7+Eu7s7fv7552KHAhIRERFVFOtUZGzz589HVlbeqm+TJk2CTCbDP//8g169euGzzz4TOR0Zk4ubDIHBtmLHIBJN4dX93N3dxY5EZkC0QtX48eNhbW2NOnXqYNWqVVi1alWx+3E5XyIiIiIyZU5OTrqvpVIpxo8fL2IaMgZBEHD+TDqSVXkrkifEZ4uciEh8hYtUnDidDEW0QtXAgQPZFZ+IiIiMjtcbZAwpKSml3tfe3t6ISagy3Lurxpb1D4u0yyz5+4WqJxapyJhEK1StXLlSrIcmIiIiIqoQBweHZxZBBUGARCKBRqOppFRkLFmZeZNSWVlLERBkk/e1lRSNQmuIGYtIFDk5OTh37hyLVGQ0ok6mTkRERGRs7FBFxvDXX3+JHYFE4OBoiR69XcWOQSQqmUyG+vXrIyEhAcHBwSxSkcGxUEVERERmjUP/yBjatm0rdgQiokqV30sUAFxdXeHi4sK/sWQULH0SERERERERUYlUKhWOHz8OtVqta2ORioyFhSoiIiIyaxKJ4TciIqLqIn/i9PT0dMTGxoodh6oBDv0jIiIis8ZPfImIiMqn8Op+derUETsSVQPsUUVEREREREREegoXqbi6H1UW/pQRERGRWePQP6oMubm52LdvH3744QekpqYCAO7fv4+0tDSRkxERlR2LVCQmDv0jIiIiIqqA2NhYvPLKK4iLi4NarUbHjh1Ro0YNfPnll1Cr1Vi8eLHYEYmISk0QBFy/fp1FKhINf9qIiIjIrEkkEoNvRAV99NFHaNq0KZ48eQJra2td++uvv46YmBgRkxERlZ1EIkHDhg3h6enJIhWJgj2qiIiIyKyxsETGdvDgQfzzzz+Qy+V67X5+frh3755IqYiIyiYnJwcymQwAoFAoUK9ePZETUXXFQhURERERUQVotVpoNJoi7Xfv3kWNGjVESESGcOtGJq5fzQAAPEnKFTkNkXGpVCqcO3cO9erVg5ubm9hxqJpjoYqIiIjMGjtUkbF16tQJc+fOxZIlSwDk9eJLS0tDVFQUXn31VZHTUXltWf8Qaan6BUiFgkOgyPwUnDg9ISEBrq6u7I1MomKhioiIiMwaL7bJ2L755huEh4cjKCgIWVlZ6N+/P65duwZnZ2f8/PPPYsejcspWawEAoU1rwMpaCqkUaNDYTuRURIZV3Op+/LtJYmOhioiIiIioAmrVqoUzZ85g/fr1OHv2LNLS0jBkyBAMGDBAb3J1qppav+wAp5oysWMQGVxxRSpOnE6mgIUqIiIiMmv8YJiMLSsrC1ZWVnjrrbfEjkJEVCosUpEp408iERERmTWJRGLwjaggV1dXREREYO/evdBqtWLHISJ6pqSkJBapyGTxp5GIiIiIqAJWrVqFjIwMdO/eHV5eXhg9ejSOHz8udiwiohL5+/ujfv36LFKRSeJPJBEREZk1icTwG1FBr7/+OjZt2oSEhATMnDkTFy9eRMuWLVGvXj1Mnz5d7HhERACA1NRUXa9PiUQCDw8PFqnIJPGnkoiIiIjIAGrUqIHBgwdjz549OHv2LGxtbTFt2jSxYxERQaVS4dSpUzh//jyHKJPJ42TqREREZNak7AJFlSQrKwu//fYb1q1bh127dsHNzQ2ffPKJ2LGolK5ezsDvvyQiN1cAAGRnCyInIjKMghOnE1UFLFQRERGRWWOdioxt9+7dWLduHbZt2wZLS0u88cYb2LNnD9q0aSN2NCqDi+fSkJKs0WuzsZXCroaFSImIKo6r+1FVxEIVEREREVEFvP766+jSpQtWr16NV199FTKZTOxIVAEtX7TH883tAQBKB0vI5XxTT1UTi1RUVbFQRURERGZNwi5VZGQJCQmoUaOG2DHIQOxqWMLVTS52DKIKYZGKqjL+pBIREZFZk0oMvxGlpKTovhYEASkpKSVuZbVgwQL4+fnBysoKLVq0wL///vvU/VUqFYYPHw4PDw8oFArUq1cPO3fuLPPjVjcajYD9+57gty2J+G1LIuJi1WJHIjIYiUQCiUTCIhVVSexRRURERERURo6Ojnjw4AFcXV3h4OBQbM89QRAgkUig0WiKOUPxNmzYgMjISCxevBgtWrTA3LlzER4ejitXrsDV1bXI/tnZ2ejYsSNcXV2xefNmeHl5ITY2Fg4ODhX59qqF2FtZ2L/vSZF2K2u+oaeqT6lUIjQ0FDY2NixSUZXDQhURERGZNQ79I2P4888/4eTkBAD466+/DHbeOXPmYOjQoRg8eDAAYPHixdixYweWL1+O8ePHF9l/+fLlSEpKwj///KObG8vPz89gecxZ/up+Newt0Cwsb04qa2sLNAq1EzMWUbmpVCpYWFjohiLb2fFnmaomFqqIiIjIrLFORcbQtm1b3df+/v7w9vYuUhQVBAF37twp9Tmzs7Nx4sQJTJgwQdcmlUrRoUMHHDlypNhjfvvtN4SFhWH48OH49ddf4eLigv79+2PcuHGwsOBqdaVRw94SbV52FDsGUYXkz0kllUoRGhoKW1tbsSMRlRsLVUREREREFeDv768bBlhQUlIS/P39Sz3079GjR9BoNHBzc9Nrd3Nzw+XLl4s95ubNm/jzzz8xYMAA7Ny5E9evX8eHH36InJwcREVFFXuMWq2GWv3/8zGVZx4tIjIdBSdOd3BwgLW1tdiRiCqEg1WJiIjIrEmM8F9Z3Lt3D2+99RZq1qwJa2trNGzYEMePH9fdLwgCpkyZAg8PD1hbW6NDhw64du2aoZ8GMqL8uagKS0tLg5WVlVEfW6vVwtXVFUuWLEGTJk3Qp08fTJo0CYsXLy7xmOjoaCiVSt3m7e1t1IxEZDxc3Y/MEXtUERERERnJkydP8OKLL+Lll1/GH3/8ARcXF1y7dg2Ojv8/zOirr77Cd999h1WrVsHf3x+TJ09GeHg4Ll68aPQiB1VMZGQkgLx50CZPngwbGxvdfRqNBseOHUNISEipz+fs7AwLCwskJCTotSckJMDd3b3YYzw8PCCTyfSG+QUGBiI+Ph7Z2dmQy+VFjpkwYYIuO5DXo4rFKqKqh0UqMlcsVBEREZFZk4o4R9WXX34Jb29vrFixQtfm7++v+1oQBMydOxefffYZunfvDgBYvXo13NzcsG3bNvTt27fSM1PpnTp1CkDev+O5c+f0ikJyuRyNGzfG2LFjS30+uVyOJk2aICYmBj169ACQ12MqJiYGI0aMKPaYF198EevWrYNWq9W9Qb169So8PDyKLVIBgEKhgEKhKHUuIjI9qampLFKR2WKhioiIiMyamKv+/fbbbwgPD0fv3r1x4MABeHl54cMPP8TQoUMBALdu3UJ8fDw6dOigO0apVKJFixY4cuQIC1UmLn+1v8GDB2PevHmwt7ev8DkjIyMRERGBpk2bonnz5pg7dy7S09N1qwAOHDgQXl5eiI6OBgB88MEHmD9/Pj766COMHDkS165dw8yZMzFq1KgKZyEi02VjYwN7e3tIpVIWqcjssFBFREREVEaFJ6MGiu+lcvPmTSxatAiRkZGYOHEi/vvvP4waNQpyuRwRERGIj48HgGInz86/j0xfwR5zFdWnTx8kJiZiypQpiI+PR0hICHbt2qX7GYmLi9N7Q+rt7Y3du3djzJgxaNSoEby8vPDRRx9h3LhxBstERKbHwsICDRs2hEQiYZGKzA4LVURERGTWjNGhKjo6GtOmTdNri4qKwtSpU/XatFotmjZtipkzZwIAQkNDcf78eSxevBgRERGGD0aVpmfPnli5ciXs7e3Rs2fPp+67devWMp17xIgRJQ71279/f5G2sLAwHD16tEyPQURVj0qlQnJyMnx8fCCRSPTmpiMyJyxUERERkVmTGqFSVXgyagDFzvnj4eGBoKAgvbbAwEBs2bIFAHQTZCckJMDDw0O3T0JCQpkm4abKp1QqdcNKlUqlyGmIyNwVnDhdoVCUuMACkTlgoYqIiIiojEo7GfWLL76IK1eu6LVdvXoVvr6+APImVnd3d0dMTIyuMJWSkoJjx47hgw8+MHhuMpyCw/0MOfSPiKiwwqv7ubq6ih2JyKhYqCIiIiKzJuJc6hgzZgxeeOEFzJw5E2+++Sb+/fdfLFmyBEuWLPlfNglGjx6NGTNmoG7duvD398fkyZPh6empW/WNTF9mZiYEQYCNjQ0AIDY2Fr/88guCgoLQqVMnkdNRQadPpOLyxXQAQFqqRuQ0RM9WuEjFidOpOmChioiIiMhImjVrhl9++QUTJkzA9OnT4e/vj7lz52LAgAG6fT799FOkp6fjvffeg0qlQqtWrbBr1y5YWVmJmJzKonv37ujZsyfef/99qFQqNG/eHHK5HI8ePcKcOXPYO86E/LH9MdRZWr02G1u+6SfTxCIVVVcsVBEREZFZk4jZpQpAly5d0KVLlxLvl0gkmD59OqZPn16JqciQTp48iW+//RYAsHnzZri7u+PUqVPYsmULpkyZwkKVCdFoBABAu3BH2NhYQCIB6gbYiJyKqKjs7GycO3eORSqqllioIiIiIrMmcp2KqoGMjAzUqFEDALBnzx707NkTUqkULVu2RGxsrMjpqDiNQuzg4CgTOwZRieRyOWrXro3Hjx+zSEXVDn/aiYiIiIgqoE6dOti2bRvu3LmD3bt36+alevjwIezt7UVOR0RViSAIuq+9vLzQsGFDFqmo2uFPPBEREZk1qURi8I2ooClTpmDs2LHw8/ND8+bNERYWBiCvd1VoaKjI6YioqlCpVDh16hRycnJ0bWIPXycSA4f+ERERkVnjJT4Z2xtvvIFWrVrhwYMHaNy4sa69ffv2eP3110VMRkRVRcGJ02NjY1GnTh2xIxGJhoUqIiIiIqIKcnd3h7u7O+7evQsAqFWrFpo3by5yKiKqCgqv7le7dm2xIxGJikP/iIiIyKxJJBKDb0QFabVaTJ8+HUqlEr6+vvD19YWDgwM+//xzaLVaseMRkQkrXKTixOlE7FFFREREZk7KuhIZ2aRJk7Bs2TLMmjULL774IgDg0KFDmDp1KrKysvDFF1+InJCITBGLVETFY6GKiIiIiKgCVq1ahR9//BHdunXTtTVq1AheXl748MMPWagioiIEQcDVq1dZpCIqBgtVREREZNY4VI+MLSkpCQEBAUXaAwICkJSUJEIiIjJ1EokEDRs2RGxsLOrVq8ciFVEBfDUQEREREVVA48aNMX/+/CLt8+fP11sFkIgoNzdX97W1tTUCAgJYpCIqhD2qiIiIyKyxQxUZ21dffYXXXnsN+/btQ1hYGADgyJEjuHPnDnbu3Clyuurt7p0s/LX3CXJzBABAbq4gciKqzlQqFc6fP4/AwEDUrFlT7DhEJoulWyIiIjJrXPWPjK1t27a4evUqevbsCZVKBZVKhZ49e+LKlSto3bq12PGqteNHU3DjaiZib2Uh9lYWIACWlhJYWVuIHY2qmfyJ03Nzc3H//n0IAoumRCVhjyoiIiIionK6ffs29u7di+zsbPTt2xcNGjQQOxIVoNXm/b9RqB3qB9oAAFzd5bCy4uf1VHkKr+4XHBzMDz2InoKFKiIiIjJrUr4XICP566+/0KVLF2RmZgIALC0tsXz5crz11lsiJ6PC3D3kCG5kJ3YMqoYKF6m4uh/Rs/EVQkRERGaNQ//IWCZPnoyOHTvi3r17ePz4MYYOHYpPP/1U7FjVmlYr4MLZNBw5qMKRgyokPswWOxJVYyxSEZUPe1QREREREZXD+fPn8c8//8DDwwMAMHv2bPzwww94/PgxJ0oWyZ04NTate1ik3VLGAjNVvocPH7JIRVQOLFQRERGRWePbUzKWlJQUODs7627b2NjA2toaycnJLFSJJDNDAwCwtpGiTj0b3dcc9kdiqFu3LmxsbODp6ckiFVEZsFBFREREZk3KoXpkRLt374ZSqdTd1mq1iImJwfnz53Vt3bp1EyNateZUU4ZefV3FjkHVUFpaGmxtbXVDxWvVqiV2JKIqp9SFqp49e5b6pFu3bi1XGCIiIiKiqiQiIqJI27Bhw3RfSyQSaDSayoxU7Wg0ApJVuQCAtFQ+1ySe/DmpnJ2dERgYyDkNicqp1IWqgp8UEREREVUVfJ9AxqLVasWOQABW/HAfd+PUYsegaq7gxOm5ubkQBIGFKqJyKnWhasWKFcbMQUREREREVGb37+UVqWQyCSQSQCKVoEEjW5FTUXXC1f2IDItzVBEREZFZ4yfaZAxHjx5Fy5YtS7VvRkYGbt26heDgYCOnqt5GjPWGUsm3N1S5WKQiMrxyv4I2b96MN998Ey1btsTzzz+vtxERERGZConE8BvR22+/jfDwcGzatAnp6enF7nPx4kVMnDgRzz33HE6cOFHJCYnI2FikIjKOcr2KvvvuOwwePBhubm44deoUmjdvjpo1a+LmzZvo3LmzoTMSEREREZmUixcv4rXXXsNnn30GBwcHBAcHo2PHjujatStatWoFZ2dnPP/887h16xb27NmDgQMHih2ZiAwsf546FqmIDKtcfWMXLlyIJUuWoF+/fli5ciU+/fRT1K5dG1OmTEFSUpKhMxIRERGVm5RdoMgIZDIZRo0ahVGjRuH48eM4dOgQYmNjkZmZicaNG2PMmDF4+eWX4eTkJHZUIjISJycnhISEwM7OjkUqIgMqV6EqLi4OL7zwAgDA2toaqampAPK6QLds2RLz5883XEIiIiKiCmCdioytadOmaNq0qdgxiKgSqFQqyOVy2NjYAADs7e1FTkRkfspV9nV3d9f1nPLx8cHRo0cBALdu3YIgCIZLR0RERERERGQC8uekOn36NDIzM8WOQ2S2ylWoateuHX777TcAwODBgzFmzBh07NgRffr0weuvv27QgEREREQVIZFIDL4REVH1UnDidDs7OygUCrEjEZmtcg39W7JkiW7iuOHDh6NmzZr4559/0K1bNwwbNsygAYmIiIiIiIjEwtX9iCpXuQpVUqlU74XZt29f9O3b12ChDCHzFOfJIjIXVuX6TUVElIdvJYiIqLxYpCKqfOV++3fw4EH88MMPuHHjBjZv3gwvLy/89NNP8Pf3R6tWrQyZsVyuxGeIHYGIDKC+uw06LTgqdgwiMoA9w1uK8rgcqkeVKSsrC1ZWVmLHICIDSElJYZGKSATlepVt2bIF4eHhsLa2xqlTp6BWqwEAycnJmDlzpkEDEhERERGZMq1Wi88//xxeXl6ws7PDzZs3AQCTJ0/GsmXLRE5HROVlbW0NGxsbFqmIKlm5XmkzZszA4sWLsXTpUshkMl37iy++iJMnTxosHBEREVFFSSWG34gKmjFjBlauXImvvvoKcrlc196gQQP8+OOPIiYjooqQyWRo3Lgxi1RElaxcr7YrV66gTZs2RdqVSiVUKlVFMxEREREZDAtVZGyrV6/GkiVLMGDAAFhYWOjaGzdujMuXL4uYjIjKSqVS4d69e7rbMpmMRSqiSlauV5y7uzuuX79epP3QoUOoXbt2hUMREREREVUV9+7dQ506dYq0a7Va5OTkiJCIiMojf+L0a9euITExUew4RNVWuQpVQ4cOxUcffYRjx45BIpHg/v37WLt2LT7++GN88MEHhs5IREREVG4SicTgG1FBQUFBOHjwYJH2zZs3IzQ0VIRERFRWhVf3q1mzptiRiKqtcq36N378eGi1WrRv3x4ZGRlo06YNFAoFPvnkE7z77ruGzkhERERUbhyqR8Y2ZcoURERE4N69e9Bqtdi6dSuuXLmC1atX4/fffxc7HhE9Q+EiFeekIhJXuV59EokEkyZNQlJSEs6fP4+jR48iMTERSqUS/v7+hs5IRERERGSyunfvju3bt2Pfvn2wtbXFlClTcOnSJWzfvh0dO3YUOx4RPQWLVESmp0w9qtRqNaZOnYq9e/fqelD16NEDK1aswOuvvw4LCwuMGTPGWFmJiIiIyowj9agytG7dGnv37hU7BhGVQVZWFotURCaoTK/CKVOmYNGiRfDz88OtW7fQu3dvvPfee/j222/xzTff4NatWxg3bpyxshIRERERmZzatWvj8ePHRdpVKhUXGiIyYVZWVvD19WWRisjElKlH1aZNm7B69Wp069YN58+fR6NGjZCbm4szZ85wYlEiIiIySVJeo5CR3b59GxqNpki7Wq3WW+aeiEyDIAi696++vr56t4lIfGUqVN29exdNmjQBADRo0AAKhQJjxozhi5qIiIhMFj8fJ2P57bffdF/v3r0bSqVSd1uj0SAmJgZ+fn4iJCOikqhUKsTFxSEoKAiWlnlvh/l+lsi0lKlQpdFoIJfL//9gS0vY2dkZPBQRERERkanr0aMHgLw3uREREXr3yWQy+Pn54ZtvvhEhGREVp+DE6XFxcRyaS2SiylSoEgQBgwYNgkKhAJA3+dz7778PW1tbvf22bt1quIREREREFcAPyslYtFotAMDf3x///fcfnJ2dRU5ERCUpvLofezsSma4yFaoKf1L01ltvGTQMERERkaFxjioytlu3bokdgYieonCRihOnE5m2MhWqVqxYYawcRERERERVVnp6Og4cOIC4uDhkZ2fr3Tdq1CiRUhERi1REVU+ZClVEREREVQ07VJGxnTp1Cq+++ioyMjKQnp4OJycnPHr0CDY2NnB1dWWhikgkWq0Wly9fZpGKqIrhq5SIiIjMmlRi+K20pk6dColEorcFBATo7s/KysLw4cNRs2ZN2NnZoVevXkhISDDCs0DGNGbMGHTt2hVPnjyBtbU1jh49itjYWDRp0gRff/212PGIqi2pVIoGDRrAzc2NRSqiKoSvVCIiIiIjCg4OxoMHD3TboUOHdPeNGTMG27dvx6ZNm3DgwAHcv38fPXv2FDEtlcfp06fx8ccfQyqVwsLCAmq1Gt7e3vjqq68wceJEseMRVTsajUb3tZ2dHQIDA1mkIqpCOPSPiIiIzJrYk6lbWlrC3d29SHtycjKWLVuGdevWoV27dgDy5gMNDAzE0aNH0bJly8qOSuUkk8l0b4JdXV0RFxeHwMBAKJVK3LlzR+R0RNWLSqXChQsXEBwcDAcHB7HjEFE5sKxMREREZETXrl2Dp6cnateujQEDBiAuLg4AcOLECeTk5KBDhw66fQMCAuDj44MjR46IFZfKITQ0FP/99x8AoG3btpgyZQrWrl2L0aNHo0GDBiKnI6o+8idOz8nJwb1798SOQ0TlxEIVERERmTWJxPCbWq1GSkqK3qZWq4s8dosWLbBy5Urs2rULixYtwq1bt9C6dWukpqYiPj4ecrm8yCf+bm5uiI+Pr6Rnhwxh5syZ8PDwAAB88cUXcHR0xAcffIDExET88MMPIqcjqh4Kr+4XGBgodiQiKicO/SMiIiKzVpbJz0srOjoa06ZN02uLiorC1KlT9do6d+6s+7pRo0Zo0aIFfH19sXHjRlhbWxs+GImiadOmuq9dXV2xa9cuEdMQVT+Fi1ScOJ2oauOrl4iIiKiMJkyYgOTkZL1twoQJzzzOwcEB9erVw/Xr1+Hu7o7s7GyoVCq9fRISEoqd04qqnpMnT6JLly5ixyAyayxSEZkfvoKJiIjIrEmM8J9CoYC9vb3eplAonpklLS0NN27cgIeHB5o0aQKZTIaYmBjd/VeuXEFcXBzCwsKM+ZSQAe3evRtjx47FxIkTcfPmTQDA5cuX0aNHDzRr1gxarVbkhETm7f79+yxSEZkZDv0jIiIis2aMoX+lNXbsWHTt2hW+vr64f/8+oqKiYGFhgX79+kGpVGLIkCGIjIyEk5MT7O3tMXLkSISFhXHFvypi2bJlGDp0KJycnPDkyRP8+OOPmDNnDkaOHIk+ffrg/PnznCeHyMgCAgJga2sLb29vFqmIzAQLVURERERGcvfuXfTr1w+PHz+Gi4sLWrVqhaNHj8LFxQUA8O2330IqlaJXr15Qq9UIDw/HwoULRU5NpTVv3jx8+eWX+OSTT7Blyxb07t0bCxcuxLlz51CrVi2x4xGZrYyMDFhbW0MikUAqlcLX11fsSERkQCxUERERkVkTs0fV+vXrn3q/lZUVFixYgAULFlRSIjKkGzduoHfv3gCAnj17wtLSErNnz2aRisiI8uekcnd3R926dSGRiPhLnoiMgn0jiYiIiIjKITMzEzY2NgAAiSRv7jIPDw+RUxGZr4ITp2dlZUEQBLEjEZERsEcVERERmTV+2k7G9OOPP8LOzg4AkJubi5UrV8LZ2Vlvn1GjRokRjciscHU/ouqDhSoiIiIya2IO/SPz5uPjg6VLl+puu7u746efftLbRyKRsFBFVEEsUhFVLyxUERERERGVw+3bt8WOQGT2WKQiqn5YqCIiIiKzxpF/RERVV3Z2NotURNUMC1VERERk1qSsVBERVVmurq6QyWRQKpUsUhFVE3ylExERERGZkAULFsDPzw9WVlZo0aIF/v3331Idt379ekgkEvTo0cO4AYmMLDk5GWq1Wnfb0dGRRSqiaoSvdiIiIjJrUonhNyJj2bBhAyIjIxEVFYWTJ0+icePGCA8Px8OHD5963O3btzF27Fi0bt26kpISGYdKpcKZM2dw+vRpvWIVEVUfLFQRERGRWZNIDL8RGcucOXMwdOhQDB48GEFBQVi8eDFsbGywfPnyEo/RaDQYMGAApk2bhtq1a1diWiLDKjhxurW1NWQymdiRiEgELFQREREREVXQjRs38Nlnn6Ffv3663k9//PEHLly4UOpzZGdn48SJE+jQoYOuTSqVokOHDjhy5EiJx02fPh2urq4YMmRIqR5HrVYjJSVFbyMSG1f3I6J8fOUTERGRWZNCYvCNqKADBw6gYcOGOHbsGLZu3Yq0tDQAwJkzZxAVFVXq8zx69AgajQZubm567W5uboiPjy/2mEOHDmHZsmVYunRpqR8nOjoaSqVSt3l7e5f6WCJjYJGKiAriq5+IiIiIqALGjx+PGTNmYO/evZDL5br2du3a4ejRo0Z73NTUVLz99ttYunQpnJ2dS33chAkTkJycrNvu3LljtIxEz5KcnMwiFRHpsRQ7ABEREZExcU4pMrZz585h3bp1RdpdXV3x6NGjUp/H2dkZFhYWSEhI0GtPSEiAu7t7kf1v3LiB27dvo2vXrro2rVYLALC0tMSVK1fw3HPPFTlOoVBAoVCUOheRMVlZWek2FqmICGCPKiIiIjJzXPWPjM3BwQEPHjwo0n7q1Cl4eXmV+jxyuRxNmjRBTEyMrk2r1SImJgZhYWFF9g8ICMC5c+dw+vRp3datWze8/PLLOH36NIf0UZWgUCgQEhLCIhUR6bBHFRERERFRBfTt2xfjxo3Dpk2bIJFIoNVqcfjwYYwdOxYDBw4s07kiIyMRERGBpk2bonnz5pg7dy7S09MxePBgAMDAgQPh5eWF6OhoXQ+UghwcHACgSDuRKVGpVFCr1br52AoOmSUiYqGKiIiIzJqUY//IyGbOnInhw4fD29sbGo0GQUFB0Gg06N+/Pz777LMynatPnz5ITEzElClTEB8fj5CQEOzatUv3hj4uLo69TqhKKzhxukwmg5OTk9iRiMjEsFBFREREZo11KjI2uVyOpUuXYvLkyTh//jzS0tIQGhqKunXrlut8I0aMwIgRI4q9b//+/U89duXKleV6TKLKUHh1v/wegEREBbFQRURERERUAYcOHUKrVq3g4+MDHx8fseMQmaTCRSrOSUVEJeFvBiIiIjJrUonE4BtRQe3atYO/vz8mTpyIixcvih2HyOSwSEVEZcHfDkRERGTWJBLDb0QF3b9/Hx9//DEOHDiABg0aICQkBLNnz8bdu3fFjkYkuszMTBapiKhM+BuCiIiIiKgCnJ2dMWLECBw+fBg3btxA7969sWrVKvj5+aFdu3ZixyMSlZWVFTw9PVmkIqJS4xxVREREZNb4logqk7+/P8aPH4/GjRtj8uTJOHDggNiRiEQlkUjw3HPPQRAEFqmIqFT4m4KIiIiIyAAOHz6MDz/8EB4eHujfvz8aNGiAHTt2iB2LqNKpVCpcuHABWq0WQF6xikUqIiot9qgiIiIisybhpFJkZBMmTMD69etx//59dOzYEfPmzUP37t1hY2MjdjSiSldw4nRbW1v4+fmJHYmIqhgWqoiIiMissUxFxvb333/jk08+wZtvvglnZ2ex4xCJpvDqfj4+PmJHIqIqiIUqIiIiIqIKOHz4sNgRiERXuEjFidOJqLxYqCIiIiKzJuXQPzKC3377DZ07d4ZMJsNvv/321H27detWSamIxMEiFREZEgtVREREZNZYpiJj6NGjB+Lj4+Hq6ooePXqUuJ9EIoFGo6m8YESVTKPR4OLFiyxSEZHBsFBFRERERFRG+auZFf6aqLqxsLBAcHAw7t69i8DAQBapiKjC+FuEiIiIzJpEYviNqKDVq1dDrVYXac/Ozsbq1atFSERkfAULtEqlEsHBwSxSEZFB8DcJEREREVEFDB48GMnJyUXaU1NTMXjwYBESERmXSqXCsWPHkJqaKnYUIjJDLFQRERGRWZNIJAbfiAoSBKHYn4u7d+9CqVSKkIjIePInTler1bhz547YcYjIDHGOKiIiIjJr/FSOjCU0NFRXvGzfvj0sLf//0lqj0eDWrVt45ZVXRExIZFiFV/cLCAgQOxIRmSEWqoiIiIiIyiF/tb/Tp08jPDwcdnZ2uvvkcjn8/PzQq1cvkdIRGVbhIhVX9yMiY2GhioiIiMwah+qRsURFRQEA/Pz80KdPH1hZWYmcyDylp2uwfnU8UpI1xd6vLb6ZDIhFKiKqTCxUERERkVljmYqMLSIiQuwIZi3udhbuxBZdVbEgaxspbGxYODGWO3fusEhFRJWGhSoiIiIiojJycnLC1atX4ezsDEdHx6f23EtKSqrEZGZIyPufm7scXXs5F7uLU00ZZDIWT4wlKCgIcXFx8PX1ZZGKiIyOhSoiIiIyaxz6R8bw7bffokaNGrqv+XNmfHKFBLW8ObyysmRlZUGhUEAikcDCwgL+/v5iRyKiaoKFKiIiIjJr/OyfjKHgcL9BgwaJF4TICPLnpPL29oafnx8LsURUqXjtRkRERERUASdPnsS5c+d0t3/99Vf06NEDEydORHZ2tojJiMqu4MTpqampYschomqIhSoiIiIyaxKJxOAbUUHDhg3D1atXAQA3b95Enz59YGNjg02bNuHTTz8VOR1R6RW3uh9/5xFRZWOhioiIiIioAq5evYqQkBAAwKZNm9C2bVusW7cOK1euxJYtW8QNR1RKxRWpOHE6EYmBc1QRERGRWWNfADI2QRCg1WoBAPv27UOXLl0AAN7e3nj06JGY0YhKhUUqIjIlLFQRERGRWeOoFTK2pk2bYsaMGejQoQMOHDiARYsWAQBu3boFNzc3kdMRPVtmZiaLVERkMlioIiIiIiKqgLlz52LAgAHYtm0bJk2ahDp16gAANm/ejBdeeEHkdETP5uHhAblcDkdHRxapiEh0LFQRERGRWZNy8B8ZWaNGjfRW/cs3e/ZsWFhYiJCI6NmSk5NhY2MDmUwGAKhZs6bIiYiI8rBQRURERGaNQ/+ospw4cQKXLl0CAAQFBeH5558XORFR8fLnpLKxsUHjxo11xSoiIlPAfp1ERERElWTWrFmQSCQYPXq0ri0rKwvDhw9HzZo1YWdnh169eiEhIUG8kFRmDx8+xMsvv4xmzZph1KhRGDVqFJo2bYr27dsjMTFR7HhEegpOnC6Xy9nrj4hMDgtVREREZNYkRvivPP777z/88MMPaNSokV77mDFjsH37dmzatAkHDhzA/fv30bNnT0N861RJRo4cibS0NFy4cAFJSUlISkrC+fPnkZKSglGjRokdj0iHq/sRUVXA30pERERERpaWloYBAwZg6dKlcHR01LUnJydj2bJlmDNnDtq1a4cmTZpgxYoV+Oeff3D06FERE1NZ7Nq1CwsXLkRgYKCuLSgoCAsWLMAff/whYjKi/8ciFRFVFfzNRERERGZNIjH8plarkZKSorep1eoSMwwfPhyvvfYaOnTooNd+4sQJ5OTk6LUHBATAx8cHR44cMdpzQoal1WqLneNHJpNBq9WKkIhIH4tURFSV8LcTERERmTUpJAbfoqOjoVQq9bbo6OhiH3/9+vU4efJksffHx8dDLpfDwcFBr93NzQ3x8fHGeDrICNq1a4ePPvoI9+/f17Xdu3cPY8aMQfv27UVMVnWdPZ2GrRseYuuGhzh6OFnsOFWeQqGATCZjkYqIqgSTWPVPpVJh2bJlulVSgoOD8c4770CpVIqcjIiIiKioCRMmIDIyUq9NoVAU2e/OnTv46KOPsHfvXlhZWVVWPKpk8+fPR7du3eDn5wdvb28Aef/2DRo0wJo1a0ROVzVt35KInBxBr83GhpN+l5e1tTVCQ0Mhl8tZpCIikyd6oer48eMIDw+HtbU1mjdvDgCYM2cOvvjiC+zZs4fL+hIREVGFSMo39/lTKRSKYgtThZ04cQIPHz7Uu57RaDT4+++/MX/+fOzevRvZ2dlQqVR6vaoSEhLg7u5u+OBkFN7e3jh58iRiYmJ0H7wGBgYWGepJpZebm1ekatveAQorKaRSCQKDbUVOVbWoVCrk5ubC2dkZAFgsJ6IqQ/RC1ZgxY9CtWzcsXboUlpZ5cXJzc/Huu+9i9OjR+Pvvv0VOSERERFWZMQpVpdW+fXucO3dOr23w4MEICAjAuHHj4O3tDZlMhpiYGPTq1QsAcOXKFcTFxSEsLEyMyFRGGzZswG+//Ybs7Gy0b98eI0eOFDuSWWnawh417EV/y1Ll5M9JJQgCQkJCOFKFiKoU0X/rHz9+XK9IBQCWlpb49NNP0bRpUxGTEREREVVMjRo10KBBA702W1tb1KxZU9c+ZMgQREZGwsnJCfb29hg5ciTCwsLQsmVLMSJTGSxatAjDhw9H3bp1YW1tja1bt+LGjRuYPXu22NFMniAIuBOnRmpKbvH3V3Iec1J44vQaNWqIHYmIqExEL1TZ29sjLi4OAQEBeu137tzhL1UiIiKqMAlE7FJVCt9++y2kUil69eoFtVqN8PBwLFy4UOxYVArz589HVFQUoqKiAABr1qzBsGHDWKgqhTtxaixfdP+Z+0mlpv36NTVc3Y+IzIHohao+ffpgyJAh+Prrr/HCCy8AAA4fPoxPPvkE/fr1EzkdERERVXWm9j53//79eretrKywYMECLFiwQJxAVG43b95ERESE7nb//v0xZMgQPHjwAB4eHiImM335PakUCgncPIqf783bVwFbO06gXlosUhGRuRC9UPX1119DIpFg4MCByM3N+4Mlk8nwwQcfYNasWSKnIyIiIiIqnlqthq3t/0/wLZVKIZfLkZmZKWKqqsXdU4HBwzzFjlHlpaens0hFRGZD9EKVXC7HvHnzEB0djRs3bgAAnnvuOdjY2IicjIiIiMyBqQ/9o6pt8uTJetet2dnZ+OKLL/Qmr54zZ44Y0UyOIAjQavO+zv8/GYaNjQ1cXV2RnZ3NIhURVXmiF6qSk5Oh0Wjg5OSEhg0b6tqTkpJgaWkJe3t7EdMRERERERWvTZs2uHLlil7bCy+8gJs3b+puS8RcdtLErFuVgGuXM8SOYZYkEgnq168PQRBYpCKiKk/0QlXfvn3RtWtXfPjhh3rtGzduxG+//YadO3eKlIyIiIjMAesEZCyF5xujpyuuSOVX20qEJOZBpVIhISEB9erVg0Qi0W1ERFWd6IWqY8eOFdsd+qWXXsKkSZNESERERETmhEP/iEzLyLHesLGRQiKVwMqKvX/Ko+DE6TY2NvD29hY7EhGRwYheqFKr1bpJ1AvKycnhRJRERERERGbGykoKaxuu5ldehVf38/LyEjsSEZFBif4RRvPmzbFkyZIi7YsXL0aTJk1ESERERETmRCox/EZEJIbCRSpOnE5E5kj0HlUzZsxAhw4dcObMGbRv3x4AEBMTg//++w979uwROR0RERFVdRz6R0TmgEUqIqouRC9Uvfjiizhy5Ahmz56NjRs3wtraGo0aNcKyZctQt25dseORiHZu24g/ft2Mh/H3AQA+frXRN+I9NGnZCgCQrVZj+cI5OPjnbuTkZCO0WRjeHzMRjk41xYxNRCWoaSvDu2E+aObrAIWlBe4nZ+HrmBu4lpgOC6kEg1p4o7mvAzzsFUjP1uDknWQsOxKHpIwcsaMTERGJKjc3F+fPn2eRioiqBdELVQAQEhKCtWvXih2DTIyzixsiho2EZy0fCALw567t+GLSGMz9cT18/J/Dj/O/xvGjh/DptK9ga2uHH+bOQvTkj/HVgpViRyeiQuwUFvi2ZwOcuZeMSdsvIzkzF14OVkhT581RqLCUoq6LDdYev4ubjzJgp7DEh639MP21+hix6bzI6amq4yJYVBkOHjyIH374ATdu3MDmzZvh5eWFn376Cf7+/mjVqpXY8aiKs7S0RFBQEO7fv4+goCAWqYjIrInyGy4lJUXv66dtVH01f7EtmrZsDc9avvDy9sXbQ0fAytoGly+eRXpaKvbt3IYhwyPR+PnmqFM/CB+Nn4bL58/g8oWzYkcnokLeDPVEYpoa3/x5E1cepiM+VY0Td5LxIEUNAMjI1mD8b5fx9/Uk3FVl4XJCGub/fQv1XO3gYicXOT1VdRIjbEQFbdmyBeHh4bC2tsapU6egVuf9bktOTsbMmTNFTkdVmSAIuq/Zk4qIqgtRfss5Ojri4cOHAAAHBwc4OjoW2fLbiQBAo9Hg75hdyMrKREBwI1y/egm5ublo3KSlbp9avv5wcXPHFRaqiExOmL8jrj1Mx2fhdbFxcBMsfLMhOge5PvUYW7kFtIKAdLWmklISEZXPjBkzsHjxYixduhQymUzX/uKLL+LkyZMiJqOqTKVS4d9//0VGRobYUYiIKpUoQ//+/PNPODk56b6WsE8+leD2jWv4dHgEsrOzYW1tjYkzvoGP33O4de0qLGUy2NWoobe/g2NNPEl6LFJaIiqJh70VujSwwpYzD/DziXuo72qHD1v7IVejxd4rj4rsL7OQ4N0wH+y/9hgZOSxUUcVIeZ1BRnblyhW0adOmSLtSqYRKpar8QFTlFZw4PS4uDgEBAWJHIiKqNKIUqtq2bav7+qWXXqrQudRqta57dT6FQlGhc5Lp8PLxw9wf1yMjPQ2HD+zD3JlTMPO7H8WORURlJJEAVx+mY8XROwCAG48y4FfTGq81cCtSqLKQSvBZeF1AIsF3+2+JEZeIqEzc3d1x/fp1+Pn56bUfOnQItWvXFicUVVmFV/erV6+e2JGIiCqV6AOcp06dCq1WW6Q9OTkZ/fr1e+bx0dHRUCqVelt0dLQxopIIZDIZPGv5oE79IES8Nwr+deph++af4VCzJnJzcpCWmqq3v+rJY676R2SCkjJyEPckU68tLikLrnb6HyzkF6lcaygw/tdL7E1FBsE5qsjYhg4dio8++gjHjh2DRCLB/fv3sXbtWowdOxYffPCB2PFElZmhQVpqLtJSc8WOUiUULlJxTioiqo5EX/Vv2bJl2LNnD9asWaP7xGn//v0YOHAg3N3dn3n8hAkTEBkZqdemUChw+wnf3JgjrVZATk426tQLhKWlJc6ePIYX2nYAANyNu43EhHjUD24kckoiKuzCg1TUcrDSa6vlYIWE1P/vEZtfpPJSWuGTbReRquabGjIQVpbIyMaPHw+tVov27dsjIyMDbdq0gUKhwNixYzFy5Eix44nmn4Mq7NmRJHaMKoNFKiKiPKL/5jt79ixq1aqFkJAQLF26FJ988gk6deqEt99+G//8888zj1coFLC3t9fbOPTPPKxa8h3OnzmBhAf3cfvGtbzbp4+jbYdXYWtXAx1e7YFlC77B2ZP/4fqVi/huVhQCghshgIUqIpOz9cwDBLrZoW8TT3gqFXi5bk28GuyK7efjAeQVqSa/Uhf1XGwxa+91SKUSONrI4Ggjg6WUVQYiMm0SiQSTJk1CUlISzp8/j6NHjyIxMRGff/652NFEdSe2wPQc/+uO6OtvBWsb0d+CmBxBEHD79m0WqYiIYAI9qhwdHbFx40ZMnDgRw4YNg6WlJf744w+0b99e7GgksuQnSZg7czKSHj+Cra0d/J6ri6mzFyK0Wd5Kf++OGAupVIpZU8YiJycboc1ewAdjJoicmoiKc/VhOqb9cRXvhPngraa1EJ+ixqJDsfjzat7iB862crzgn7fIxuK++sXmsb9cxNn7KZWemcyHhF2qqJLI5XIEBQWJHcPkvNbDGc1a2osdw6RJJBIEBwcjNjYWtWvXZpGKiKo1iSAIgtghvv/+e4wfPx49evTAiRMnYGFhgXXr1qFx48blPueVeC7jSmQO6rvboNOCo2LHICID2DO8pSiP++/NZIOfs3ltpcHPSVXXyy+//NRVrP/8889KTFN2KSkpUCqVSE5Ohr294QpKG9Yk4NL5dBaqnkKtVnM0CBFRIaL3qHrllVdw/PhxrFq1Cm+88QYyMzMRGRmJli1bYtq0afj000/FjkhEREREVKKQkBC92zk5OTh9+jTOnz+PiIgIcUKRyVOpVDh37hz8/f1Rq1YtseMQEZkM0QtVGo0GZ8+ehaenJwDA2toaixYtQpcuXfDuu++yUEVEREQVwoF/ZGzffvttse1Tp05FWlpaJaehqqDgxOlJSUnw8vJ6aq88IqLqRPTBz3v37tUVqQp67bXXcO7cORESERERERFV3FtvvYXly5eLHYNMTHGr+7FIRUT0/0TvUQUAN27cwNy5c3Hp0iUAQFBQEEaPHo3atWuLnIyIiIiqPL7/I5EcOXIEVlZWYscgE1JckYoTpxMR6RO9ULV7925069YNISEhePHFFwEAhw8fRlBQELZv346OHTuKnJCIiIiqMq76R8bWs2dPvduCIODBgwc4fvw4Jk+eLFIqMjUsUhERlY7oharx48djzJgxmDVrVpH2cePGsVBFRERERCZNqdRfBVIqlaJ+/fqYPn06OnXqJFIqMjUpKSksUhERlYLohapLly5h48aNRdrfeecdzJ07t/IDERERkVnh1C9kTBqNBoMHD0bDhg3h6OgodhwyYT4+PrCysoKzszOLVERETyH6b0gXFxecPn26SPvp06fh6upa+YGIiIjIrEiMsBHls7CwQKdOnaBSqcSOQiYoJSUFubm5utuurq4sUhERPYNovyWnT5+OjIwMDB06FO+99x6+/PJLHDx4EAcPHsSsWbMwbNgwDB06VKx4RERERESl0qBBA9y8edNg51uwYAH8/PxgZWWFFi1a4N9//y1x36VLl6J169ZwdHSEo6MjOnTo8NT9qfKoVCqcPn0a586dg0ajETsOEVGVIVqhatq0aUhLS8PkyZMxZcoUfP/992jbti3atm2L+fPnY+rUqfjss8/EikdERETmgl2qyMhmzJiBsWPH4vfff8eDBw+QkpKit5XFhg0bEBkZiaioKJw8eRKNGzdGeHg4Hj58WOz++/fvR79+/fDXX3/hyJEj8Pb2RqdOnXDv3j1DfGtUTgUnTrewsICEY5CJiEpNIgiCIMYDS6VSxMfH6w3vS01NBQDUqFGjwue/Ep9R4XMQkfjqu9ug04KjYscgIgPYM7ylKI97KjbV4OcM9a34tQpVfdOnT8fHH3+sd+1asCAhCAIkEkmZetO0aNECzZo1w/z58wEAWq0W3t7eGDlyJMaPH//M4zUaDRwdHTF//nwMHDiwVI+ZkpICpVKJ5ORk2Nvblzrrs2xYk4BL59PxWg9nNGtpuPOaOq7uR0RUMaJOpl74kwVDFKiIiIiIiCrDtGnT8P777+Ovv/4yyPmys7Nx4sQJTJgwQdcmlUrRoUMHHDlypFTnyMjIQE5ODpycnErcR61WQ61W626XtdcXlYxFKiKiihO1UFWvXr1ndoNNSkqqpDRERERkjjjihowlf2BC27ZtDXK+R48eQaPRwM3NTa/dzc0Nly9fLtU5xo0bB09PT3To0KHEfaKjozFt2rQKZaWiWKQiIjIMUQtV06ZNg1KpFDMCEREREVG5mdLcQ7NmzcL69euxf/9+WFlZlbjfhAkTEBkZqbudkpICb2/vyoho1iwtLWFhYQEHBwcWqYiIKkDUQlXfvn315qgiIiIiMjTTKSOQOTLkCAFnZ2dYWFggISFBrz0hIQHu7u5PPfbrr7/GrFmzsG/fPjRq1Oip+yoUCigUilJlotKzs7NDaGgorKysWKQiIqoA0QpVpvTpExEREZkxXnKQERlyhIBcLkeTJk0QExODHj16AMibTD0mJgYjRowo8bivvvoKX3zxBXbv3o2mTZsaJAuVjkqlAgA4ODgAAGxsbMQLQ0RkJkQrVIm02CARERERkcEYeoRAZGQkIiIi0LRpUzRv3hxz585Feno6Bg8eDAAYOHAgvLy8EB0dDQD48ssvMWXKFKxbtw5+fn6Ij48HkNe7x87OzmC5qKj8OakAIDQ0lAtDEREZiGiFKq1WK9ZDExERUTUiYZcqMhJjjBDo06cPEhMTMWXKFMTHxyMkJAS7du3STbAeFxenN6xs0aJFyM7OxhtvvKF3nqioKEydOtXg+ShP4YnTbW1txY5ERGQ2RJ2jioiIiMjYONsAGYuxRgiMGDGixKF++/fv17t9+/Zto2SgknF1PyIi42KhioiIiIioHDhCoPphkYqIyPhYqCIiIiKzxg5VRGQIaWlpLFIREVUCFqqIiIjIvLFSRVRpHj/KQVqaBgCQka4ROY1h2djYwMnJCVqtlkUqIiIjYqGKiIiIiIgq7O6dLPy44H6RdnOZJ04qlSIoKEj3NRERGQcLVURERGTWuOofUeV4kpQLALC0lMDeIe9thq2tFHXqWYsZq0JUKhUeP36M2rVrQyKRsEBFRFQJWKgiIiIiIiKDqeWjwKD3PMWOUWEFJ063srKCl5eX2JGIiKoFFqqIiIjIrJnLsCMiqjyFV/fz8PAQOxIRUbXBQhURERGZNdapiMovWZWLNSseIC312ROj5+YKlZDI+AoXqThxOhFR5WKhioiIiIiIihV7KxOJCTllOsbNQ26kNMbHIhURkfhYqCIiIiLzJmKXqkWLFmHRokW4ffs2ACA4OBhTpkxB586dAQBZWVn4+OOPsX79eqjVaoSHh2PhwoVwc3MTLzRRMWr5KND9DZdn7ieVSuBUs2q+xcjJycG5c+dYpCIiElnV/CtCREREVEpirvpXq1YtzJo1C3Xr1oUgCFi1ahW6d++OU6dOITg4GGPGjMGOHTuwadMmKJVKjBgxAj179sThw4dFy0xUHLlCChfXqttTqjRkMhnq16+PhIQEBAcHs0hFRCQSFqqIiIiIjKRr1656t7/44gssWrQIR48eRa1atbBs2TKsW7cO7dq1AwCsWLECgYGBOHr0KFq2bClGZKJqRxAESP636oKrqytcXFx0t4mIqPLxYwIiIiIyaxKJ4Te1Wo2UlBS9Ta1WPzWHRqPB+vXrkZ6ejrCwMJw4cQI5OTno0KGDbp+AgAD4+PjgyJEjxn5aiAh5c1KdOHFC7/XLIhURkbhYqCIiIiIqo+joaCiVSr0tOjq62H3PnTsHOzs7KBQKvP/++/jll18QFBSE+Ph4yOVyODg46O3v5uaG+Pj4SvguiKq3/InT09LSEBsbK3YcIiL6Hw79IyIiIrNmjL4REyZMQGRkpF6bQqEodt/69evj9OnTSE5OxubNmxEREYEDBw4YIRURlVbh1f3q1KkjdiQiIvofFqqIiIjIvBmhUqVQKEosTBUml8t1b4KbNGmC//77D/PmzUOfPn2QnZ0NlUql16sqISEB7u7uhg9NRACKFqm4uh8RkWnhb2QiIiKiSqTVaqFWq9GkSRPIZDLExMTo7rty5Qri4uIQFhYmYkIi88UiFRGR6WOPKiIiIjJrEqMM/iudCRMmoHPnzvDx8UFqairWrVuH/fv3Y/fu3VAqlRgyZAgiIyPh5OQEe3t7jBw5EmFhYVzxj8gIBEHAjRs3WKQiIjJxLFQRERGRWRNzAa+HDx9i4MCBePDgAZRKJRo1aoTdu3ej4/+1d99hUVzt38C/u8DSpFpooiJIU8QWjfgYGxETNdhLFCGxxIIldtQImthiN2KJBdTH7qOmWBALUVFRUSwRsYuJoDEIKp3d8/7hj3ldKQLShO8n11xXdubMmXuOs4V7zjnz6acAgKVLl0Iul6Nnz55IT0+Hh4cHVq1aVXYBE1VgMpkMDRo0wMOHD2FnZ8ckFRFROcVEFREREVEJ2bBhQ77bdXR0EBgYiMDAwFKKiKjyyczMhJaWFoDX88vZ29uXcURERJQf3kYgIiKiCk1WAgsRfRgSExNx7tw5PHnypKxDISKiAmKiioiIiCo2ZqqIKqXsidOVSiWePHkCIURZh0RERAXARBUREREREVUouT3dT1aWE9YREVGBcY4qIiIiqtDK8ql/RFT6cktSceL0ikepVCIzM7OswyCqdBQKRYl/pjJRRUREREREFQKTVBWfEALx8fFITEws61CIKiW5XA4bGxsoFIoSOwYTVURERFShcbQPUeWRkJDAJFUFl52kqlGjBvT09Dikk6gUqVQqPH78GHFxcahVq1aJvf+YqCIiIqIKjX/CEFUeNjY20NXVhZmZGZNUFZBSqZSSVFWrVi3rcIgqperVq+Px48fIysqClpZWiRyDn95ERERERPTBevnyJVQqFQBAJpPBwsKCSaoKKntOKj09vTKOhKjyyh7yp1QqS+wY7FFFREREFRu7VBEVytMnGfj7UToA4FFsWhlHk7/sOamMjY051K8S4XA/orJTGu8/JqqIiIioQuNT/4gKTqUS2LjmMdJSVWrrNTTK3/vozYnTiYio4uAtByIiIiIiAgCoVJCSVHXr6aKegy4cnPXQ6hOjMo5MHZ/uR1Q+PHjwADKZDFFRUQCAsLAwyGSyUnkq47///osaNWrgwYMHJX6symLq1KkYPXp0WYfBRBURERFVbDJZ8S9ElUGfAWYY8JUF+g8yR526umUdjoRJKvrQ+Pj4oFu3bnlur1OnDmQyGWQyGfT09ODi4oL169e/s94399PQ0IClpSUGDx6M58+fF2P0hePm5oa4uDgYGZV8cnvOnDnw9PREnTp1cmzz8PCAhoYGLly4kGNb27ZtMW7cuBzrg4ODYWxsrLbuxYsXmD59OhwdHaGjowNzc3O4u7tj7969EEIU05nkFBYWhiZNmkBbWxt2dnYIDg5+5z4hISH4+OOPYWBggOrVq6Nnz55qSby4uDh8+eWXsLe3h1wuz7UNJk6ciE2bNuHevXvFdzJFwE90IiIiqtBkJbAQUdlgkooqqtmzZyMuLg7Xr1/HwIEDMXToUBw6dKjA+8XGxmLr1q04efIkxowZUwoR506hUMDc3LzE5zFKSUnBhg0bMHjw4BzbYmNjcebMGfj6+mLjxo1FPkZiYiLc3NywefNm+Pn54dKlSzh58iT69u2LyZMnIykp6X1OIU/3799H586d0a5dO0RFRWHcuHEYMmQIQkJC8t3H09MT7du3R1RUFEJCQvDs2TP06NFDKpOeno7q1atjxowZcHV1zbWeatWqwcPDA6tXry728yoMfqoTEREREdEHIbv3CJNUlE0IgYwMVakvxd2bxsDAAObm5qhbty6mTJkCU1NThIaGFng/KysrtGvXDt7e3rh06ZK0/d9//0X//v1hZWUl9dbavn27Wh179uyBi4sLdHV1UbVqVbi7uyM5OVnavn79ejg5OUFHRweOjo5YtWpVnvG8PfQvu5dSSEgInJycUKVKFXTq1AlxcXFq+xXmGABw8OBBaGtr4+OPP86xLSgoCF26dMGIESOwfft2pKam5ltXXqZNm4YHDx4gIiIC3t7ecHZ2hr29PYYOHYqoqChUqVKlSPW+y5o1a2BjY4PFixfDyckJvr6+6NWrF5YuXZrnPpGRkVAqlfjhhx9ga2uLJk2aYOLEiYiKipKellmnTh0sX74cgwYNyrfHW9euXbFjx45iP6/C4GTqREREVKFxqB5RxWFkZITGjRtDT0+PSSoCAGRmCsyd+aDUjzttdh0oFMX/BaNSqbBv3z48f/4cCoWiUPv+/fff+O2339CiRQtpXVpaGpo2bYopU6bA0NAQBw4cgJeXF2xtbdG8eXPExcWhf//++PHHH9G9e3e8fPkSp06dkhJxW7duxcyZM7Fy5Uo0btwYly9fxtChQ6Gvrw9vb+8CxZWSkoJFixZhy5YtkMvlGDhwICZOnIitW7cW+RinTp1C06ZNc6wXQiAoKAiBgYFwdHSEnZ0d9uzZAy8vr0K1pUqlwo4dOzBgwABYWlrm2J5fkurUqVP47LPP8q1/7dq1GDBgQK7bzp49C3d3d7V1Hh4euQ7Vy9a0aVPI5XIEBQXBx8cHr169wpYtW+Du7g4tLa18Y3lb8+bN8ddff+HBgwe5DqssDUxUERERERFRuZWYmAgNDQ0YGBgAyP8PRKIP1ZQpUzBjxgykp6cjKysLpqamGDJkSIH3UyqVSEtLQ4sWLbBkyRJpu5WVFSZOnCi9Hj16NEJCQrBr1y4pUZWVlYUePXqgdu3aAAAXFxepvL+/PxYvXiwNIbOxscGNGzewdu3aAieqMjMzsWbNGtja2gIAfH19MXv27Pc6xsOHD3NNIB09ehQpKSnw8PAAAAwcOBAbNmwodKLq2bNneP78ORwdHQu1HwA0a9ZMmlw+L2ZmZnlui4+Pz7HdzMwML168QGpqKnR1c84ZaGNjgyNHjqBPnz745ptvoFQq0bJlSxw8eLDQ8We368OHD5moIiIiIioZ7FJF9KHKnpNKLpejcePG0NfXL+uQqJzR0pJh2uw6ZXLc4jRp0iT4+PggLi4OkyZNwsiRI2FnZ1fg/YQQePToEaZNm4bOnTvj5MmT0NDQgFKpxNy5c7Fr1y78/fffyMjIQHp6OvT09AAArq6u6NChA1xcXODh4YGOHTuiV69eMDExQXJyMu7evYvBgwdj6NCh0jGzsrIKNVm6np6elKQCAAsLCzx9+hQAinyM1NRU6Ojo5Fi/ceNG9O3bF5qar1Md/fv3x6RJk3D37l21GN7lfYZ26urqFujfrjjFx8dj6NCh8Pb2Rv/+/fHy5UvMnDkTvXr1QmhoaKHmDMtOhKWkpJRUuO/ERBURERFVaBz6R/RhenPidGNj41x7ERDJZLISGYJX2qpVqwY7OzvY2dlh9+7dcHFxQbNmzeDs7Fyg/QCgXr16WLZsGVq2bIkTJ07A3d0dCxcuxPLly7Fs2TK4uLhAX18f48aNQ0ZGBgBAQ0MDoaGhOHPmDI4cOYKffvoJ06dPR0REhJTMWrdundpwwuz9CurtoWcymUxKBL169apIx6hWrVqOpxsmJCRg3759yMzMVJsMXKlUYuPGjZgzZw4AwNDQMNeJ0BMTE6XkWPXq1WFsbIybN28W9DQl7zv0z9zcHE+ePFFb9+TJExgaGub5ORgYGAgjIyP8+OOP0rr//ve/sLa2RkRERK5zeeUlISEBwOs2KCtMVBERERERUbnCp/tRZWZtbY2+ffvCz88Pv/zyS6H2zU7uZE8gHh4eDk9PTwwcOBDA67mXbt26pZYAk8lkaNWqFVq1aoWZM2eidu3a2LdvH8aPHw9LS0vcu3cvz6TK+zIzMyvSMRo3boz//ve/auu2bt2KmjVrYv/+/Wrrjxw5gsWLF2P27NnQ0NCAg4MDjhw5kqPOS5cuwd7eHgAgl8vRr18/bNmyBf7+/jmGGb569Qo6OjpSz603ve/Qv9yG7IWGhqJly5Z57pOSkpLjMzL7WlCpVPnG8rbr169DS0sL9evXL9R+xYmJKiIiIqrQPvz77ESVC5NUVBElJSXlSF5UrVoV1tbWuZYfO3YsGjRogIsXL6JZs2Z51vvy5UvEx8dLQ/8mT56M6tWrw83NDcDrXlZ79uzBmTNnYGJigiVLluDJkydSoioiIgLHjh1Dx44dUaNGDUREROCff/6Bk5MTAGDWrFkYM2YMjIyM0KlTJ6Snp+PixYt4/vw5xo8fXwwtU7RjeHh4wM/PD8+fP4eJiQkAYMOGDejVqxcaNGigVtba2hp+fn44fPgwOnfujBEjRmDlypUYM2YMhgwZAm1tbRw4cADbt2/Hb7/9Ju03Z84chIWFoUWLFpgzZw6aNWsGLS0tnDp1CvPmzcOFCxdgbGycI7b3Hfo3fPhwrFy5EpMnT8bXX3+N48ePY9euXThw4IBUZuXKldi3bx+OHTsGAOjcuTOWLl2K2bNnS0P/pk2bhtq1a6Nx48bSftnX4KtXr/DPP/8gKioKCoVCLXF56tQptG7dukx7sfITn4iIiCo0maz4FyIqGS9fvmSSiiqksLAwNG7cWG2ZNWtWnuWdnZ3RsWNHzJw5M996Z86cCQsLC1haWqJLly7Q19fHkSNHULVqVQDAjBkz0KRJE3h4eKBt27YwNzdHt27dpP0NDQ1x8uRJfP7557C3t8eMGTOwePFiaejakCFDsH79egQFBcHFxQVt2rRBcHAwbGxs3r9R/k9RjuHi4oImTZpg165dAIDIyEhcuXIFPXv2zFHWyMgIHTp0wIYNGwAAdevWxcmTJ3Hz5k24u7ujRYsW2LVrF3bv3o1OnTpJ+5mamuLcuXMYOHAgfvjhBzRu3BitW7fG9u3bsXDhwkLN01UYNjY2OHDgAEJDQ+Hq6orFixdj/fr10gTxwOvJ3u/evSu9bt++PbZt24b9+/ejcePG6NSpE7S1tXH48GG1hFP2tRcZGYlt27ahcePG+Pzzz9WOv2PHDrX5wsqCTLzPLGHlWEx82U38RUTFx8FcDx0Dz5V1GERUDI6MKvj8CMUpLimj2Ou0MCrcI8OJyrMXL17AyMgISUlJ0NMzwA8z7gMApgbUgY5O6SaJlEolrl27BrlcziQV5ZCWlob79+/DxsYm14m0qXI5cOAAJk2ahOvXr/OzopgcOnQIEyZMwNWrV3Md1giUzvuQQ/+IiIioQpNx8B/RB0NDQwMuLi6QyWT8w5OI8tW5c2fcvn0bf//9d55DKKlwkpOTERQUlGeSqrQwUUVERERERGUmMTERSUlJqFWrFmQyWaGeJkZEldu4cePKOoQKpVevXmUdAgAmqoiIiKiiY4cqonLrzYnTtbW1YW5uXtYhERFRGWOiioiIiCo05qmIyqe3n+5Xo0aNsg6JiIjKAQ78JiIiIiKiUvV2kooTpxMRUTb2qCIiIqIKTcYuVUTlCpNURESUHyaqiIiIqELjU/+Iyo+MjAxcu3aNSSoiIsoTvxWIiIiIiKhUKBQK2NraMklFRER54jcDERERVWyyEliIqFCEENL/W1pawsXFhUkqolIik8mwf//+sg6DqMD47UBEREQVGvNURGUrMTERly9fRmZmprROxsnjqJLx8fGBTCaDTCaDlpYWbGxsMHnyZKSlpZV1aETlDueoIiIiIiKiEvHmxOkPHz6EnZ1dWYdEVGY6deqEoKAgZGZmIjIyEt7e3pDJZFiwYEFZh0ZUrrBHFREREVVoMlnxL0T0bm8/3a9u3bplHRJRmdLW1oa5uTmsra3RrVs3uLu7IzQ0FADw77//on///rCysoKenh5cXFywfft2tf3btm2LMWPGYPLkyTA1NYW5uTkCAgLUyty+fRuffPIJdHR04OzsLNX/pmvXrqF9+/bQ1dVF1apVMWzYMLx69Ura7uPjg27dumHu3LkwMzODsbExZs+ejaysLEyaNAmmpqaoWbMmgoKCir+RiMBEFRERERERFbO3k1ScOJ1KmlKpzHNRqVQFLqtUKt9Ztjhcv34dZ86cgUKhAACkpaWhadOmOHDgAK5fv45hw4bBy8sL58+fV9tv06ZN0NfXR0REBH788UfMnj1bSkapVCr06NEDCoUCERERWLNmDaZMmaK2f3JyMjw8PGBiYoILFy5g9+7dOHr0KHx9fdXKHT9+HI8fP8bJkyexZMkS+Pv7o0uXLjAxMUFERASGDx+Ob775Bn/99VextAfRmzj0j4iIiCo0GWeVIipVTFJRWTh16lSe20xNTdGwYUPpdXh4eI7kVTZjY2M0atRIen3u3Dm1+dWA1z2biuL3339HlSpVkJWVhfT0dMjlcqxcuRIAYGVlhYkTJ0plR48ejZCQEOzatQvNmzeX1jds2BD+/v4AgHr16mHlypU4duwYPv30Uxw9ehQ3b95ESEgILC0tAQBz587FZ599Ju2/bds2pKWlYfPmzdDX1wcArFy5El27dsWCBQtgZmYG4HWbrVixAnK5HA4ODvjxxx+RkpKCadOmAQD8/Pwwf/58nD59Gv369StSexDlhYkqIiIiqtA4VI+o9AghcOvWLSapiHLRrl07rF69GsnJyVi6dCk0NTXRs2dPAK97bs2dOxe7du3C33//jYyMDKSnp0NPT0+tjjcTbgBgYWGBp0+fAgCio6NhbW0tJakAoGXLlmrlo6Oj4erqKiWpAKBVq1ZQqVSIiYmRElX169dXe++amZmhQYMG0msNDQ1UrVpVOjZRcWKiioiIiIiIioVMJoOLiwsePnwIe3t7Jqmo1LRu3TrPbW8/ZbJVq1YFrvfjjz8uckxv09fXlx4osHHjRri6umLDhg0YPHgwFi5ciOXLl2PZsmVwcXGBvr4+xo0bh4yMDLU6tLS01F7LZLI8e4e9j9yOU1rHJuI3BxERERERvZesrCzp/3V1deHo6MgkFZUqDQ2NPJe3r8X8ympoaLyzbHGQy+WYNm0aZsyYgdTUVISHh8PT0xMDBw6Eq6sr6tati1u3bhWqTicnJzx69AhxcXHSunPnzuUoc+XKFSQnJ0vrwsPDpSF+ROUBvz2IiIioQuNT/4hKVmJiIs6dO4dnz56VdShEH5TevXtDQ0MDgYGBqFevHkJDQ3HmzBlER0fjm2++wZMnTwpVn7u7O+zt7eHt7Y0rV67g1KlTmD59ulqZAQMGQEdHB97e3rh+/TpOnDiB0aNHw8vLSxr2R1TWmKgiIiIiIqIiyZ44PSsrC3FxcRBClHVIRB8MTU1N+Pr64scff8SECRPQpEkTeHh4oG3btjA3N0e3bt0KVZ9cLse+ffuQmpqK5s2bY8iQIZgzZ45aGT09PYSEhCAhIQEfffQRevXqhQ4dOkiTuhOVBzJRQb9NYuJTyjoEIioGDuZ66Bh47t0FiajcOzKq+Ob5KIyk1OKfP8NIl/f6qOJ48eIFjIyMkJSUBD09A/ww4z4AYGpAHejo5H2t8+l+VNrS0tJw//592NjYQEdHp6zDIaqUSuN9yG8SIiIiIiIqFCapiIiopPCpf0RERFShcU4pouLFJBUREZUkJqqIiIioQmOeiqh4PX36lEkqIiIqMUxUERERERFRgdWrVw96enqwtLRkkoqIiIodv1mIiIioYpOVwFJA8+bNw0cffQQDAwPUqFED3bp1Q0xMjFqZtLQ0jBo1ClWrVkWVKlXQs2fPQj+SnKikvXr1Snqin0wmQ82aNZmkIiKiEsFvFyIiIqrQZCXwX0H98ccfGDVqFM6dO4fQ0FBkZmaiY8eOSE5Olsp8++23+O2337B792788ccfePz4MXr06FESTUFUJImJibh06RKio6NRQR8YTh8YXodEZac03n9MVBERERGVkMOHD8PHxwf169eHq6srgoODERsbi8jISABAUlISNmzYgCVLlqB9+/Zo2rQpgoKCcObMGZw7d66Mo6eyEhgYiDp16kBHRwctWrTA+fPn8y2/e/duODo6QkdHBy4uLjh48GCxxfLmxOlZWVlMEFCZ0tLSAgCkpKSUcSRElVdGRgYAQENDo8SOwTmqiIiIqEIrT0/9S0pKAgCYmpoCACIjI5GZmQl3d3epjKOjI2rVqoWzZ8/i448/LpM4qezs3LkT48ePx5o1a9CiRQssW7YMHh4eiImJQY0aNXKUP3PmDPr374958+ahS5cu2LZtG7p164ZLly6hQYMG7xVLUlIiYmKuc+J0Kjc0NDRgbGyMp0+fAgD09PQgK08f8kQVnEqlwj///AM9PT1oapZcOomJKiIiIqrQSuJPmPT0dKSnp6ut09bWhra2dp77qFQqjBs3Dq1atZISCPHx8VAoFDA2NlYra2Zmhvj4+GKPm8q/JUuWYOjQofjqq68AAGvWrMGBAwewceNGTJ06NUf55cuXo1OnTpg0aRIA4Pvvv0doaChWrlyJNWvWFD0Q2Sv8+ecjyOWCSSoqV8zNzQFASlYRUemSy+WoVatWiSaJmagiIiIiKqR58+Zh1qxZauv8/f0REBCQ5z6jRo3C9evXcfr06RKOjj5UGRkZiIyMhJ+fn7ROLpfD3d0dZ8+ezXWfs2fPYvz48WrrPDw8sH///qIHInsFaNyHSmWIatWqMklF5YpMJoOFhQVq1KiBzMzMsg6HqNJRKBQl/p3ARBURERFVbCVww8/Pzy9HciC/3lS+vr74/fffcfLkSdSsWVNab25ujoyMDCQmJqr1qnry5InUa4Aqj2fPnkGpVMLMzExtvZmZGW7evJnrPvHx8bmWz69H3ts9Al+8ePFWCRUAARMTEyapqNzS0NAo0TlyiKjs8FuHiIiIqJC0tbVhaGiotuSWqBJCwNfXF/v27cPx48dhY2Ojtr1p06bQ0tLCsWPHpHUxMTGIjY1Fy5YtS/w8qHKaN28ejIyMpMXa2lptu4VlNdSo7gRnZyapiIio9LFHFREREVVoshKZpapgRo0ahW3btuGXX36BgYGB1MvFyMgIurq6MDIywuDBgzF+/HiYmprC0NAQo0ePRsuWLTmReiVUrVo1aGho4MmTJ2rr8+thZ25uXqjyQM4egS9evJCSVZqaMnwzumZeuxIREZU43iIhIiKiCk0mK/6loFavXo2kpCS0bdsWFhYW0rJz506pzNKlS9GlSxf07NkTn3zyCczNzbF3794SaAkq7xQKBZo2barWw06lUuHYsWN59rBr2bKlWnkACA0NzbdHXm49AomIiMoL9qgiIiIiKiFCiHeW0dHRQWBgIAIDA0shIirvxo8fD29vbzRr1gzNmzfHsmXLkJycLD0FcNCgQbCyssK8efMAAGPHjkWbNm2wePFidO7cGTt27MDFixfx888/F/iY2ddpzrmqiIiICs/AwOC9ngpYYRNVDuZ6ZR0ClaD09HTMmzcPfn5++U5eSxXDkVEc/lKR8f1MJU2nwv7aoYqob9+++OeffzBz5kzEx8ejUaNGOHz4sDRhemxsrNq8UW5ubti2bRtmzJiBadOmoV69eti/fz8aNGhQ4GO+fPkSAHLMVUVERFQUSUlJ79VbVyYKcquPqJx58eIFjIyM3vsNQERlj+9nIqKypVKp8PjxY+kOePacVY8ePeLnciGx7d4P26/o2HZFx7Yrurzajj2qiIiIiIioyORyOWrWzDmBOuevKjq23fth+xUd267o2HZFV9xtx8nUiYiIiIiIiIioXGCiioiIiIiIiIiIygUmquiDpK2tDX9/f068TFQB8P1MRFS+8HO56Nh274ftV3Rsu6Jj2xVdSbUdJ1MnIiIiIiIiIqJygT2qiIiIiIiIiIioXGCiioiIiIiIiIiIygUmqqjS8fHxQbdu3co6DCLKRVhYGGQyGRITE8s6FCIiIiIiKgNMVNF78fHxgUwmw/z589XW79+/HzKZ7L3qDggIQKNGjd6rjtwsX74cwcHBxV4vUWUhk8nyXQICAopct5ubG+Li4mBkZFR8ARMRUQ6BgYGoU6cOdHR00KJFC5w/fz7f8rt374ajoyN0dHTg4uKCgwcPllKk5U9h2m7dunVo3bo1TExMYGJiAnd393e2dUVX2Gsv244dOyCTySr1DefCtl1iYiJGjRoFCwsLaGtrw97evtK+dwvbdsuWLYODgwN0dXVhbW2Nb7/9FmlpaaUUbflx8uRJdO3aFZaWlpDJZNi/f/879wkLC0OTJk2gra0NOzu7Iv3tzUQVvTcdHR0sWLAAz58/L+tQCsTIyAjGxsZlHQbRBysuLk5ali1bBkNDQ7V1EydOLHLdCoUC5ubm753oJiKivO3cuRPjx4+Hv78/Ll26BFdXV3h4eODp06e5lj9z5gz69++PwYMH4/Lly+jWrRu6deuG69evl3LkZa+wbRcWFob+/fvjxIkTOHv2LKytrdGxY0f8/fffpRx5+VDY9sv24MEDTJw4Ea1bty6lSMufwrZdRkYGPv30Uzx48AB79uxBTEwM1q1bBysrq1KOvOwVtu22bduGqVOnwt/fH9HR0diwYQN27tyJadOmlXLkZS85ORmurq4IDAwsUPn79++jc+fOaNeuHaKiojBu3DgMGTIEISEhhTuwIHoP3t7eokuXLsLR0VFMmjRJWr9v3z7x9uW1Z88e4ezsLBQKhahdu7ZYtGhRnvUGBQUJAGpLUFCQEEKIhw8fii+++ELo6+sLAwMD0bt3bxEfHy+EECI6Olro6uqKrVu3SnXt3LlT6OjoiD///FOK2dPTU9quVCrFggULhK2trVAoFMLa2lr88MMP0varV6+Kdu3aCR0dHWFqaiqGDh0qXr58WeQ2I6pIgoKChJGRkfRaqVSKWbNmCSsrK6FQKISrq6s4dOiQEEIIlUolOnToIDp27ChUKpUQQoh///1XWFlZie+++04IIcSJEycEAPH8+XOpztOnT4s2bdoIXV1dYWxsLDp27CgSEhKEEEKkpaWJ0aNHi+rVqwttbW3RqlUrcf78+dI5eSKiD1Tz5s3FqFGjpNdKpVJYWlqKefPm5Vq+T58+onPnzmrrWrRoIb755psSjbM8KmzbvS0rK0sYGBiITZs2lVSI5VpR2i8rK0u4ubmJ9evX5/gdX5kUtu1Wr14t6tatKzIyMkorxHKrsG03atQo0b59e7V148ePF61atSrROMs7AGLfvn35lpk8ebKoX7++2rq+ffsKDw+PQh2LParovWloaGDu3Ln46aef8Ndff+VaJjIyEn369EG/fv1w7do1BAQE4LvvvsuzG2Dfvn0xYcIE1K9fX+ql0bdvX6hUKnh6eiIhIQF//PEHQkNDce/ePfTt2xcA4OjoiEWLFmHkyJGIjY3FX3/9heHDh2PBggVwdnbO9Vh+fn6YP38+vvvuO9y4cQPbtm2DmZkZgNcZZA8PD5iYmODChQvYvXs3jh49Cl9f3/dvOKIKaPny5Vi8eDEWLVqEq1evwsPDA1988QVu374NmUyGTZs24cKFC1ixYgUAYPjw4bCyssLMmTNzrS8qKgodOnSAs7Mzzp49i9OnT6Nr165QKpUAgMmTJ+N///sfNm3ahEuXLsHOzg4eHh5ISEgotXMmIvqQZGRkIDIyEu7u7tI6uVwOd3d3nD17Ntd9zp49q1YeADw8PPIsX1EVpe3elpKSgszMTJiampZUmOVWUdtv9uzZqFGjBgYPHlwaYZZLRWm7X3/9FS1btsSoUaNgZmaGBg0aYO7cudJvqMqiKG3n5uaGyMhIaXjgvXv3cPDgQXz++eelEvOHrLi+LzSLMyiqvLp3745GjRrB398fGzZsyLF9yZIl6NChA7777jsAgL29PW7cuIGFCxfCx8cnR3ldXV1UqVIFmpqaMDc3l9aHhobi2rVruH//PqytrQEAmzdvRv369XHhwgV89NFHGDlyJA4ePIiBAwdCoVDgo48+wujRo3ON++XLl1i+fDlWrlwJb29vAICtrS3+85//AHjd7TMtLQ2bN2+Gvr4+AGDlypXo2rUrFixYICW0iOi1RYsWYcqUKejXrx8AYMGCBThx4gSWLVuGwMBAWFlZYe3atRg0aBDi4+Nx8OBBXL58GZqauX8d/fjjj2jWrBlWrVolratfvz6A14nk1atXIzg4GJ999hmA13OBhIaGYsOGDZg0aVIJny0R0Yfn2bNnUCqVOX7DmJmZ4ebNm7nuEx8fn2v5+Pj4EouzPCpK271typQpsLS0zPGHXGVQlPY7ffo0NmzYgKioqFKIsPwqStvdu3cPx48fx4ABA3Dw4EHcuXMHI0eORGZmJvz9/Usj7HKhKG335Zdf4tmzZ/jPf/4DIQSysrIwfPjwSjn0r7Dy+r548eIFUlNToaurW6B62KOKis2CBQuwadMmREdH59gWHR2NVq1aqa1r1aoVbt++XaisfnR0NKytraUkFQA4OzvD2NhY7bgbN27E1atXcenSJQQHB+c53010dDTS09PRoUOHPLe7urpKSarsuFUqFWJiYgocN1Fl8OLFCzx+/DjX9/qb78/evXuje/fumD9/PhYtWoR69erlWWd2j6rc3L17F5mZmWrH09LSQvPmzXP9HCIiIipL8+fPx44dO7Bv3z7o6OiUdTjl3suXL+Hl5YV169ahWrVqZR3OB0elUqFGjRr4+eef0bRpU/Tt2xfTp0/HmjVryjq0ci8sLAxz587FqlWrcOnSJezduxcHDhzA999/X9ahVRrsUUXF5pNPPoGHhwf8/Pxy7SVVmq5cuYLk5GTI5XLExcXBwsIi13IFzegSUfFJSUlBZGQkNDQ0cPv27XzL8j1KRFS8qlWrBg0NDTx58kRt/ZMnT9R6sb/J3Ny8UOUrqqK0XbZFixZh/vz5OHr0KBo2bFiSYZZbhW2/u3fv4sGDB+jatau0TqVSAQA0NTURExMDW1vbkg26nCjKtWdhYQEtLS1oaGhI65ycnBAfH4+MjAwoFIoSjbm8KErbfffdd/Dy8sKQIUMAAC4uLkhOTsawYcMwffp0yOXs75OXvL4vDA0NC/W7ni1MxWr+/Pn47bffcoxBdXJyQnh4uNq68PBw2Nvbq314vkmhUOTobeXk5IRHjx7h0aNH0robN24gMTFRmoMqISEBPj4+mD59Onx8fDBgwACkpqbmeox69epBV1cXx44dy3W7k5OTlPR6M265XA4HB4c8WoGocjI0NISlpWWu7/U354ibMGEC5HI5Dh06hBUrVuD48eN51tmwYcM835+2trZQKBRqx8vMzMSFCxfynJOOiKiyUygUaNq0qdpnq0qlwrFjx9CyZctc92nZsmWOz+LQ0NA8y1dURWk74PUw9u+//x6HDx9Gs2bNSiPUcqmw7efo6Ihr164hKipKWr744gvpaWJvjrCo6Ipy7bVq1Qp37tyRknsAcOvWLVhYWFSaJBVQtLZLSUnJkYzK/pv19ZzilJdi+74o3DzvROpye/KGl5eX0NHRUXvqX2RkpJDL5WL27NkiJiZGBAcHC11dXelJfrnZunWr0NfXF5cvXxb//POPSEtLEyqVSjRq1Ei0bt1aREZGioiICNG0aVPRpk0bab/evXuLFi1aiMzMTPHq1StRr149MXLkyDxjDggIECYmJmLTpk3izp074uzZs2L9+vVCCCGSk5OFhYWF6Nmzp7h27Zo4fvy4qFu3rvD29n6fZiOqMN5+6t/SpUuFoaGh2LFjh7h586aYMmWK0NLSErdu3RJCCPH7778LhUIhIiMjhRBC+Pn5iZo1a0pP8Xv7qX8xMTFCoVCIESNGiCtXrojo6GixatUq8c8//wghhBg7dqywtLQUhw4dEn/++afw9vYWJiYmUn1ERJTTjh07hLa2tggODhY3btwQw4YNE8bGxtJTlL28vMTUqVOl8uHh4UJTU1MsWrRIREdHC39/f6GlpSWuXbtWVqdQZgrbdvPnzxcKhULs2bNHxMXFSUtlfYJ0YdvvbZX5qX+FbbvY2FhhYGAgfH19RUxMjPj9999FjRo11J5uXlkUtu38/f2FgYGB2L59u7h37544cuSIsLW1FX369CmrUygzL1++FJcvXxaXL18WAMSSJUvE5cuXxcOHD4UQQkydOlV4eXlJ5e/duyf09PTEpEmTRHR0tAgMDBQaGhri8OHDhTouE1X0XnL7srh//75QKBTi7Tzonj17hLOzs9DS0hK1atUSCxcuzLfutLQ00bNnT2FsbCwASEmthw8fii+++ELo6+sLAwMD0bt3b+lDZtOmTUJfX1/6o1gIISIiIoSWlpY4ePBgrjErlUrxww8/iNq1a0uxzZ07V9p+9epV0a5dO6GjoyNMTU3F0KFDK+2PC6K3vZ2oUiqVIiAgQFhZWQktLS3h6uoqDh06JIQQ4unTp8LMzEzt/ZWRkSGaNm0qffG/nagSQoiwsDDh5uYmtLW1hbGxsfDw8JC2p6amitGjR4tq1aoJbW1t0apVK3H+/PkSP28iog/dTz/9JGrVqiUUCoVo3ry5OHfunLStTZs2OW7K7dq1S9jb2wuFQiHq168vDhw4UMoRlx+FabvatWsLADkWf3//0g+8nCjstfemypyoEqLwbXfmzBnRokULoa2tLerWrSvmzJkjsrKySjnq8qEwbZeZmSkCAgKEra2t0NHREdbW1mLkyJFqv08ri+zf5m8v2e3l7e2t1mkke59GjRoJhUIh6tatm2/nlLzIhGDfNSIiIiIiIiIiKnuco4qIiIiIiIiIiMoFJqqIiIiIiIiIiKhcYKKKiIiIiIiIiIjKBSaqiIiIiIiIiIioXGCiioiIiIiIiIiIygUmqoiIiIiIiIiIqFxgooqIiIiIiIiIiMoFJqqIiIiIiIiIiKhcYKKKiMolHx8fdOvWTXrdtm1bjBs3rkD7hoWFQSaTITExsURiIyIiIiIiopLBRBURFYqPjw9kMhlkMhkUCgXs7Owwe/ZsZGVllehx9+7di++//75Ej0FERERU0oKDg2FsbFzWYRSZTCbD/v378y3z9g3HyuS7777DsGHDSuVYBb05W6dOHSxbtqxEYynsMYrrfVCQ67Gwbty4gZo1ayI5OblY66WCY6KKiAqtU6dOiIuLw+3btzFhwgQEBARg4cKFOcplZGQU2zFNTU1hYGBQbPURERERFdWbN+7eXO7cuVPWoSE4OFiKRy6Xo2bNmvjqq6/w9OnTYqk/Li4On332GQDgwYMHkMlkiIqKUiuzfPlyBAcHF8vx8hIQECCdp4aGBqytrTFs2DAkJCQUqp7iTKrFx8dj+fLlmD59ulr9JXWT183NDXFxcTAyMgKQd/LnwoULpZY8+xDMmTMHbm5u0NPTy7W9nJ2d8fHHH2PJkiWlHxwBYKKKiIpAW1sb5ubmqF27NkaMGAF3d3f8+uuv0hf9nDlzYGlpCQcHBwDAo0eP0KdPHxgbG8PU1BSenp548OCBVJ9SqcT48eNhbGyMqlWrYvLkyRBCqB3z7aF/6enpmDJlCqytraGtrQ07Ozts2LBBbZ/IyEg0a9YMenp6cHNzQ0xMjNr21atXw9bWFgqFAg4ODtiyZUvxNhQRERFVWNk37t5cbGxsyjosAIChoSHi4uLw119/Yd26dTh06BC8vLyKpW5zc3Noa2vnW8bIyKhUeo3Vr18fcXFxiI2NRVBQEA4fPowRI0aU+HHzsn79eri5uaF27dpq6wt6k7ewFAoFzM3NIZPJ8i1XvXp16OnpvffxKoqMjAz07t0732vlq6++wurVq0t81AjljokqInpvurq6Uu+pY8eOISYmBqGhofj999+RmZkJDw8PGBgY4NSpUwgPD0eVKlXQqVMnaZ/FixcjODgYGzduxOnTp5GQkIB9+/ble8xBgwZh+/btWLFiBaKjo7F27VpUqVJFrcz06dOxePFiXLx4EZqamvj666+lbfv27cPYsWMxYcIEXL9+Hd988w2++uornDhxophbh4iIiCqi7Bt3by4aGhpYsmQJXFxcoK+vD2tra4wcORKvXr3Ks54rV66gXbt2MDAwgKGhIZo2bYqLFy9K20+fPo3WrVtDV1cX1tbWGDNmzDuHJMlkMpibm8PS0hKfffYZxowZg6NHjyI1NRUqlQqzZ89GzZo1oa2tjUaNGuHw4cPSvhkZGfD19YWFhQV0dHRQu3ZtzJs3T63u7KFW2Ym5xo0bQyaToW3btgDUeyn9/PPPsLS0hEqlUovR09NT7bfZL7/8giZNmkBHRwd169bFrFmz3pkk0NTUhLm5OaysrODu7o7evXsjNDRU2q5UKjF48GDY2NhAV1cXDg4OWL58ubQ9ICAAmzZtwi+//CL1egoLCwPw7hutudmxYwe6du2aY31eN3kB4Pnz5xg0aBBMTEygp6eHzz77DLdv35b2ffjwIbp27QoTExPo6+ujfv36OHjwIAD1oX9hYWH46quvkJSUJJ1LQEAAAPVheV9++SX69u2rFl9mZiaqVauGzZs3AwBUKhXmzZsntZurqyv27NmT77m/raDvg/3796NevXrQ0dGBh4cHHj16pLa9KNfFu8yaNQvffvstXFxc8izz6aefIiEhAX/88cd7HYuKhokqIioyIQSOHj2KkJAQtG/fHgCgr6+P9evXo379+qhfvz527twJlUqF9evXw8XFBU5OTggKCkJsbKz0Q2DZsmXw8/NDjx494OTkhDVr1khdmHNz69Yt7Nq1Cxs3bkT37t1Rt25ddOjQIceX7pw5c9CmTRs4Oztj6tSpOHPmDNLS0gAAixYtgo+PD0aOHAl7e3uMHz8ePXr0wKJFi0qmsYiIiKhSkMvlWLFiBf78809s2rQJx48fx+TJk/MsP2DAANSsWRMXLlxAZGQkpk6dCi0tLQDA3bt30alTJ/Ts2RNXr17Fzp07cfr0afj6+hYqJl1dXahUKmRlZWH58uVYvHgxFi1ahKtXr8LDwwNffPGFlBxZsWIFfv31V+zatQsxMTHYunUr6tSpk2u958+fBwAcPXoUcXFx2Lt3b44yvXv3xr///qt2MzAhIQGHDx/GgAEDAACnTp3CoEGDMHbsWNy4cQNr165FcHAw5syZU+BzfPDgAUJCQqBQKKR1KpUKNWvWxO7du3Hjxg3MnDkT06ZNw65duwAAEydORJ8+fdR6x7m5uRXoRuvbEhIScOPGDTRr1uydsb55k9fHxwcXL17Er7/+irNnz0IIgc8//xyZmZkAgFGjRiE9PR0nT57EtWvXsGDBghw3Z4HXwwCXLVsm9aaLi4vDxIkTc5QbMGAAfvvtN7WkUUhICFJSUtC9e3cAwLx587B582asWbMGf/75J7799lsMHDiwUEmbgrwPUlJSMGfOHGzevBnh4eFITExEv379pO1FuS7atm0LHx+fAseZF4VCgUaNGuHUqVPvXRcVgSAiKgRvb2+hoaEh9PX1hUKhEJqammLQoEHi1atXwtvbW7i7u6uVnzhxolT+zUUmk4lVq1aJxMREAUD88ccfavt169ZNeHp6Sq/btGkjxo4dK4QQYufOnUJDQ0NkZGTkGuOJEycEAPH06VNp3aVLlwQA8fDhQyGEECYmJiI4OFhtv2XLlgkbG5uiNg0RERFVEm/+HspeevXqlWvZ3bt3i6pVq0qvg4KChJGRkfTawMAgx2+SbIMHDxbDhg1TW3fq1Ckhl8tFampqrvu8Xf+tW7eEvb29aNasmRBCCEtLSzFnzhy1fT766CMxcuRIIYQQo0ePFu3btxcqlSrX+gGIffv2CSGEuH//vgAgLl++rFbG29tb7Xecp6en+Prrr6XXa9euFZaWlkKpVAohhOjQoYOYO3euWh1btmwRFhYWucYghBD+/v5CLpcLfX19oaOjIwAIAGLJkiV57iOEEKNGjRI9e/bMM9bsYzs4OKi1QXp6utDV1RUhISG51nv58mUBQMTGxqqtf7N+lUolQkNDhba2tpg4caK4deuWACDCw8Ol8s+ePRO6urpi165dQgghXFxcREBAQK7HzP7N+/z5cyFEzn/7bLVr1xZLly4VQgiRmZkpqlWrJjZv3ixt79+/v+jbt68QQoi0tDShp6cnzpw5o1bH4MGDRf/+/XON4+1j5Ca39wEAce7cOWlddHS0ACAiIiKEEAW7Lt68HoUQwsvLS0ydOjXPON6UV3tl6969u/Dx8SlQXVS8NMskO0ZEH7R27dph9erVUCgUsLS0hKbm//8o0dfXVyv76tUrNG3aFFu3bs1RT/Xq1Yt0fF1d3QKVy74bCUAau/92t3MiIiKiosj+PZQt+zfQ0aNHMW/ePNy8eRMvXrxAVlYW0tLSkJKSkus8QePHj8eQIUOwZcsWafiara0tgNfDAq9evar2O0oIAZVKhfv378PJySnX2JKSklClShWoVCqkpaXhP//5D9avX48XL17g8ePHaNWqlVr5Vq1a4cqVKwBe9/D59NNP4eDggE6dOqFLly7o2LHje7XVgAEDMHToUKxatQra2trYunUr+vXrB7lcLp1neHi4Wk8ZpVKZb7sBgIODA3799VekpaXhv//9L6KiojB69Gi1MoGBgdi4cSNiY2ORmpqKjIwMNGrUKN94r1y5gjt37uR4kE9aWhru3r2b6z6pqakAAB0dnRzbfv/9d1SpUgWZmZlQqVT48ssvERAQgGPHjkFTUxMtWrSQylatWhUODg6Ijo4GAIwZMwYjRozAkSNH4O7ujp49e6Jhw4b5xp8fTU1N9OnTB1u3boWXlxeSk5Pxyy+/YMeOHQCAO3fuICUlBZ9++qnafhkZGWjcuHGBj1OQ94GmpiY++ugjaR9HR0cYGxsjOjoazZs3L9J1kT18sTjo6uoiJSWl2OqjguPQPyIqNH19fdjZ2aFWrVpqSarcNGnSBLdv30aNGjVgZ2enthgZGcHIyAgWFhaIiIiQ9snKykJkZGSedbq4uEClUr3XmHEnJyeEh4errQsPD4ezs3OR6yQiIqLKI/v3UPZiYWGBBw8eoEuXLmjYsCH+97//ITIyEoGBgQDyfhpyQEAA/vzzT3Tu3BnHjx+Hs7OzNFfnq1ev8M033yAqKkparly5gtu3b0vJrNwYGBggKioK169fR3JyMk6ePAl7e/sCnVeTJk1w//59fP/990hNTUWfPn3Qq1evQraOuq5du0IIgQMHDuDRo0c4deqUNOwv+zxnzZqldp7Xrl3D7du3c038ZMt+il6DBg0wf/58aGhoYNasWdL2HTt2YOLEiRg8eDCOHDmCqKgofPXVV+98MnX2jdY344mKisKtW7fw5Zdf5rpPtWrVALyec+pt7dq1Q1RUFG7fvo3U1FRs2rQpx83dvAwZMgT37t2Dl5cXrl27hmbNmuGnn34q0L55GTBgAI4dO4anT59i//790NXVRadOnQBAGhJ44MABtXO/ceNGgeepKsr7IDdFvS6KS0JCQpFvrNP7YY8qIipRAwYMwMKFC+Hp6SlN3Pnw4UPs3bsXkydPRs2aNTF27FjMnz8f9erVg6OjI5YsWYLExMQ866xTpw68vb3x9ddfY8WKFXB1dcXDhw/x9OlT9OnTp0BxTZo0CX369EHjxo3h7u6O3377DXv37sXRo0eL6cyJiIiosomMjIRKpcLixYul3kLZ8yHlx97eHvb29vj222/Rv39/BAUFoXv37mjSpAlu3LgBOzu7QsUhl8tz3cfQ0BCWlpYIDw9HmzZtpPXh4eFo3ry5Wrm+ffuib9++6NWrFzp16oSEhASYmpqq1Zc9H5RSqcw3Hh0dHfTo0QNbt27FnTt34ODggCZNmkjbmzRpgpiYmEKf59tmzJiB9u3bY8SIEdJ5urm5YeTIkVKZt3tEKRSKHPE3adIEO3fuRI0aNWBoaFigY9va2sLQ0BA3btzIkRTMTmq+zcnJCVlZWYiIiICbmxsA4N9//0VMTIzazVNra2sMHz4cw4cPh5+fH9atW5ej51he55IbNzc3WFtbY+fOnTh06BB69+4tjURwdnaGtrY2YmNj1a6Rwijo+yArKwsXL16Urr2YmBgkJiZKPQWL67ooquvXr793kpaKhj2qiKhE6enp4eTJk6hVq5Y0WfrgwYORlpYmffFPmDABXl5e8Pb2RsuWLWFgYCBN5piX1atXo1evXhg5ciQcHR0xdOjQdz4B503dunXD8uXLsWjRItSvXx9r165FUFCQ9LQaIiIiosKys7NDZmYmfvrpJ9y7dw9btmzBmjVr8iyfmpoKX19fhIWF4eHDhwgPD8eFCxekP9SnTJmCM2fOwNfXV+qR88svvxR6MvU3TZo0CQsWLMDOnTsRExODqVOnIioqCmPHjgXw+mlt27dvx82bN3Hr1i3s3r0b5ubmMDY2zlFXjRo1oKuri8OHD+PJkydISkrK87gDBgzAgQMHsHHjRrXeVAAwc+ZMbN68GbNmzcKff/6J6Oho7NixAzNmzCjUubVs2RINGzbE3LlzAQD16tXDxYsXERISglu3buG7777DhQsX1PapU6cOrl69ipiYGDx79gyZmZkYMGAAqlWrBk9PT5w6dQr3799HWFgYxowZg7/++ivXY8vlcri7u+P06dMFjrdevXrw9PTE0KFDcfr0aVy5cgUDBw6ElZUVPD09AQDjxo1DSEgI7t+/j0uXLuHEiRN5DvmsU6cOXr16hWPHjuHZs2f5Dlv78ssvsWbNGoSGhqr9exgYGGDixIn49ttvsWnTJty9exeXLl3CTz/9hE2bNhXovAr6PtDS0sLo0aMRERGByMhI+Pj44OOPP5YSV0W5LgYNGgQ/P79844uNjUVUVBRiY2OhVCql3lpvTjD/4MED/P3333B3dy/QOVMxK+tJsoiIiIiIiD4kuU3AnW3JkiXCwsJC6OrqCg8PD7F58+Y8J7xOT08X/fr1E9bW1kKhUAhLS0vh6+urNlH6+fPnxaeffiqqVKki9PX1RcOGDXNMhv6md00QrVQqRUBAgLCyshJaWlrC1dVVHDp0SNr+888/i0aNGgl9fX1haGgoOnToIC5duiRtx1uTV69bt05YW1sLuVwu2rRpk2f7KJVKYWFhIQCIu3fv5ojr8OHDws3NTejq6gpDQ0PRvHlz8fPPP+d5Hv7+/sLV1TXH+u3btwttbW0RGxsr0tLShI+PjzAyMhLGxsZixIgRYurUqWr7PX36VGpfAOLEiRNCCCHi4uLEoEGDRLVq1YS2traoW7euGDp0qEhKSsozpoMHDworKytpkvi82uJNCQkJwsvLSxgZGUnXzK1bt6Ttvr6+wtbWVmhra4vq1asLLy8v8ezZMyFEzsnUhRBi+PDhomrVqgKA8Pf3F0LkPtH5jRs3BABRu3btHBPnq1QqsWzZMuHg4CC0tLRE9erVhYeHR46HH73p7WMU9H3wv//9T9StW1doa2sLd3d36cFH2d51Xbx9PbZp00Z4e3vnGacQr/9N8H+T77+5ZP/bCyHE3LlzhYeHR771UMmRCSFEWSTIiIiIiIiIiCoKIQRatGghDeGkD1NGRgbq1auHbdu25XjwAJUODv0jIiIiIiIiek8ymQw///wzsrKyyjoUeg+xsbGYNm0ak1RliD2qiIiIiIiIiIioXGCPKiIiIiIiIiIiKheYqCIiIiIiIiIionKBiSoiIiIiIiIiIioXmKgiIiIiIiIiIqJygYkqIiIiIiIiIiIqF5ioIiIiIiIiIiKicoGJKiIiIiIiIiIiKheYqCIiIiIiIiIionKBiSoiIiIiIiIiIioX/h/vsmzb+0hAfQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Guardado en reports/v2/10_baseline_confusion_roc.png\n" + ] + } + ], + "source": [ + "# Matriz de confusion + Curva ROC\n", + "fig, axes = plt.subplots(1, 2, figsize=(13, 5))\n", + "\n", + "# Matriz de confusion\n", + "cm = confusion_matrix(y_test, y_pred)\n", + "sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', ax=axes[0],\n", + " xticklabels=['No toxico','Toxico'],\n", + " yticklabels=['No toxico','Toxico'],\n", + " linewidths=0.5)\n", + "axes[0].set_title('Matriz de Confusión — Test Set', fontweight='bold')\n", + "axes[0].set_ylabel('Real')\n", + "axes[0].set_xlabel('Predicho')\n", + "\n", + "# Curva ROC\n", + "RocCurveDisplay.from_predictions(y_test, y_pred_proba, ax=axes[1],\n", + " color='#7F77DD', name='LR Baseline')\n", + "axes[1].plot([0,1],[0,1],'--', color='gray', alpha=0.5, label='Random')\n", + "axes[1].set_title('Curva ROC — Test Set', fontweight='bold')\n", + "axes[1].legend()\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig(PROJECT_ROOT / 'reports' / 'v2' / '10_baseline_confusion_roc.png',\n", + " dpi=150, bbox_inches='tight')\n", + "plt.show()\n", + "print('Guardado en reports/v2/10_baseline_confusion_roc.png')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Análisis de coeficientes — ¿qué aprendió el modelo?\n", + "\n", + "Los coeficientes de Logistic Regression indican el peso de cada feature.\n", + "Coeficiente positivo alto → predice TÓXICO.\n", + "Coeficiente negativo alto → predice NO TÓXICO.\n", + "\n", + "**Buscamos específicamente** si el modelo aprendió nombres propios\n", + "(`stefan`, `peggy`, `hubbard`) en lugar de lenguaje tóxico real.\n", + "Si los vemos en top features → añadirlos a custom stopwords y re-ejecutar." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TOP 20 — Palabras que MAS predicen TOXICO (coef positivo):\n", + " feature coeficiente\n", + " fuck 1.568407\n", + " run 1.411254\n", + " idiot 1.186074\n", + " shit 1.170665\n", + " ass 0.869589\n", + " bitch 0.825775\n", + " stupid 0.803532\n", + " thug 0.802252\n", + " shoot 0.802137\n", + " dumb 0.633515\n", + " fucking 0.594837\n", + " cunt 0.575905\n", + " white 0.571840\n", + "bullshit 0.508231\n", + " job 0.491564\n", + " every 0.483343\n", + " kill 0.481690\n", + " cnn 0.476915\n", + " black 0.455726\n", + " fucker 0.433620\n", + "\n", + "TOP 20 — Palabras que MAS predicen NO TOXICO (coef negativo):\n", + "feature coeficiente\n", + " thank -0.793547\n", + " truth -0.657544\n", + " say -0.608830\n", + " woman -0.608580\n", + " put -0.486706\n", + " move -0.483702\n", + " rap -0.468101\n", + " good -0.467515\n", + " tell -0.454767\n", + " pretty -0.443326\n", + " much -0.394840\n", + " well -0.387480\n", + " love -0.386914\n", + " side -0.378015\n", + " great -0.368998\n", + " fair -0.358242\n", + " could -0.355620\n", + " wow -0.349627\n", + " drug -0.344020\n", + " many -0.342814\n" + ] + } + ], + "source": [ + "# Extraer coeficientes del clasificador dentro del pipeline\n", + "lr_model = pipeline.named_steps['clf']\n", + "tfidf_model = pipeline.named_steps['tfidf']\n", + "feature_names = tfidf_model.get_feature_names_out()\n", + "coef = lr_model.coef_[0]\n", + "\n", + "coef_df = pd.DataFrame({\n", + " 'feature' : feature_names,\n", + " 'coeficiente': coef\n", + "}).sort_values('coeficiente', ascending=False)\n", + "\n", + "print('TOP 20 — Palabras que MAS predicen TOXICO (coef positivo):')\n", + "print(coef_df.head(20).to_string(index=False))\n", + "print()\n", + "print('TOP 20 — Palabras que MAS predicen NO TOXICO (coef negativo):')\n", + "print(coef_df.tail(20).sort_values('coeficiente').to_string(index=False))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Guardado en reports/v2/11_lr_coeficientes.png\n", + "\n", + "⚠️ Nombres propios / términos sospechosos en el modelo:\n", + "feature coeficiente\n", + " cnn 0.476915\n", + "\n", + "Considerar: añadir a custom_stopwords en preprocessing y re-ejecutar\n" + ] + } + ], + "source": [ + "# Visualizacion de coeficientes\n", + "fig, axes = plt.subplots(1, 2, figsize=(15, 8))\n", + "\n", + "top_pos = coef_df.head(25)\n", + "top_neg = coef_df.tail(25).sort_values('coeficiente')\n", + "\n", + "axes[0].barh(top_pos['feature'], top_pos['coeficiente'],\n", + " color='#E8593C', edgecolor='white')\n", + "axes[0].set_title('Top 25 — predicen TOXICO', fontweight='bold', color='#993C1D')\n", + "axes[0].set_xlabel('Coeficiente LR')\n", + "axes[0].invert_yaxis()\n", + "\n", + "axes[1].barh(top_neg['feature'], top_neg['coeficiente'].abs(),\n", + " color='#5DCAA5', edgecolor='white')\n", + "axes[1].set_title('Top 25 — predicen NO TOXICO', fontweight='bold', color='#0F6E56')\n", + "axes[1].set_xlabel('|Coeficiente LR|')\n", + "axes[1].invert_yaxis()\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig(PROJECT_ROOT / 'reports' / 'v2' / '11_lr_coeficientes.png',\n", + " dpi=150, bbox_inches='tight')\n", + "plt.show()\n", + "print('Guardado en reports/v2/11_lr_coeficientes.png')\n", + "\n", + "# Alerta: ¿hay nombres propios en top features?\n", + "suspicious = ['stefan','peggy','hubbard','ferguson','cigar','cnn']\n", + "found = coef_df[coef_df['feature'].isin(suspicious)]\n", + "if len(found) > 0:\n", + " print('\\n⚠️ Nombres propios / términos sospechosos en el modelo:')\n", + " print(found.to_string(index=False))\n", + " print('\\nConsiderar: añadir a custom_stopwords en preprocessing y re-ejecutar')\n", + "else:\n", + " print('\\n✅ No se detectaron nombres propios en top features')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Análisis de errores\n", + "\n", + "Los errores del modelo son tan importantes como sus aciertos.\n", + "Entender qué falla nos guía para mejorar el preprocesamiento,\n", + "cambiar el vectorizador o ajustar hiperparámetros.\n", + "\n", + "**Falso Positivo (FP):** comentario NO tóxico clasificado como TÓXICO → censura incorrecta.\n", + "**Falso Negativo (FN):** comentario TÓXICO clasificado como NO tóxico → hate speech no detectado.\n", + "\n", + "Para la app de YouTube: los FN son más dañinos (dejan pasar hate speech)." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total test : 200\n", + "Correctos : 151 (75.5%)\n", + "Falsos Pos : 19 — no toxicos clasificados como toxicos\n", + "Falsos Neg : 30 — toxicos NO detectados\n", + "\n", + "FALSOS POSITIVOS (el modelo censura incorrectamente):\n", + "-----------------------------------------------------------------\n", + " Prob: 0.631 | Who the fuck has time to be on the freeway???\n", + " Limpio: fuck time freeway\n", + "\n", + " Prob: 0.593 | If that cop shot a white guy, there would not be any riots. But since he shot a black guy, everyone \n", + " Limpio: cop shoot white guy would riot since shoot black guy everyone seem think black l\n", + "\n", + " Prob: 0.581 | people get shot everyday, how come this is the only one thats getting attention \n", + " Limpio: people get shoot everyday come one get attention\n", + "\n", + " Prob: 0.580 | 7:28 Lost my shit to that GUY. lmao\n", + " Limpio: lose shit guy lmao\n", + "\n", + " Prob: 0.578 | police shot 1 black guy , & then the blacks riot ,!! when a black shoot a black , what happens ?? ,,\n", + " Limpio: police shoot black guy black riot black shoot black happen\n", + "\n", + "FALSOS NEGATIVOS (hate speech que se escapa):\n", + "-----------------------------------------------------------------\n", + " Prob: 0.375 | I wish mr masri was dead,,\n", + " Limpio: wish mr dead\n", + "\n", + " Prob: 0.402 | We all know with the chimpers there is no compassion in their mud pumping hearts. \n", + " Limpio: know chimper compassion mud pump heart\n", + "\n", + " Prob: 0.416 | This is so far off base that you can't even call it propaganda! BS!\n", + " Limpio: far base even call propaganda bs\n", + "\n", + " Prob: 0.427 | As a black person all I have to say is THANK YOU FOR SPEAKING THE TRUTH. Too many blacks out there c\n", + " Limpio: black person say thank speak truth many black cause trouble dress idiot bring tr\n", + "\n", + " Prob: 0.427 | That video of him pushing that clerk around really made me lose any sympathy for him. You can defini\n", + " Limpio: push clerk around really make I lose sympathy definitely tell guy likely dick.bu\n", + "\n" + ] + } + ], + "source": [ + "# Reconstruir DataFrame de test para analisis\n", + "test_df = df.iloc[X_test.index].copy()\n", + "test_df['predicted'] = y_pred\n", + "test_df['proba_toxic'] = y_pred_proba\n", + "test_df['correct'] = test_df[TARGET] == test_df['predicted']\n", + "\n", + "# Falsos positivos y negativos\n", + "fp = test_df[(test_df[TARGET] == False) & (test_df['predicted'] == True)]\n", + "fn = test_df[(test_df[TARGET] == True) & (test_df['predicted'] == False)]\n", + "\n", + "print(f'Total test : {len(test_df)}')\n", + "print(f'Correctos : {test_df[\"correct\"].sum()} ({test_df[\"correct\"].mean()*100:.1f}%)')\n", + "print(f'Falsos Pos : {len(fp)} — no toxicos clasificados como toxicos')\n", + "print(f'Falsos Neg : {len(fn)} — toxicos NO detectados')\n", + "print()\n", + "\n", + "print('FALSOS POSITIVOS (el modelo censura incorrectamente):')\n", + "print('-' * 65)\n", + "for _, row in fp.nlargest(5, 'proba_toxic').iterrows():\n", + " print(f' Prob: {row[\"proba_toxic\"]:.3f} | {row[\"Text\"][:100]}')\n", + " print(f' Limpio: {row[\"clean_text\"][:80]}')\n", + " print()\n", + "\n", + "print('FALSOS NEGATIVOS (hate speech que se escapa):')\n", + "print('-' * 65)\n", + "for _, row in fn.nsmallest(5, 'proba_toxic').iterrows():\n", + " print(f' Prob: {row[\"proba_toxic\"]:.3f} | {row[\"Text\"][:100]}')\n", + " print(f' Limpio: {row[\"clean_text\"][:80]}')\n", + " print()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7. Registro en MLflow\n", + "\n", + "Guardamos todo en MLflow para poder comparar este baseline\n", + "contra los modelos ensemble del siguiente notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026/05/14 16:26:13 INFO mlflow.tracking.fluent: Experiment with name 'Youtube_project_experiment' does not exist. Creating a new experiment.\n", + "2026/05/14 16:26:17 WARNING mlflow.models.model: `artifact_path` is deprecated. Please use `name` instead.\n", + "2026/05/14 16:26:19 WARNING mlflow.sklearn: Saving scikit-learn models in the pickle or cloudpickle format requires exercising caution because these formats rely on Python's object serialization mechanism, which can execute arbitrary code during deserialization. The recommended safe alternative is the 'skops' format. For more information, see: https://scikit-learn.org/stable/model_persistence.html\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MLflow registrado\n", + " Run ID : 716ccbc603ad40389fbdd81ab0197960\n", + " Experimento: Youtube_project_experiment\n", + " Run name : lr_baseline\n" + ] + } + ], + "source": [ + "MLFLOW_DIR = PROJECT_ROOT / 'mlruns'\n", + "mlflow.set_tracking_uri(f'file://{MLFLOW_DIR}')\n", + "mlflow.set_experiment('Youtube_project_experiment')\n", + "\n", + "with mlflow.start_run(run_name='lr_baseline'):\n", + "\n", + " # Params\n", + " mlflow.log_param('model', 'LogisticRegression')\n", + " mlflow.log_param('C', lr_cfg['C'])\n", + " mlflow.log_param('max_iter', lr_cfg['max_iter'])\n", + " mlflow.log_param('class_weight', lr_cfg['class_weight'])\n", + " mlflow.log_param('solver', lr_cfg['solver'])\n", + " mlflow.log_param('tfidf_features', tfidf_cfg['max_features'])\n", + " mlflow.log_param('ngram_range', str(tuple(tfidf_cfg['ngram_range'])))\n", + " mlflow.log_param('cv_folds', CV_FOLDS)\n", + " mlflow.log_param('vectorizer', 'tfidf')\n", + "\n", + " # Metrics CV\n", + " mlflow.log_metric('cv_f1_mean', cv_results['test_f1'].mean())\n", + " mlflow.log_metric('cv_f1_std', cv_results['test_f1'].std())\n", + " mlflow.log_metric('cv_roc_auc_mean', cv_results['test_roc_auc'].mean())\n", + " mlflow.log_metric('cv_precision_mean', cv_results['test_precision'].mean())\n", + " mlflow.log_metric('cv_recall_mean', cv_results['test_recall'].mean())\n", + "\n", + " # Metrics test final\n", + " mlflow.log_metric('test_f1', f1_test)\n", + " mlflow.log_metric('train_f1', f1_train)\n", + " # Gap clásico Train vs Test\n", + " mlflow.log_metric('train_test_gap_pp', round(train_test_gap_pp, 2))\n", + "\n", + " # Consistencia CV vs Test\n", + " mlflow.log_metric('cv_f1_mean', round(cv_f1_mean, 4))\n", + " mlflow.log_metric('cv_test_gap_pp', round(cv_test_gap_pp, 2))\n", + " mlflow.log_metric('test_roc_auc', roc_auc_score(y_test, y_pred_proba))\n", + " \n", + " mlflow.log_metric('fp_count', len(fp))\n", + " mlflow.log_metric('fn_count', len(fn))\n", + "\n", + " # Modelo\n", + " mlflow.sklearn.log_model(pipeline, 'lr_baseline_pipeline')\n", + "\n", + " # Artefactos\n", + " for png in ['09_cv_metrics','10_baseline_confusion_roc','11_lr_coeficientes']:\n", + " mlflow.log_artifact(str(PROJECT_ROOT / 'reports' / 'v2' / f'{png}.png'))\n", + "\n", + " print(f'MLflow registrado')\n", + " print(f' Run ID : {mlflow.active_run().info.run_id}')\n", + " print(f' Experimento: Youtube_project_experiment')\n", + " print(f' Run name : lr_baseline')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8. Guardar modelo\n", + "\n", + "Guardamos el pipeline completo (TF-IDF + LR) en `models/`.\n", + "El pipeline incluye el vectorizador entrenado, por lo que basta\n", + "con cargar este archivo y llamar `.predict()` sobre texto limpio." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Modelo guardado en: /mnt/c/Users/under/Documents/F5/3_Projects/Project_9_Equipo3/Project_YT/models/lr_baseline.joblib\n", + "\n", + "Verificacion modelo cargado:\n", + " [TOXICO 0.72] you are such a stupid thug get out\n", + " [NO TOXICO 0.43] I think the police should be more transparent\n", + " [TOXICO 0.58] black people are criminal thugs\n" + ] + } + ], + "source": [ + "MODELS_DIR = PROJECT_ROOT / 'models'\n", + "MODELS_DIR.mkdir(exist_ok=True)\n", + "\n", + "model_path = MODELS_DIR / 'lr_baseline.joblib'\n", + "joblib.dump(pipeline, model_path)\n", + "print(f'Modelo guardado en: {model_path}')\n", + "\n", + "# Verificacion: cargar y predecir\n", + "loaded = joblib.load(model_path)\n", + "test_comments = [\n", + " 'you are such a stupid thug get out',\n", + " 'I think the police should be more transparent',\n", + " 'black people are criminal thugs',\n", + "]\n", + "preds = loaded.predict(test_comments)\n", + "probas = loaded.predict_proba(test_comments)[:, 1]\n", + "print('\\nVerificacion modelo cargado:')\n", + "for comment, pred, prob in zip(test_comments, preds, probas):\n", + " label = 'TOXICO' if pred else 'NO TOXICO'\n", + " print(f' [{label} {prob:.2f}] {comment[:60]}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9. Conclusiones y decisiones" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "CONCLUSIONES — BASELINE\n", + "=======================================================\n", + "Modelo : Logistic Regression + TF-IDF\n", + "Dataset: 800 train / 200 test / 5-fold CV\n", + "\n", + "Metricas CV (media 5 folds):\n", + " F1-weighted : 0.7015\n", + " ROC-AUC : 0.7737\n", + "\n", + "Metricas test final:\n", + " F1-weighted : 0.7531\n", + " Train F1 : 0.8623\n", + "\n", + "Gaps:\n", + " Train-Test Gap : 10.91 pp\n", + " CV-Test Gap : 5.17 pp\n", + " Rubrica CV/Test: ⚠️ Alto gap\n", + "\n", + "Errores:\n", + " False Positives : 19\n", + " False Negatives : 30\n", + "\n", + "Coeficientes sospechosos detectados:\n", + " Revisar si stefan/peggy/hubbard aparecen en top coef\n", + " Si aparecen -> agregar a custom_stopwords\n", + " y re-ejecutar preprocessing\n", + "\n", + "\n" + ] + } + ], + "source": [ + "f1_cv = cv_results['test_f1'].mean()\n", + "roc_cv = cv_results['test_roc_auc'].mean()\n", + "\n", + "train_test_gap_pp = abs(f1_train - f1_test) * 100\n", + "cv_test_gap_pp = abs(f1_cv - f1_test) * 100\n", + "\n", + "cv_status = '✅ Estable' if cv_test_gap_pp < 5 else '⚠️ Alto gap'\n", + "\n", + "print(f\"\"\"\n", + "CONCLUSIONES — BASELINE\n", + "=======================================================\n", + "Modelo : Logistic Regression + TF-IDF\n", + "Dataset: 800 train / 200 test / {CV_FOLDS}-fold CV\n", + "\n", + "Metricas CV (media {CV_FOLDS} folds):\n", + " F1-weighted : {f1_cv:.4f}\n", + " ROC-AUC : {roc_cv:.4f}\n", + "\n", + "Metricas test final:\n", + " F1-weighted : {f1_test:.4f}\n", + " Train F1 : {f1_train:.4f}\n", + "\n", + "Gaps:\n", + " Train-Test Gap : {train_test_gap_pp:.2f} pp\n", + " CV-Test Gap : {cv_test_gap_pp:.2f} pp\n", + " Rubrica CV/Test: {cv_status}\n", + "\n", + "Errores:\n", + " False Positives : {len(fp)}\n", + " False Negatives : {len(fn)}\n", + "\n", + "Coeficientes sospechosos detectados:\n", + " Revisar si stefan/peggy/hubbard aparecen en top coef\n", + " Si aparecen -> agregar a custom_stopwords\n", + " y re-ejecutar preprocessing\n", + "\n", + "\"\"\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "py310", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.20" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}