{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 🔁 Data Augmentation\n",
    "\n",
    "### ¿Qué hace este notebook?\n",
    "Evaluamos **3 estrategias de augmentation** sobre la clase tóxica del train set\n",
    "y comparamos si alguna mejora el modelo ganador (LR tuned).\n",
    "\n",
    "### Estrategias\n",
    "| # | Estrategia | Herramienta | Requiere internet |\n",
    "|---|---|---|---|\n",
    "| 1 | Synonym Replacement (WordNet) | `nlpaug` + NLTK | No |\n",
    "| 2 | Random Swap + Delete (EDA) | Python nativo | No |\n",
    "| 3 | Back-Translation EN→ES→EN | `deep_translator` | Sí |\n",
    "\n",
    "### Hipótesis\n",
    "- WordNet: mejora diversidad léxica pero puede romper contexto\n",
    "- EDA: mínima perturbación, preserva semántica\n",
    "- Back-translation: mejor calidad semántica, parafrasea naturalmente\n",
    "\n",
    "### Modelo de referencia\n",
    "LR tuned cargado desde `final_model.joblib` — F1 test ≈ 0.7579."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 0. Imports y recursos NLTK\n",
    "\n",
    "Todos los recursos NLTK se descargan aquí para evitar errores\n",
    "en celdas posteriores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PROJECT_ROOT: /mnt/c/Users/under/Documents/F5/3_Projects/Project_9_Equipo3/Project_YT\n",
      "Recursos NLTK cargados\n"
     ]
    }
   ],
   "source": [
    "import sys, yaml, joblib, warnings, random\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from pathlib import Path\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.model_selection import (\n",
    "    train_test_split, StratifiedKFold, cross_validate\n",
    ")\n",
    "from sklearn.metrics import f1_score, roc_auc_score, confusion_matrix\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "# NLTK — descargar todos los recursos necesarios aqui\n",
    "import nltk\n",
    "for resource in [\n",
    "    'stopwords', 'wordnet', 'omw-1.4', 'punkt',\n",
    "    'averaged_perceptron_tagger', 'averaged_perceptron_tagger_eng'\n",
    "]:\n",
    "    nltk.download(resource, quiet=True)\n",
    "\n",
    "import nlpaug.augmenter.word as naw\n",
    "\n",
    "PROJECT_ROOT = Path.cwd().parent\n",
    "sys.path.insert(0, str(PROJECT_ROOT))\n",
    "plt.rcParams['figure.figsize'] = (12, 5)\n",
    "plt.rcParams['axes.spines.top'] = False\n",
    "plt.rcParams['axes.spines.right'] = False\n",
    "print(f'PROJECT_ROOT: {PROJECT_ROOT}')\n",
    "print('Recursos NLTK cargados')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Configuración y datos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train: 800 | Test: 200\n",
      "Toxicos en train: 370 (46.2%)\n"
     ]
    }
   ],
   "source": [
    "CONFIG_FEAT = PROJECT_ROOT / 'configs' / 'features.yaml'\n",
    "CONFIG_PIPE = PROJECT_ROOT / 'configs' / 'pipeline.yaml'\n",
    "CONFIG_BEST = PROJECT_ROOT / 'configs' / 'best_params.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_BEST) as f: best_cfg = yaml.safe_load(f)\n",
    "\n",
    "tfidf_cfg   = feat_cfg['vectorization']['tfidf']\n",
    "TARGET      = pipe_cfg['data']['target_binary']\n",
    "RAND        = pipe_cfg['pipeline']['random_state']\n",
    "TEST_SIZE   = pipe_cfg['pipeline']['test_size']\n",
    "CV_FOLDS    = pipe_cfg['pipeline']['cv_folds']\n",
    "best_params = best_cfg['hyperparameters']\n",
    "\n",
    "PROCESSED = PROJECT_ROOT / 'data' / 'processed' / 'v2' / 'comments_preprocessed.csv'\n",
    "df = pd.read_csv(PROCESSED)\n",
    "df['clean_text'] = df['clean_text'].fillna('').astype(str)\n",
    "X, y = df['clean_text'], 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",
    "cv_strategy = StratifiedKFold(n_splits=CV_FOLDS, shuffle=True, random_state=RAND)\n",
    "\n",
    "print(f'Train: {len(X_train)} | Test: {len(X_test)}')\n",
    "print(f'Toxicos en train: {y_train.sum()} ({y_train.mean()*100:.1f}%)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Helpers — TF-IDF y evaluación"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_tfidf(**overrides):\n",
    "    params = {\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",
    "    params.update(overrides)\n",
    "    return TfidfVectorizer(**params)\n",
    "\n",
    "def build_lr_pipeline():\n",
    "    \"\"\"Construye LR pipeline desde best_params.yaml — sin hardcode.\"\"\"\n",
    "    bp = best_params\n",
    "    ngram = (1,1) if str(bp.get('ngram_range','1_2')) == '1_1' else (1,2)\n",
    "    return Pipeline([\n",
    "        ('tfidf', make_tfidf(\n",
    "            max_features = bp.get('max_features', tfidf_cfg['max_features']),\n",
    "            min_df       = bp.get('min_df', tfidf_cfg['min_df']),\n",
    "            ngram_range  = ngram,\n",
    "            sublinear_tf = bp.get('sublinear_tf', True),\n",
    "        )),\n",
    "        ('clf', LogisticRegression(\n",
    "            C            = bp.get('C', 0.4),\n",
    "            max_iter     = 1000,\n",
    "            class_weight = 'balanced',\n",
    "            solver       = 'lbfgs',\n",
    "            random_state = RAND,\n",
    "        ))\n",
    "    ])\n",
    "\n",
    "def evaluate(pipeline, X_tr, y_tr, X_te, y_te, name, cv_scores=None):\n",
    "    \"\"\"Devuelve metricas incluyendo ambos gaps.\"\"\"\n",
    "    pred       = pipeline.predict(X_te)\n",
    "    pred_train = pipeline.predict(X_tr)\n",
    "    f1_te  = f1_score(y_te, pred,       average='weighted')\n",
    "    f1_tr  = f1_score(y_tr, pred_train, average='weighted')\n",
    "    roc    = roc_auc_score(y_te, pipeline.predict_proba(X_te)[:,1])\n",
    "    cv_mean = cv_std = cv_gap = None\n",
    "\n",
    "    if cv_scores is not None:\n",
    "        cv_mean = cv_scores['test_score'].mean()\n",
    "        cv_std  = cv_scores['test_score'].std()\n",
    "        cv_gap  = abs(cv_mean - f1_te) * 100\n",
    "    return {\n",
    "        \n",
    "        'name'             : name,\n",
    "        'f1_test'          : round(f1_te, 4),\n",
    "        'f1_train'         : round(f1_tr, 4),\n",
    "        'train_test_gap_pp': round((f1_tr - f1_te)*100, 2),\n",
    "        'cv_mean'          : round(cv_mean, 4) if cv_mean else None,\n",
    "        'cv_std'           : round(cv_std, 4)  if cv_std  else None,\n",
    "        'cv_test_gap_pp'   : round(cv_gap, 2)  if cv_gap  else None,\n",
    "        'roc_auc'          : round(roc, 4),\n",
    "        'fp'               : int(((y_te==False)&(pred==True)).sum()),\n",
    "        'fn'               : int(((y_te==True) &(pred==False)).sum()),\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Modelo baseline — LR tuned sin augmentation\n",
    "\n",
    "Entrenamos LR tuned con los datos originales para tener\n",
    "la referencia exacta en este notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Baseline (sin augmentation):\n",
      "  F1 test  : 0.7579\n",
      "  CV mean  : 0.7104 ± 0.0353\n",
      "  FP / FN  : 18 / 30\n"
     ]
    }
   ],
   "source": [
    "lr_base = build_lr_pipeline()\n",
    "lr_base.fit(X_train, y_train)\n",
    "\n",
    "cv_base = cross_validate(lr_base, X_train, y_train,\n",
    "                          cv=cv_strategy, scoring='f1_weighted',\n",
    "                          return_train_score=False, n_jobs=-1)\n",
    "\n",
    "metrics_base = evaluate(lr_base, X_train, y_train,\n",
    "                         X_test, y_test, 'LR tuned (sin aug)', cv_base)\n",
    "\n",
    "print('Baseline (sin augmentation):')\n",
    "print(f\"  F1 test  : {metrics_base['f1_test']:.4f}\")\n",
    "print(f\"  CV mean  : {metrics_base['cv_mean']:.4f} ± {metrics_base['cv_std']:.4f}\")\n",
    "print(f\"  FP / FN  : {metrics_base['fp']} / {metrics_base['fn']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Función de augmentation\n",
    "\n",
    "Solo augmentamos **comentarios tóxicos del train set**.\n",
    "El test set nunca se toca."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Comentarios toxicos en train: 370\n",
      "Objetivo: generar ~185 muestras sinteticas\n"
     ]
    }
   ],
   "source": [
    "def get_toxic_train():\n",
    "    \"\"\"Devuelve X e y de solo los comentarios toxicos del train.\"\"\"\n",
    "    mask = y_train == True\n",
    "    return X_train[mask].tolist(), y_train[mask].tolist()\n",
    "\n",
    "def build_augmented_train(aug_texts, aug_labels):\n",
    "    \"\"\"\n",
    "    Concatena textos originales + sinteticos.\n",
    "    Retorna X_aug (Series) e y_aug (Series).\n",
    "    \"\"\"\n",
    "    X_aug = pd.concat([\n",
    "        X_train,\n",
    "        pd.Series(aug_texts, dtype=str)\n",
    "    ], ignore_index=True)\n",
    "    y_aug = pd.concat([\n",
    "        y_train,\n",
    "        pd.Series(aug_labels, dtype=bool)\n",
    "    ], ignore_index=True)\n",
    "    return X_aug, y_aug\n",
    "\n",
    "X_toxic, y_toxic = get_toxic_train()\n",
    "print(f'Comentarios toxicos en train: {len(X_toxic)}')\n",
    "print(f'Objetivo: generar ~{len(X_toxic)//2} muestras sinteticas')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Estrategia 1 — Synonym Replacement (WordNet)\n",
    "\n",
    "Reemplaza palabras aleatorias por sinónimos usando WordNet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Muestras generadas (WordNet): 326\n",
      "Ejemplos:\n",
      "  ORIG: wonder police expect happen continually abuse kill people honestly expect public\n",
      "  AUG : curiosity police expect pass off continually abuse kill citizenry candidly expec\n",
      "\n",
      "  ORIG: bassem think walmart hire holiday get job loser\n",
      "  AUG : bassem think walmart hire vacation get caper loser\n",
      "\n",
      "  ORIG: monkey screamin bout honky intensifie\n",
      "  AUG : monkey screamin bout whitey intensifie\n",
      "\n"
     ]
    }
   ],
   "source": [
    "aug_wordnet = naw.SynonymAug(aug_src='wordnet', aug_p=0.3)\n",
    "\n",
    "random.seed(RAND)\n",
    "texts_wn, labels_wn = [], []\n",
    "\n",
    "for text, label in zip(X_toxic, y_toxic):\n",
    "    if len(text.split()) < 3:\n",
    "        continue\n",
    "    try:\n",
    "        result = aug_wordnet.augment(text)\n",
    "        aug_text = result[0] if isinstance(result, list) else result\n",
    "        if isinstance(aug_text, str) and aug_text.strip() and aug_text.strip() != text.strip():\n",
    "            texts_wn.append(aug_text.strip())\n",
    "            labels_wn.append(label)\n",
    "    except Exception:\n",
    "        continue\n",
    "\n",
    "print(f'Muestras generadas (WordNet): {len(texts_wn)}')\n",
    "print('Ejemplos:')\n",
    "for orig, aug in zip(X_toxic[:3], texts_wn[:3]):\n",
    "    print(f'  ORIG: {orig[:80]}')\n",
    "    print(f'  AUG : {aug[:80]}')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train original : 800\n",
      "Train WordNet  : 1126 (+326 sinteticos)\n",
      "Balance toxico : 61.8%\n",
      "WordNet: F1=0.6855 (-7.24pp) | FN=28 | FP=35\n"
     ]
    }
   ],
   "source": [
    "X_aug_wn, y_aug_wn = build_augmented_train(texts_wn, labels_wn)\n",
    "print(f'Train original : {len(X_train)}')\n",
    "print(f'Train WordNet  : {len(X_aug_wn)} (+{len(texts_wn)} sinteticos)')\n",
    "print(f'Balance toxico : {y_aug_wn.mean()*100:.1f}%')\n",
    "\n",
    "lr_wn = build_lr_pipeline()\n",
    "lr_wn.fit(X_aug_wn, y_aug_wn)\n",
    "\n",
    "cv_wn = cross_validate(lr_wn, X_aug_wn, y_aug_wn,\n",
    "                        cv=cv_strategy, scoring='f1_weighted',\n",
    "                        return_train_score=False, n_jobs=-1)\n",
    "\n",
    "metrics_wn = evaluate(lr_wn, X_aug_wn, y_aug_wn,\n",
    "                       X_test, y_test, 'LR + WordNet', cv_wn)\n",
    "\n",
    "delta = metrics_wn['f1_test'] - metrics_base['f1_test']\n",
    "\n",
    "print(f\"WordNet: F1={metrics_wn['f1_test']:.4f} ({delta*100:+.2f}pp) | \"\n",
    "      f\"FN={metrics_wn['fn']} | FP={metrics_wn['fp']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Estrategia 2 — EDA (Random Swap + Delete)\n",
    "\n",
    "Easy Data Augmentation — dos operaciones simples sin dependencias externas:\n",
    "\n",
    "- **Random Swap**: intercambia dos palabras aleatorias\n",
    "- **Random Delete**: elimina palabras con probabilidad p\n",
    "\n",
    "**Ventaja:** no depende de WordNet ni internet. Funciona siempre.\n",
    "**Limitación:** perturbación mínima — puede no añadir suficiente diversidad."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Muestras generadas (EDA): 336\n",
      "Ejemplos:\n",
      "  ORIG: wonder police expect happen continually abuse kill people honestly expect public\n",
      "  AUG : wonder happen expect continually abuse kill honestly public nothing back take le\n",
      "\n",
      "  ORIG: bassem think walmart hire holiday get job loser\n",
      "  AUG : think bassem hire holiday get job loser\n",
      "\n",
      "  ORIG: monkey screamin bout honky intensifie\n",
      "  AUG : bout screamin intensifie\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def eda_augment(text, p_swap=0.15, p_delete=0.10, seed=None):\n",
    "    \"\"\"\n",
    "    Easy Data Augmentation:\n",
    "    - Random swap: intercambia 2 palabras adyacentes\n",
    "    - Random delete: elimina palabras con probabilidad p_delete\n",
    "    \"\"\"\n",
    "    if seed is not None:\n",
    "        random.seed(seed)\n",
    "    words = text.split()\n",
    "    if len(words) < 2:\n",
    "        return text\n",
    "\n",
    "    # Random delete\n",
    "    words = [w for w in words if random.random() > p_delete]\n",
    "    if not words:\n",
    "        return text\n",
    "\n",
    "    # Random swap (pares adyacentes)\n",
    "    n_swaps = max(1, int(len(words) * p_swap))\n",
    "    for _ in range(n_swaps):\n",
    "        if len(words) >= 2:\n",
    "            idx = random.randint(0, len(words)-2)\n",
    "            words[idx], words[idx+1] = words[idx+1], words[idx]\n",
    "\n",
    "    return ' '.join(words)\n",
    "\n",
    "# Generar muestras EDA\n",
    "texts_eda, labels_eda = [], []\n",
    "random.seed(RAND)\n",
    "\n",
    "for text, label in zip(X_toxic, y_toxic):\n",
    "    if len(text.split()) < 3:\n",
    "        continue\n",
    "    aug = eda_augment(text)\n",
    "    if aug != text:\n",
    "        texts_eda.append(aug)\n",
    "        labels_eda.append(label)\n",
    "\n",
    "print(f'Muestras generadas (EDA): {len(texts_eda)}')\n",
    "print('Ejemplos:')\n",
    "for orig, aug in zip(X_toxic[:3], texts_eda[:3]):\n",
    "    print(f'  ORIG: {orig[:80]}')\n",
    "    print(f'  AUG : {aug[:80]}')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train EDA: 1136 (+336 sinteticos)\n",
      "EDA: F1=0.7054 (-5.25pp) | FN=27 | FP=32\n"
     ]
    }
   ],
   "source": [
    "X_aug_eda, y_aug_eda = build_augmented_train(texts_eda, labels_eda)\n",
    "print(f'Train EDA: {len(X_aug_eda)} (+{len(texts_eda)} sinteticos)')\n",
    "\n",
    "lr_eda = build_lr_pipeline()\n",
    "lr_eda.fit(X_aug_eda, y_aug_eda)\n",
    "\n",
    "cv_eda = cross_validate(lr_eda, X_aug_eda, y_aug_eda,\n",
    "                         cv=cv_strategy, scoring='f1_weighted',\n",
    "                         return_train_score=False, n_jobs=-1)\n",
    "\n",
    "metrics_eda = evaluate(lr_eda, X_aug_eda, y_aug_eda,\n",
    "                        X_test, y_test, 'LR + EDA', cv_eda)\n",
    "\n",
    "delta = metrics_eda['f1_test'] - metrics_base['f1_test']\n",
    "print(f\"EDA: F1={metrics_eda['f1_test']:.4f} ({delta*100:+.2f}pp) | \"\n",
    "      f\"FN={metrics_eda['fn']} | FP={metrics_eda['fp']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Estrategia 3 — Back-Translation EN→ES→EN\n",
    "\n",
    "Traduce el comentario a español y lo retraduce al inglés.\n",
    "El resultado es una paráfrasis que preserva el significado.\n",
    "\n",
    "**Por qué funciona mejor que WordNet:**\n",
    "- La traducción produce paráfrasis naturales\n",
    "- Los insultos raciales en inglés no siempre tienen equivalente directo\n",
    "  en español → el modelo de traducción busca el contexto más cercano\n",
    "- Añade variedad sintáctica real, no solo léxica\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deep_translator disponible\n"
     ]
    }
   ],
   "source": [
    "# Instalar si no esta disponible\n",
    "try:\n",
    "    from deep_translator import GoogleTranslator\n",
    "    BACKTRANS_AVAILABLE = True\n",
    "    print('deep_translator disponible')\n",
    "except ImportError:\n",
    "    BACKTRANS_AVAILABLE = False\n",
    "    print('deep_translator no disponible — ejecuta: pip install deep-translator')\n",
    "    print('Saltando back-translation...')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Muestras back-translation: 311\n",
      "Ejemplos:\n",
      "  ORIG: wonder police expect happen continually abuse kill people honestly expect public\n",
      "  BT  : I wonder the police expect it to happen continuously abuse killing people honest\n",
      "\n",
      "  ORIG: bassem think walmart hire holiday get job loser\n",
      "  BT  : Bassem Thinks Walmart Vacation Rentals Gets Losing Job\n",
      "\n",
      "  ORIG: monkey screamin bout honky intensifie\n",
      "  BT  : monkey screaming about honky step up\n",
      "\n"
     ]
    }
   ],
   "source": [
    "texts_bt, labels_bt = [], []\n",
    "\n",
    "if BACKTRANS_AVAILABLE:\n",
    "    to_es   = GoogleTranslator(source='en', target='es')\n",
    "    to_en   = GoogleTranslator(source='es', target='en')\n",
    "\n",
    "    import time\n",
    "    random.seed(RAND)\n",
    "\n",
    "    for i, (text, label) in enumerate(zip(X_toxic, y_toxic)):\n",
    "        if len(text.split()) < 3:\n",
    "            continue\n",
    "        try:\n",
    "            # Limitar largo para evitar errores de API\n",
    "            text_short = ' '.join(text.split()[:60])\n",
    "            es   = to_es.translate(text_short)\n",
    "            back = to_en.translate(es)\n",
    "            if back and back.strip() != text_short.strip():\n",
    "                texts_bt.append(back.strip())\n",
    "                labels_bt.append(label)\n",
    "            # Rate limit suave\n",
    "            if i % 50 == 0 and i > 0:\n",
    "                time.sleep(1)\n",
    "        except Exception as e:\n",
    "            print(f'Error en muestra {i}: {e}')\n",
    "            continue\n",
    "\n",
    "    print(f'Muestras back-translation: {len(texts_bt)}')\n",
    "    if texts_bt:\n",
    "        print('Ejemplos:')\n",
    "        for orig, bt in zip(X_toxic[:3], texts_bt[:3]):\n",
    "            print(f'  ORIG: {orig[:80]}')\n",
    "            print(f'  BT  : {bt[:80]}')\n",
    "            print()\n",
    "else:\n",
    "    print('Back-translation saltada — usando lista vacia')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train BT: 1111 (+311 sinteticos)\n",
      "BackTrans: F1=0.7271 (-3.08pp) | FN=34 | FP=20\n"
     ]
    }
   ],
   "source": [
    "if BACKTRANS_AVAILABLE and texts_bt:\n",
    "    X_aug_bt, y_aug_bt = build_augmented_train(texts_bt, labels_bt)\n",
    "    print(f'Train BT: {len(X_aug_bt)} (+{len(texts_bt)} sinteticos)')\n",
    "\n",
    "    lr_bt = build_lr_pipeline()\n",
    "    lr_bt.fit(X_aug_bt, y_aug_bt)\n",
    "\n",
    "    cv_bt = cross_validate(lr_bt, X_aug_bt, y_aug_bt,\n",
    "                            cv=cv_strategy, scoring='f1_weighted',\n",
    "                            return_train_score=False, n_jobs=-1)\n",
    "\n",
    "    metrics_bt = evaluate(lr_bt, X_aug_bt, y_aug_bt,\n",
    "                           X_test, y_test, 'LR + BackTrans', cv_bt)\n",
    "\n",
    "    delta = metrics_bt['f1_test'] - metrics_base['f1_test']\n",
    "    print(f\"BackTrans: F1={metrics_bt['f1_test']:.4f} ({delta*100:+.2f}pp) | \"\n",
    "          f\"FN={metrics_bt['fn']} | FP={metrics_bt['fp']}\")\n",
    "else:\n",
    "    metrics_bt = None\n",
    "    print('Back-translation no ejecutada')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. Tabla comparativa\n",
    "\n",
    "Comparamos el baseline contra las 3 estrategias de augmentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "COMPARATIVA AUGMENTATION\n",
      "==============================================================================================================\n",
      "Modelo                   F1 Test  F1 Train  TrTe Gap   CV Mean   CV Std  CV-Te Gap   FP   FN\n",
      "--------------------------------------------------------------------------------------------------------------\n",
      "  LR tuned (sin aug)      0.7579    0.8987     14.07    0.7104   0.0353       4.76 18.0 30.0\n",
      "  LR + WordNet            0.6855    0.9307     24.52    0.7452   0.0120       5.97 35.0 28.0\n",
      "  LR + EDA                0.7054    0.9401     23.47    0.7410   0.0119       3.56 32.0 27.0\n",
      "  LR + BackTrans          0.7271    0.9409     21.38    0.7736   0.0260       4.65 20.0 34.0\n",
      "\n",
      "DELTAS vs baseline (LR tuned sin aug):\n",
      "  LR + WordNet           ΔF1=-7.24pp | ΔFN=-2 | ΔFP=+17\n",
      "  LR + EDA               ΔF1=-5.25pp | ΔFN=-3 | ΔFP=+14\n",
      "  LR + BackTrans         ΔF1=-3.08pp | ΔFN=+4 | ΔFP=+2\n"
     ]
    }
   ],
   "source": [
    "all_m = [m for m in [metrics_base, metrics_wn, metrics_eda, metrics_bt]\n",
    "         if m is not None]\n",
    "\n",
    "comp_df = pd.DataFrame(all_m).set_index('name')\n",
    "\n",
    "print('COMPARATIVA AUGMENTATION')\n",
    "print('=' * 110)\n",
    "print(f\"{'Modelo':22} {'F1 Test':>9} {'F1 Train':>9} {'TrTe Gap':>9} \"\n",
    "      f\"{'CV Mean':>9} {'CV Std':>8} {'CV-Te Gap':>10} {'FP':>4} {'FN':>4}\")\n",
    "print('-' * 110)\n",
    "for name, row in comp_df.iterrows():\n",
    "    cv_g = f\"{row['cv_test_gap_pp']:.2f}\" if row['cv_test_gap_pp'] else 'N/A'\n",
    "    cv_m = f\"{row['cv_mean']:.4f}\"         if row['cv_mean']        else 'N/A'\n",
    "    cv_s = f\"{row['cv_std']:.4f}\"          if row['cv_std']         else 'N/A'\n",
    "    print(f\"  {name:20} {row['f1_test']:>9.4f} {row['f1_train']:>9.4f} \"\n",
    "          f\"{row['train_test_gap_pp']:>9.2f} {cv_m:>9} {cv_s:>8} \"\n",
    "          f\"{cv_g:>10} {row['fp']:>4} {row['fn']:>4}\")\n",
    "\n",
    "print()\n",
    "print('DELTAS vs baseline (LR tuned sin aug):')\n",
    "base_f1 = metrics_base['f1_test']\n",
    "base_fn = metrics_base['fn']\n",
    "base_fp = metrics_base['fp']\n",
    "for _, row in comp_df.iterrows():\n",
    "    if row.name == metrics_base['name']:\n",
    "        continue\n",
    "    df1 = row['f1_test'] - base_f1\n",
    "    dfn = row['fn'] - base_fn\n",
    "    dfp = row['fp'] - base_fp\n",
    "    print(f\"  {row.name:22} ΔF1={df1*100:+.2f}pp | ΔFN={int(dfn):+d} | ΔFP={int(dfp):+d}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABdIAAAHpCAYAAACGBM7aAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAhqVJREFUeJzs3XlclOX+//H3sA3igikiqLjvK4ZpHJfMXTumZR1TTy6p5VYZLUZppmW0WGlm2mJqp8ztqOWSphRmJZoLaiczl9xSDPUrKCrr/fvDH3eMMCNDwODwej4e9+PB3POZaz4z1819MR+uuW6LYRiGAAAAAAAAAABArjxcnQAAAAAAAAAAAMUZhXQAAAAAAAAAABygkA4AAAAAAAAAgAMU0gEAAAAAAAAAcIBCOgAAAAAAAAAADlBIBwAAAAAAAADAAQrpAAAAAAAAAAA4QCEdAAAAAAAAAAAHKKQDAAAAAAAAAOAAhXQAAICb3NGjR2WxWGSxWNSxY0dXp1OixcTEmH0xdOhQV6eTZ2+88YYsFotuueUWJScnuzodFLCOHTuax+XRo0cL5Tl++OEH8zl++umnQnkOwJ0wdjsv6/2qWbNmnh+zYMEC83EvvvhioeVW0MaOHSuLxaIGDRrIMAxXp4MCVrNmTfO4LCyfffaZLBaLfH19dfLkyUJ7npKGQjrgBl588UXzJJzbVr58eZv4+fPn6/7771fVqlVt4vIie4HgRpszf+Dk1dGjR/Xiiy/qxRdf1KpVqwq8fQAobM6es91N9g+0FotF7733ns392d+fZ5991kVZOjZjxgxzLHIHly5d0uuvvy5JGjFihEqXLu3ijHAzatu2rW677TZJ0gsvvODibICCxdi9INfXXaZMGd16662aPn260tLSXJZf1pg8Y8YMl+VQkI4fP66PPvpIkvTYY48VarEV7utf//qXqlSpopSUFE2bNs3V6bgNL1cnAKDozZw5U3v27HF1Gvly9OhRTZkyRZI0ZMgQ9e3b17UJAQD+ltdff10jR46Ut7e3q1PJsxkzZujYsWOSlKOY3rJlS23ZskWSVLly5aJOLV8WLFigs2fPSrpWSIf7mTVrlhITEyVJwcHBhfY8I0aM0E8//aT169fr559/VtOmTQvtuQC4XnJysnbv3q3du3drw4YN2rBhgzw8Cm++Ztb46uvra7M/6/NhjRo1NH78eJv7evXqZT6uevXqhZZbQXrnnXeUmpoqHx8fPfjgg65OB4Vg+fLlunr1aqE+h7e3t4YMGaKoqCh9/PHHmjZtmipUqFCoz1kSUEgH3EzPnj313HPP2ezz8rL9VW/QoIHCwsJ02223afTo0U61n71AIEm7d+/WY489JkkKCgrSsmXLzPuu/wMHAGArL+dsd3fs2DH95z//0UMPPeTqVAqEv7+/2rVr5+o0nDJ//nxJUpMmTdSgQQMXZ+MaycnJbj0Tv1mzZoXWdmpqqjw8POTl5aW+fftq9OjRyszM1IIFCzR9+vRCe17AVUr62B0aGqpZs2YpLS1NmzZt0iuvvCJJ2rRpk1asWKH77ruv0J47P+NrYGCgAgMDCyGbwpGenq5PP/1UktS1a1eVK1fOxRm5hruPy61atSq0trO/d/fee6+ioqKUmpqqRYsWady4cYX2vCUFS7sAbiYwMFDt2rWz2W6//XabmCVLlmjevHn5Wrs1q0CQtWX/YGa1Wm3ua9Wqlfbu3asBAwYoODhYPj4+qlq1qkaMGJFjja4rV67o6aefVr169WS1WlW6dGnVqlVL9957r1auXCnp2vqed955p/mYhQsX3pTr0AJAFkfn7OTkZI0ePVqtWrVS5cqV5ePjI39/f4WHh2vevHl5aj8v59Ys8fHxeuyxx1SnTh1ZrVaVL19eHTt2tPkHaZb//ve/ateunfz9/eXj46OgoCC1a9dOEyZMyNc6nq+++qoyMjJuGJeQkKCIiAjz9dxyyy266667FBsbmyP23LlzGjJkiPz9/VW+fHkNHjxYZ8+ezXX5sT/++EMPPfSQWrRooYCAAHl7e6tChQrq1KmTzTJiWV9tz5qNLsnmK+5S7mukZ30t22Kx5HjfX3nllVyXuTl06JCGDRumkJAQ+fj4qGLFiurVq5eio6NzvNb3339frVq1UpkyZWS1WlW1alV16dLFXK7FkePHj2vXrl2SpG7dutncd/36vd9++63CwsJUqlQp3XrrrYqJiZEkzZkzR7Vr15avr6/atm2b67fefv/9d40cOVI1atSQ1WpVYGCg+vfvr/3799vEXb+W7aeffqqmTZvKarWqfv36Wrp0aY6283rsXv96vvvuO4WHh6tUqVIaO3asw/dp3759+v7772+4HTx48IbvefYlIubNm6cpU6YoODhY5cqV04ABA3ThwgWdP39eDz74oPz9/VWhQgWNGjUq15lrX3zxhbp06aJbbrlFVqtVDRo00JQpU3TlyhWbOEdrpC9fvlx33nmnypcvL6vVqtq1a2vcuHE6ffq0TdzQoUPNNr766is9+eSTCg4Otll7NTAwUM2bN5ekHMc64C5K+tid9Xnwzjvv1LRp02zWd88+4So1NVWvvfaaQkNDVbp0afn5+alFixZ69dVXlZqaatPmnj171KdPHwUGBsrb21sVK1ZUaGioRo0apePHj5tx14/hWefTLMeOHcsRk9sa6Xfffbe5b/fu3Ta5PPzww+Z969atM/fv2rVL999/v4KCgsz377777tPOnTttHp+Zmalp06apadOmKlWqlHx9fVW9enXdddddeToGfvzxR505c0ZSznH5+r8xli1bpkaNGsnPz0/t27fXvn37lJmZqalTp6pq1ary8/NTz549bf5uyZLXz+nZx6z58+drxowZqlu3rqxWq1q0aKFvvvkmR9t5/Rvm+tezYsUKhYaGymq16o033nD4Pu3YsSNP43L248ee68e3xx57TBUrVlSFChU0btw4paSk6Pjx47r77rtVpkwZBQUFaeLEicrMzLRpxzAMzZ8/X23btlW5cuVUqlQptWjRQjNnzswRa2+NdMMw9MEHH+j2229X2bJl5evrq4YNG+q5554zv1mWJfvYvmvXLj300EMKCAhQmTJlzJhWrVrplltukcS4XGAMADe9yZMnG5IMScaQIUPy/LgrV66Yj8vv6eDbb781H1+jRg2b+9atW2dYrVab58jagoKCjCNHjpixDz30UK5xkoxBgwYZhmEYd9xxh90YZ143ALhSXs/Zp0+ftnvOk2RMmTLFjP3999/N/XfccYe5Py/nVsMwjCNHjhhBQUF2YydMmGDGxsTEGB4eHnZj09LSHL7++fPnm7EtW7Y02/rss89yvD/Zn/fYsWNGtWrVcn1Ob29v44svvjBjU1NTjVatWuWIa9GiRa5j1tatWx2+1wsXLsyRe26bYdiOi1n9Gxsba+4bOHCgzfvRsmVL8zWcPXvWMAzD2LZtm1G2bNlcn8NisRjvvfee+fhPPvnEbj5Vq1Z12BeGYRiLFi0y4//zn//Y3Jf9uKpatarh6+tr036pUqWMp556Ksfz1qxZ0+Y42Llzp1G+fPlccyxTpoyxbdu2XI+P2rVr54j38PAwfv31VzPemWM3++upUqWKzeu50d8Rjv4GcfbvkezHeJ06dXK00aNHD6N169Y59j///PM27UyaNMluHu3btzdSUlJyzf/333839z/zzDN227j+b7UhQ4bY7ZvsbWY/75w+ffqG7wdwM2Dsnp9rroZhGH369DHvGzVqlGEYhnH16lWjQ4cOdp+vQ4cO5jnq7NmzRqVKlezGbty40XyurH1ZY3j2frl+y4rJnvvkyZMNwzCMxYsXm/uee+45s/309HQzl8DAQPN9+eKLLwxvb+9cn+f6v0GmTp1qN6e2bds6fJ8NwzBeeeUVM37Lli0292X/G6NWrVqGxWLJcd4eOXLkDZ/Xmc/p2d/j3MblsmXLGufPnzfjnfkbxtHryeore2rUqOHwdy2v7RiG7fiW27j84IMPGrVq1cqx/8MPP7RpZ/DgwXbz6N+/v938s2RmZhoPPPCA3TYaNmxo815nH9uv75vsOnXqZEgySpcubaSnp9/w/YBjzEgH3Ez2WdqunK19+fJlDRkyRCkpKfLy8tK0adP09ddf65lnnpF0bfbEmDFjzPgvvvhC0rV17ZYvX66vv/5a8+bN0+DBg83/oM6aNUvvvPOO+ZiePXtqy5Yt2rJli55//vkifHUAUDAcnbP9/Pw0depULV26VF9//bW+/fZbLV68WPXq1ZMkvfHGGzlmdF0vL+dWSRozZozi4+MlXZvd8uWXX+qtt94yl+h67bXXtG3bNknS6tWrzVk1r7zyiqKjo7V48WJNnDhRjRs3duqCWPXr19f9999vtmU4mBE3ZswYc5bU4MGDtX79es2ZM0dlypRRWlqaHnroISUnJ0u6tlTJjh07JEm33HKLPvroIy1dujTHTJ4sQUFBevXVV/Xf//5XmzZt0rfffquFCxeqUqVKkqSXX35Z0l/rrAYFBZmPzRqHss/Cu16bNm1Ut25dSdKaNWuUkpIiSTpy5Ig5E65Hjx6qWLGiDMPQsGHDdPHiRUnSfffdp7Vr12rSpEny8PCQYRgaP368Tpw4IemvPvby8tLcuXMVHR2tzz77TE8++aRq1aplN6cs2WeEZ+WYmz/++ENdunTR2rVr1alTJ0nXZk1Onz5dI0aM0Jo1a9SwYUNJ12Z+b9iwQZJkGIaGDBmiCxcuSJKefPJJff3113rttdfk6empS5cuadiwYbn2/ZEjRzR8+HCtWbNGnTt3lnRtpl/WBdgk547d7E6dOqVq1arp008/1bp161x2zZWjR4/q9ddf15IlS1S2bFlJ0vr16/XLL7/oo48+0pw5c8zY999/3/z5p59+0ksvvSTp2prn8+bN0/r163XXXXdJunZcvv322w6fe9u2bea3Fnx9fTV9+nR9+eWX5rf/rv9bLbsjR47oscce0/r16/X++++buUu2x9Evv/yS5/cCuFmU9LE7S3p6ujZs2KD169eb+7K+rTxjxgx99913kqSQkBAtWrRIn3/+ublG+XfffWeeo7Zu3aqEhARJ0oABA7Rx40atWrVK06dP1x133CFPT0+7OTz00EM2429QUJA5Ji9fvtzu4+6++27zvPXf//7X3L9582Yzl/79+8vLy0vJyckaPny4eTHV0aNHa926deb5MS0tTcOHDzf/Bsnqv/Lly+vTTz/Vpk2b9Mknn2jUqFF5ukZFXsfl33//XUOHDtXatWvN9z0+Pl4ffvihIiMjtXLlSvNaLT/88IP+97//SXL+c3p2R44c0YQJE/Tll1+qRYsWkqSLFy9q0aJFkuT03zDXv55WrVpp2bJlWrVqldq3b3/D96owxMfH64MPPtBHH31krvf/n//8R1euXNHixYttro2TfVxevny5PvnkE0nXltL9/PPPtXr1avPbKkuWLNGSJUscPvfSpUu1ePFiSdf+fv3ggw+0cuVK85tev/76a45lpbIcP35ckydP1oYNG3KM/1nHUXJycq7fToCTXFjEB1BAHP0nXrI/a6IwZ6SvXLnS3N+zZ09jy5Yt5lazZk3zP9IJCQmGYRjmbIoWLVoYu3fvNq5evXrD52MWOoCbkTPn7NWrVxtdu3Y1AgICDE9Pzxyxe/bsMQzD/qy2vJxbz507Z84Aslqt5qxowzCMJ5980mz38ccfNwzDMJ599llz37Jly2zi8yL7zLD+/fsbe/fuNZ9/+fLluc5Iz55jUFCQzZhyzz33mPHLly83DMMwevbsae6bNWuW+dzr16/PdcwyDMNYsGCB0b59e6N8+fI5ZnhJMhITE83Y3GYRZbE3TmV/XV9++aVhGIbx2muvmfsWL15sGIZh7Nq1y2ZWWGpqqtlGv379zPvefvttwzAMc+aSn5+fsWnTJps882L06NFmm9lnehuG7XFVqlQps+1ly5aZ+6tXr25kZmYahmEYb7zxhrl/xowZhmEYxu7du819oaGhNn0XHh5u3rdjxw7DMGyPjxYtWpi5ZJ/V37dvX8MwnD92s7+e62e2F6Xsx0L2byjcdddd5v5JkyaZ+5s0aWLuv3DhgmEYhvH444+b+5577jnzPV29erW5v2nTpmYbuc1If+yxx8x9Tz75pBmbkJBgzlS0WCzGuXPnDMOwnbF3/TcrspszZ44Zt2TJkgJ5zwBXY+x2/I2srPEgKSnJMAzDaN68ubl/9erVNu/N9ef47GPzM888Yxw/ftwcV65nbwy3t//63LPPTs5+Ttu7d69hGLZjYmxsrGEYhrFixQpzX1hYmE3bYWFh5n0rV640DMMwbr/9dkO69k2urVu3GsnJyXl9mw3DsP0b5vq+z/43RkhIiJGRkWEYhu342759ezN+7Nix5v5Vq1YZhuH85/Tsx36fPn3MtrPP6h8/frxhGM7/DZP99ZQpU8Ycb4pa9mMh+zcUso+/8+bNMwzj2qzxrBn35cuXN2OzfzPjnXfeMd/TDz/80Nz/z3/+04zP7W/Ju+++29yX/e/Xffv2mftvueUW8/cj+9iePe/rTZgwwYzL/i1A5E/JuSIGUELkdvGbrP9EF6XffvvN/Pmrr77SV199lSPGMAz9+uuvateunYYPH65p06Zpz549atmypTw9PVW/fn316NFDTz/9dJ7+ew8ANxtH5+wVK1aoX79+Dh+fNcvXnrycWw8ePGjOBq5Tp44qVqxoPr5169bmz1nn9UGDBuntt99WSkqKOZs8MDBQbdu21ZgxY9SlS5e8vfj/r1mzZurTp49WrVqladOm6e67784Rc+jQITPH+Ph4u7OUsmZxHTlyxNzXpk0b8+fw8PBcH/f2228rIiLCYZ4XLlz4Wxf8+ve//60pU6ZIujZrqXfv3uZsubJly5qvO/v4eeutt8rb29u83bp1a3PmXFbcsGHDtGTJEl2+fNl876tVq6Y77rhD48ePd+piVlnvcW4aNGhgvv4KFSqY+8PCwsyZjAEBAeb+rGMz++uJi4tz2HdhYWE2++644w7z5+zHZVbbzh672dWrV8+pC6vu27fP7jcasqtcubI58zQvsueZ/X3N3m/Xv6/+/v42r+mVV14xL/aX3a+//urwubO3kf33JCAgQLVr19b+/ftlGIYOHTpkk6ck9e7d2267jo4jwB0wdtvy8PBQr169NGvWLHOWt73zS265tW/fXvXq1dPBgwf1+uuv6/XXX1fZsmV16623atCgQRo+fLg5M7gg/fvf/9bChQslXRuXmzRpYq4hXbduXTNve68l6/VkrZGeFTd8+HDFxsbqjz/+UHh4uCwWi2rXrq3OnTvrySefVP369fOco6PzaVhYmPm+5HX8uP715OVzenY3Gped/Rsmu7Zt29q8jhvZsWNHrtcOuV716tXNb0LkxY3GZYvFogoVKujixYs2v8vZX9Njjz2Wa9vXXxfmevaOtaZNm8rPz0+XL1/W//3f/ykhISHHBXQZl4sOhXTAzWRd/OZmkfUVuJdeeklNmzbVihUrtHfvXh0+fFj79+/X/v37tXHjRu3evVteXpyyALgXR+fsd9991/x56NChGjhwoEqVKqWpU6dq48aNkpTjwkXXy8u51ZHcvurdtGlT7dy5Ux988IG2bdumX3/9VX/++adWrlypL774Qlu2bNE//vGPG710GxMnTtSqVav+9rk+a0y50Wu43qxZs8yfn3nmGXXv3l0+Pj4aM2aM9u3bJ+nG7/WNZH0o37Ztm7788ksdOnRIP/30kyTp3nvvValSpW7YRm6vpVu3bvrhhx/M5WwOHDigkydP6rPPPtPKlSu1b98+1a5d226b2T9k/9///Z/dOH9/f/Pn7AUNe/9ccPZDW259l30Jg+zHRV7avlG/OzvJ4NFHH9XmzZtvGDdkyBAtWLAgz+0W5vuanp6ulJQUWa3WPD8my995/7IfR9mPL8BdlPSxOzQ0VLNmzZLFYpGfn5/q1q1rs7yTs7n5+fnphx9+0Ny5cxUTE6NffvlF8fHx2rx5szZv3qxz587p2WefzVP7zujUqZOqVKmiU6dOafny5ercubO5VM6gQYPy1EZur2fEiBGqVq2aFi1apN27d+vgwYM6fPiwDh8+rC+//FL79+9X+fLl7bZ5/bhsb0JZSR+X77vvvjwtUzJ58mSb5VhuxNn31Rm5vacFhXG56LBGOoBCkf0/7UOGDJFhGDm25ORkde/e3Yx74IEHtHTpUv3666+6ePGi7rvvPknSzz//bP53Nvtg9neLGgBQnP3xxx/mz7NmzVLXrl31j3/8w2Z/Xtzo3Fq3bl3zw83hw4d17tw587HZ15bOOq8bhqEmTZpo5syZio2N1YULF8yZ1ZmZmVq1apXTrzUsLEw9evSQJLO4nF32HOvUqaP09PQcY0pqaqqmTp1qxmTJ3t7WrVtzff6s97RixYp67bXX1KlTJ7Vs2dLue53fsSjrg/mFCxds1h/997//bf6cffzcvXu30tPTzdv2+iM8PFwffPCBdu3apYsXL+rNN9+UdG0d1Oxr1+amUaNG5s+HDh3K82vJq+yv54477rD798AjjzzidNvOHrvZ5Wc94OIk+2uaP3++3ffVURE9exvbt283fz537pwOHz4s6dr7lNsavY7ev+zHUePGjfP2ggA3URLGbn9/f7Vr105t27ZVy5Ytcy2i2zu/2MutUqVKmjRpkqKjo3X69GkdOXJEZcqUkXRtlv+NZL0XzozJHh4eeuCBByRdu55D1vVQJPvjcvbXcv3t7K+nR48e+uSTT7Rv3z5dunRJ48ePl3TtW3U//vijw7yKclzO6+f0/LSdl79hsnOncfnbb7/N9X3NGlvz0kb2Y+vnn3/W5cuXJV37Z0bWNXyyy8u4XLp0adWoUSNvLwh2Mb0TKIGyLqKSdcGULFl/TFWqVMnma1v50bVrV1WqVEkJCQn65JNPVKFCBXXt2lUZGRk6evSofvjhB+3Zs8e8CFXWH2KtW7dW1apVdfHiRZsLVGVdmC37f8G///57ffXVVypbtqzq16+f4+tNAHAzq1GjhvlPxBdeeEHdu3fXf/7zH6cu3peXc2vFihXVvXt3rV+/XikpKfrXv/6lJ554QocPH9Z7771nxg4YMECS9PrrrysmJkZ33XWXqlevrtKlS5sXlsxqMz8mTpxot+hboUIF9ezZU+vWrdPhw4d19913a/jw4SpbtqyOHTum3bt3a8WKFdq6datq1qypvn37at26dZKuvXelSpVS6dKlNWHChFzbr1Gjhg4ePKhz587p1VdfVfPmzTVz5kydP38+1/hbbrlFv//+u6RrhZKwsDD5+/ubF/uy54EHHlBERITS09PNmYlVqlQxL94pXZvp16hRI+3fv1+nT5/WoEGDNHToUG3bts38yrmPj4+5dMBjjz2m06dPq2vXrgoJCZGXl5fNhddu1B9t27Y1f961a5cefPBBh/HOatGihZo2baqff/5Zmzdv1uDBg3X//ffL29tbR48e1fbt27Vy5UqHs+HtcfbY/TtiYmL+dhsFaeDAgZo5c6Yk6YknntD58+fVvHlzXbhwQYcPH9bXX3+tGjVq6OOPP7bbxoABA8yLuL/77ruqUqWK6tWrpxkzZpjHTffu3Z36qr0kc7Zs7dq1bS7MC5QEJW3stmfgwIHau3evJGns2LG6ePGiLBaLzczyrNx+/PFHPfbYY+rXr5/q1aungIAA7d271ywc5iW3W265RefPn9epU6f02WefqUaNGnlaauvf//633nrrLUkyx+XsFwiXrn3zq2LFijp37px27NihcePG6a677tK6devMC5sHBASoa9eukq7NlC5btqzat2+vatWqKT093YzLy+u5flwu6ItuOvs53RnO/g3zdxw9evRvt1GQBg0aZF5o9sEHH9Tzzz+vevXqKSEhQQcPHtTatWvVs2dPTZ482W4bAwcO1Jdffinp2vnDarUqICDAXBpQunYRXGf/6RAXFyfp2rHt6OK9yKOCXnQdQNHLfgGQvFyAM/tFKXLbsl/s5kbsXWzUMAxj7dq15sWqctuyx9epU8duXOPGjY309HTDMAwjLS3NvABP9m3+/Pl5zhkAXCmv5+zsF3TM2nx9fW0ubPXtt98ahmH/gmV5PbcePnw413Nr1pZ10U/DMIyXXnrJbpyHh4fx/fffO3z9119sNLuOHTvafd5jx44Z1apVczh+ZV1EMTU11WjVqlWO+7Nf/Cz7GJT9Il1ZW0BAgNGgQYMcbRuG7YXcrn/fb3RR7OwXEZNkRERE5IjZtm2beSGr6zeLxWK89957Zuzw4cPtvh+lSpUyDh8+7LA/DOOvi6VlvzilYdg/ruy9RnsXdNu5c6dRvnx5h313ozbs5eLMsWuvjaKW/RyQ/e+X7Bc7y/rdNozcLxRqGIYxadIkh+9p9r6x18Yzzzxj9/FBQUHGkSNHbphfdmfOnDE8PDwMScZTTz31N98poPhg7J6fa672XL161Wjfvr3d5+zQoYORkpJiGIZhbNmyxeG5LCoqymw3tzHcMGwvZHl9P9kbV7I0atTI5nHvvPNOjphVq1YZ3t7euebn7e1tfPHFF2Zs586d7b6WypUrmxeNtif7593sF6c0DOfHX3vjjTOf0+21YS8XZ/6GudHfTEXF2fHX3kXnBw8e7PBYzt43ubWRmZlp9O/f3+7jGzZsaJw/f/6G+WX3008/mTHvvvvu33qfcA1LuwAoNL169dKOHTv04IMPqlq1avL29lZAQIBCQ0MVERGhZcuWmbGRkZHq06ePatSoIT8/P3l7e6tmzZoaNWqUvvnmG/M/p15eXvryyy/Vrl27PK/FBwA3o/vuu0/vv/++6tWrJ19fX912221av369mjZtmuc28npurV27tnbt2qVx48apVq1a8vb2Vrly5dShQwctWbJEr776qtlmr1699Mgjj6hp06a65ZZb5OnpqQoVKqhbt27asGGDzUwqZ02aNMnufdWrV9fu3bv19NNPq2HDhvL19VXZsmXVsGFDDR48WF9++aVCQkIkSd7e3lq/fr0efPBBlStXTuXKldOAAQPMi1xJ19ZkzfLEE0/o5ZdfNt+njh076ptvvrE7m3by5Ml6+OGHVaVKFadnBWX/unhut6W/Ll42ZMgQVa1aVV5eXrrlllvUo0cPff311xo9erQZO2jQIA0ZMkQNGjSQv7+/PD09FRgYqL59+2rLli0O10fPMmzYMEnXvjp88OBBp15PXtx6662Ki4vTqFGjVLt2bfn4+Kh8+fJq2rSpRo0apejo6Hy37cyx626mTp2qNWvWqEePHqpYsaK8vb1VtWpVtWvXTq+++qrNDLbssh+zr732mpYuXao77rhD5cqVM88RY8eO1a5du1SrVi2nclq1apW5tMLQoUPz/dqAm1VJHLtzY7VatXHjRvNbXqVKlZKvr6+aNWumqKgoff311/Lx8ZF0bTmLCRMm6Pbbb1flypXl5eWlMmXK6LbbbtPs2bPtfpssu3fffVf/+te/cl3y4kayj8NeXl7mci/Z9enTR1u3btV9992nwMBAeXl5qVKlSrr33nv1448/2lwofcyYMerfv7/q1KmjMmXKyMvLS1WrVtWgQYP0/fff26zBnRsvLy8zp40bN+rixYtOv6YbceZzurOc+RvG3SxcuFCffPKJ7rjjDvn7+8vHx0fVq1dX586d9c4779gs65cbi8WiRYsWae7cuWrdurVKly4tq9Wq+vXr69lnn1VsbKzNN/TzImtpJKvVWiDf0INkMQwu3woAAAD3YhhGjiL3+vXr1bNnT0nS3XffbX4Ft6S7dOmSatWqpbNnz+qZZ57Ra6+95uqUUMBatWqlnTt3SrrW36VLly6U52ndurV++ukncykmAIDzTpw4obp16yo1NVXvvfeeWxefS6qAgACdO3dOAQEBSkhIKJTnSEtLU82aNXXq1CmNHj3aZtkn5B8z0gEAAOB2hgwZolmzZikuLk7Hjh3TypUrNWrUKPP+/v37uzC74qVMmTJ65plnJEkffPCBkpOTXZwRCsrVq1e1detW7du3T9K1NfkLq4j+ww8/mBf3tTcbHgBwYyEhIRoxYoQkacaMGWL+q/tITk7WqlWrzAsE53bh1YKydOlSnTp1SlarVc8991yhPU9Jw4x0AAAAuJ2OHTtq8+bNud7Xv39/ff75504vywLcbPr27WvzzYtXX301T8skAACAghcaGqo9e/aYtxcvXszkjpuMl6sTAAAAAAragAEDlJ6ergMHDujChQsqW7asWrRooaFDh2rw4MEU0VGiBAYGasiQIXryySddnQoAACWaxWJRtWrV9Oijj1JEvwnla0b67Nmz9cYbbyg+Pl4tWrTQrFmz1Lp1a7vxM2bM0Jw5c3T8+HEFBATovvvuU1RUlHx9fSVJL774Yo6v/zVo0EC//vqrs6kBAAAAAAAAAFCgnJ6RvmTJEkVERGju3Llq06aNZsyYoe7du+vAgQMKDAzMEb9o0SI9++yz+vjjj/WPf/xDv/32m4YOHSqLxaK33nrLjGvSpIk2bdr0V2JeTJYHAAAAAAAAALie09Xqt956SyNHjtSwYcMkSXPnztXatWv18ccf69lnn80R/+OPP6pt27YaOHCgJKlmzZoaMGCAtm3bZpuIl5eCgoLylENKSopSUlLM24ZhKDU1VQEBAXxNFwCAYsgwDF28eFFly5ZlrAYAoBhirAYAwDEPZ4JTU1O1c+dOdenS5a8GPDzUpUsXbd26NdfH/OMf/9DOnTu1fft2SdKRI0e0bt069erVyybu4MGDqlKlimrXrq1Bgwbp+PHjdvOIioqSv7+/uZUvX16BgYG6ePGiMy8HAAAUkYsXL8rf35+xGgCAYoqxGgAAx5wqpJ89e1YZGRmqXLmyzf7KlSsrPj4+18cMHDhQU6dOVbt27eTt7a06deqoY8eOeu6558yYNm3aaMGCBVq/fr3mzJmj33//Xe3bt7c7gEdGRioxMdHcTpw44czLAAAAAAAAAAAgz5wqpOdHTEyMXnnlFb333nvatWuXVqxYobVr1+qll14yY3r27Kn7779fzZs3V/fu3bVu3TpduHBBS5cuzbVNq9WqcuXK2WwAAAAAAAAAABQGp9ZIDwgIkKenp86cOWOz/8yZM3bXN580aZIefPBBjRgxQpLUrFkzJScn6+GHH9bzzz8vD4+ctfzy5curfv36OnTokDPpAQAAAAAAAABQ4Jyake7j46OwsDBFR0eb+zIzMxUdHa3w8PBcH3P58uUcxXJPT09J1y5mkptLly7p8OHDCg4OdiY9AAAAAAAAAAAKnFMz0iUpIiJCQ4YMUatWrdS6dWvNmDFDycnJGjZsmCRp8ODBqlq1qqKioiRJvXv31ltvvaWWLVuqTZs2OnTokCZNmqTevXubBfWnnnpKvXv3Vo0aNXTq1ClNnjxZnp6eGjBgQAG+VAC4uRmGofT0dGVkZLg6FbiAt7e3OW4WtDlz5mjOnDk6evSoJKlJkyZ64YUX1LNnT0lSx44dtXnzZpvHPPLII5o7d26B5ZCRkaG0tLQCaw8Fw9PTU15eXrJYLK5OBQAAACj2+NxefBXEZ2qnC+n9+/dXQkKCXnjhBcXHxys0NFTr1683L0B6/PhxmxnoEydOlMVi0cSJE/XHH3+oUqVK6t27t6ZNm2bGnDx5UgMGDNC5c+dUqVIltWvXTrGxsapUqdLfenEA4C5SU1N1+vRpXb582dWpwEUsFouqVaumMmXKFHjb1apV06uvvqp69erJMAwtXLhQffr00e7du9WkSRNJ0siRIzV16lTzMX5+fgX2/JcuXdLJkyftflMNruXn56fg4GD5+Pi4OhUAAACg2OJze/FWEJ+pLYYbfGpNSkqSv7+/EhMTufAoALeTmZmpgwcPytPTU5UqVZKPjw+zQ0sYwzCUkJCgy5cvq169eoU2Mz27ChUq6I033tDw4cPVsWNHhYaGasaMGXl+fEpKilJSUszbSUlJCgkJyTFWZ2Rk6ODBg/Lz81OlSpU4tosRwzCUmpqqhIQEZWRkqF69erle2wYA4B74XA0A+cfn9uKtoD5TOz0jHQBQtFJTU5WZmamQkJACnQWMm0ulSpV09OhRpaWlFWohPSMjQ8uWLVNycrLN9U8+++wzffrppwoKClLv3r01adIkh8djVFSUpkyZcsPnS0tLk2EYqlSpkkqVKlUgrwEFp1SpUvL29taxY8eUmpoqX19fV6cEAAAAFDt8bi/+CuIzNYV0ALhJMBO0ZCvs2Qz79u1TeHi4rl69qjJlymjlypVq3LixJGngwIGqUaOGqlSpor1792rChAk6cOCAVqxYYbe9yMhIRUREmLezZqTbw2yN4otzDwAAAJA3/O1cfBXEZ04K6QAAQA0aNFBcXJwSExO1fPlyDRkyRJs3b1bjxo318MMPm3HNmjVTcHCwOnfurMOHD6tOnTq5tme1WmW1WosqfQAAAAAAChX/JgEA5EvNmjXVoEEDhYaGqlGjRho4cKCSk5ML7bni4uIkSSNGjNC3335boO1v27ZNLVq0UP369dWpUyf98ccfucZNmzZNoaGh5lauXDlz1nVMTIxKlSplc/+VK1ckSfPnz7fZHxAQoHvvvdds94033lDTpk3VuHFj3XPPPbpw4UKBvr688PHxUd26dRUWFqaoqCi1aNFCM2fOzDW2TZs2kqRDhw4VZYpFxl2O7eTkZLVp00YtWrRQixYt1KNHDx09etS8P6/HPQAAAICbk7t8tpGk++67T1WqVJHFYsnxmXnhwoVq1qyZQkND1bJlS61bt65AnzsLhXQAuEmlpqba3dLT0/Mcm5aWlu8clixZori4OP3vf/9TYmKiFixY8Ddf1Y199NFHuvPOOwusvczMTA0aNEgzZszQb7/9pl69emn8+PG5xj7//POKi4tTXFyctm3bJm9vbw0aNMi8P2tWd9aWteb3sGHDbPYHBQWZj9u4caPmz5+vrVu36pdfflFYWJief/75Ant9+ZWZmWlzsdDssv44Cg4OLpTn5tguGKVKldKmTZu0Z88e7dmzR927d9fjjz8uybnjHgAAAED+8Nmm4IwaNcr8LJrd+fPn9eijj2rjxo2Ki4vTrFmzNHTo0AJ97iws7QIAN6moqCi799WrV08DBw40b0+fPt3uwFujRo2/Pcikpqbq8uXLuuWWWyRdW2979OjRunz5sq5evaqBAwdq4sSJkqTVq1fr+eefl4eHh9LT0zVt2jT16dNH8fHxeuyxx3T06FFduXJFffr00csvv5zjuTp27Kjx48erb9++Gjp0qKxWqw4dOqQTJ06oadOmWrx4sXx8fJSWlqZJkybpm2++UWpqqurXr6/333/fzDHLzp075eXlZQ7yjzzyiCZOnKirV686vLDiqlWrFBISorCwMKfeq23btunPP//U3XffLUnas2eP2rVrp7Jly0qSevXqpY4dO2r27NlOtft3REZGqmfPnqpevbouXryoRYsWKSYmRhs2bNDhw4e1aNEi9erVSxUrVtTevXv1xBNPqEOHDmrevHmh5MOxXTDHtoeHh3lcGYahpKQkc13A/B73AAAAAPKOzzYF89lGkrp06ZLr68rMzJRhGLp48aKCgoJ04cIFVatW7W+9V/YwIx0AkG/9+/dXaGiogoKC5OHhoX/961+Srn2lKzo6Wrt27dLOnTv13//+V7GxsZKkiRMn6v3331dcXJz27t2rO+64Q5I0ZMgQjR07Vtu3b9fu3bu1Y8cOLVu27IY5xMXFafXq1dq/f7/OnDmj//73v5KuLZdSunRpbd++XXFxcWrWrJn5R0F2x48fV40aNczbZcuWVbly5XTq1CmHzztv3jwNHz7cZt/hw4d166236rbbbtN7771n93EPPvigvL29JUlhYWHatGmT4uPjZRiGPvvsM128eFHnz5+/4WsvKH/++acGDx6sBg0aqHPnzvrpp5+0YcMGde3aVT4+Ptq0aZO6deumhg0b6sknn1S/fv20evXqIsvPFdzh2M7SpUsXBQUFadmyZeY/aPJ73AMAAAC4ubjTZ5vcBAQEaO7cubr11ltVo0YNPfTQQ4U2654Z6QBwk4qMjLR73/VXCn/qqafsxv6dK1cvWbJEoaGhSk9P1yOPPKIJEybozTff1JUrVzRmzBjFxcXJw8NDJ06cUFxcnG6//XZ17txZjz/+uO677z5169ZNoaGhSk5OVnR0tM6cOWO2fenSJR04cOCGOdxzzz3y8/OTJLVu3VqHDx+WdG3GeGJiojlAp6amqmbNmvl+rdkdO3ZM33//vRYvXmzuu/XWW3Xy5En5+/vr5MmT6tWrlwICAsw/UqRra1YvXrzY/ONEku6880499dRT+uc//ylPT0/dc889kiQvr6IboufNm2f3vpCQEG3evLnIcpE4trMU1LG9adMmZWZmatq0aZo2bZrdf/IAAAAAKFh8trmmMD+3JyYmaubMmdq+fbsaNWqk1atX65577tH+/fvl4+PjVFs3QiEdAG5SzgwIBT14XM/Ly0v9+vXT008/rTfffFPPPfecAgICtHv3bnl5eenee+/V1atXJUlvvfWW/ve//+nbb7/VkCFDNGjQII0ZM0aSFBsb6/SyEtnjPT09zXXmDMPQrFmz1K1bN4ePr169uo4dO2bevnjxohITE1WlShW7j5k/f7769OmjChUqmPvKlStn/lytWjUNGDBAW7ZssSmkL1u2TE2aNFHjxo1t2hszZozNe1CtWjWb9koaju1r/u6xnZ2Hh4dGjhypevXq6b333svXcQ8AcJ05c+Zozpw55kWjmzRpohdeeEE9e/aUdO0r9Nf/4/uRRx7R3LlzizpVAEA2fLa5piA/21xv48aNKl++vBo1aiRJ6t27tx566CEdO3ZM9erVy3e7uWFpFwBAgfjmm2/UoEEDSdL//d//qVq1avLy8tKBAwe0ceNGM+7XX39VkyZNNG7cOI0ePVqxsbEqU6aM7rzzTr366qtm3KlTp3Ty5Ml859O3b1+9/fbbunz5siTp8uXL+t///pcjLiwsTGlpaeYVxd9//3317t3b7h8GmZmZmj9/fo5lXU6fPq3MzExJ14qSa9asUcuWLW1iclsOJuuxWTm+8MILeuaZZ5x8tShMN+uxHR8fr//7v/8zby9ZssRc197Z4x4A4FrVqlXTq6++qp07d2rHjh3q1KmT+vTpY3P+HzlypE6fPm1ur7/+ugszBgAURzfrZxtHateurbi4OMXHx0uStm7dqvT0dIWEhOQ7L3uYkQ4AyLf+/furVKlSSk9PV40aNcxZTxMnTtSDDz6ohQsXqk6dOurUqZP5mOeee04HDhyQj4+P/Pz8NGfOHEnSZ599poiICDVt2lQWi0WlS5fW+++/n++LhEyYMEEpKSlq06aN+TW4CRMmqEmTJjZxHh4e+vTTT/XII4/o6tWrqlKliv7zn/+Y9/fq1UtTp05Vq1atJF1bJsPDw0OdO3e2aee///2v5syZIy8vL6Wnp+v+++/XsGHDzPsPHDiguLg4rVu3Lkeu3bp1U2ZmplJTU/Xggw9q3Lhx+XrNKDjucGwfP35cjzzyiDIyMmQYhurUqaNPP/1U0o2PewBA8dK7d2+b29OmTdOcOXMUGxtrnv/9/PwUFBSU5zZTUlKUkpJi3k5KSiqYZAEAxYo7fLaRpLvuukt79uyRdO2bWfXq1VNMTIxuvfVWPf/88+rUqZO8vb3l5eWlpUuXFsokIYthGEaBt1rEkpKS5O/vr8TExBL9VXgA7unq1av6/fffVatWLWaLlmA3+3Fgb6y+2V9XSUAfAchyZU1XV6dQJEr9c+ONg1woIyNDy5Yt05AhQ7R79241btxYHTt21P/+9z8ZhqGgoCD17t1bkyZNMtejzc2LL76oKVOm5NjP52o4cvbJga5OoUgEvLnI1SngJsPfzMVfQfQRM9IBAAAAACjm9u3bp/DwcF29elVlypTRypUrzeuuDBw4UDVq1FCVKlW0d+9eTZgwQQcOHNCKFSvsthcZGamIiAjzdlJSUqF8DR4AAHdBIR0AAAAAgGKuQYMGiouLU2JiopYvX64hQ4Zo8+bNaty4sR5++GEzrlmzZgoODlbnzp11+PBh1alTJ9f2rFarrFZrUaUPAMBNj4uNAgAAAABQzPn4+Khu3boKCwtTVFSUWrRooZkzZ+Ya26ZNG0nSoUOHijJFAADcGoV0ALhJZGZmujoFuJAbXNLEIXd/fTczzj0AUDxlZmbaXCw0u7i4OElScHBwEWYEAOBv5+KrID5zsrQLABRzPj4+8vDw0KlTp1SpUiX5+PiYV7NGyWAYhhISEmSxWOTt7e3qdAqUt7e3LBaLEhISVKlSJY7tYsQwDKWmpiohIUEeHh7y8fFxdUoAUGJFRkaqZ8+eql69ui5evKhFixYpJiZGGzZs0OHDh7Vo0SL16tVLFStW1N69e/XEE0+oQ4cOat68uatTB4ASgc/txVtBfaamkA4AxZyHh4dq1aql06dP69SpU65OBy5isVhUrVo1eXp6ujqVAuXp6alq1arp5MmTOnr0qKvTQS78/PxUvXp1eXjwRUYAcJU///xTgwcP1unTp+Xv76/mzZtrw4YN6tq1q06cOKFNmzZpxowZSk5OVkhIiPr166eJEye6Om0AKDH43F78FcRnagrpAHAT8PHxUfXq1ZWenq6MjAxXpwMX8Pb2drsiepYyZcqoXr16SktLc3UquI6np6e8vLyYTQMALjZv3jy794WEhGjz5s1FmA0AIDd8bi/eCuIzNYV0ALhJZH0Fyd2W9gCkawVbd/1HAQAAAICSgc/t7o3v6AIAAAAAAAAA4ACFdAAAAAAAAAAAHKCQDgAAAAAAAACAAxTSAQAAAAAAAABwgEI6AAAAAAAAAAAOUEgHAAAAAAAAAMABCukAAAAAAAAAADhAIR0AAAAAAAAAAAcopAMAAAAAAAAA4ACFdAAAAAAAAAAAHKCQDgAAAAAAAACAAxTSAQAAAAAAAABwgEI6AAAAAAAAAAAOUEgHAAAAAAAAAMABCukAAAAAAAAAADhAIR0AAAAAAAAAAAcopAMAAAAAAAAA4ACFdAAAAAAAAAAAHKCQDgAAAAAAAACAAxTSAQAAAAAAAABwgEI6AAAAAAAAAAAOUEgHAAAAAAAAAMABCukAAAAAAAAAADjg5eoEAAAAAAAAABStZ/atdnUKReL1Zr1dnQLcBDPSAQAAAAAAAABwgEI6AAAAAAAAAAAOUEgHAAAAAAAAAMABCukAAAAAAAAAADhAIR0AAAAAAAAAAAcopAMAAAAAAAAA4ACFdAAAAAAAAAAAHKCQDgAAAAAAAACAAxTSAQAo4ebMmaPmzZurXLlyKleunMLDw/XVV1+Z91+9elVjx45VxYoVVaZMGfXr109nzpxxYcYAAAAAABQtL1cnAAAAXKtatWp69dVXVa9ePRmGoYULF6pPnz7avXu3mjRpoieeeEJr167VsmXL5O/vr3Hjxunee+/VDz/84PRzpaamKjU1Ncd+Dw8PeXl52cTZY7FY5O3tna/YtLQ0GYZRpLGS5OPjk6/Y9PR0ZWZmFkist7e3LBZLocZmZGQoIyOjQGK9vLzk4eFRbGIzMzOVnp5uN9bT01Oenp7FJtYwDKWlpRVIbPbfz8KKlRz/LnOOyD22qM8RqRnXfh+8PTL1/0OVnmlRpmGx32622IxMizIKKNbLI1Me+Yk1LMrIdBybpaDOEdn7AQAA3LwopAMAUML17t3b5va0adM0Z84cxcbGqlq1apo3b54WLVqkTp06SZLmz5+vRo0aKTY2VrfffnuubaakpCglJcW8nZSUJEl688035evrmyO+Xr16GjhwoHl7+vTpdgtwNWrU0NChQ83bM2fO1OXLl3ONrVKlikaOHGnenj17thITE3ONrVSpksaMGWPe/vDDD5WQkJBrrL+/v8aPH2/eXrBggU6dOpVrrJ+fn55++mnz9meffaZjx47lGuvt7a3nnnvOvL106VIdPHgw11hJmjx5svnzypUr9csvv9iNjYyMNIs5a9as0Z49e+zGPvXUUypdurQkacOGDdqxY4fd2Mcff1zly5eXJEVHR2vr1q12Y0ePHq3AwEBJ0pYtW7R582a7sSNGjFDVqlUlSbGxsdq0aZPd2CFDhqhmzZqSpJ07d9p8o+J6AwYMUP369SVJ+/bt0xdffGE39r777lOTJk0kSfv379fy5cvtxvbp00ehoaGSpEOHDunzzz+3G9uzZ0+1bt1aknT8+HEtXLjQbmyXLl3Utm1bSdLp06f10Ucf2Y2944471LFjR0lSQkKC5syZYzc2PDxc3bp1kyQlJiZq5syZdmNbtWqlu+66S5J0+fJlTZ8+3W5sixYt1LdvX0nXCsJRUVF2Yxs3bqz777/fvO0olnPENa4/R/xDkjSueaz8vK8Vjb89WUu7E6rYbfeRpj/J33ptPPjuVA39dKaa3diHGu9SQKlrfbU1PkQ/nq5uN/bBhnEKLn1JkrTjzyra/Ectu7EP1N+n6mWv9euehCBtOlHHbmy/uv9T0///c0GdI7L3AwAAuHlRSAcAAKaMjAwtW7ZMycnJCg8P186dO5WWlqYuXbqYMQ0bNlT16tW1detWu4X0qKgoTZkypVBznTX9hCTpymX7MyzPxKeacZJ08bL9mYXnz6bZxCZetj+T9mJShm3sFfszXq9czrSJTbqSYjc2Lc2wzffqFbuxAAAAAICiYzEcfW/wJpGUlCR/f38lJiaqXLlyrk4HAICbzr59+xQeHq6rV6+qTJkyWrRokXr16qVFixZp2LBhNrPLJal169a688479dprr+XaXm4z0kNCQpSQkJDrWJ2fZRuyCs6GYb/gLVlksfzVrmGkS7L3p09hxUoWi/ffih31eO4zOFnapehii8NyLSztwtIu18cW9dIuV7669g0md1/apXTvjddiS9jSLnyuRl6cfXLgjYPcQMCbi1ydQpF4Zt9qV6dQJF5v1vvGQUAeMCMdAACoQYMGiouLU2JiopYvX64hQ4Y4XHbjRqxWq6xWa479Pj4+eSooOFN0yF54vnFs3v/0KU6xeXk/shcZXRWbvTjrbrEeHh55Pi6LQ6zFYrmpYiXnfu8LKzZ78ftmiC3q3/sMz5zFdS8PQ47+OZidp4chT1fHWgx5euYxtpDOEQAA4OZEIR0AAMjHx0d169aVJIWFhemnn37SzJkz1b9/f6WmpurChQvmOtiSdObMGQUFBbkoWwAAAAAAipaHqxMAAADFT2ZmplJSUhQWFiZvb29FR0eb9x04cEDHjx9XeHi4CzMEAAAAAKDoMCMdAIASLjIyUj179lT16tV18eJFLVq0SDExMdqwYYP8/f01fPhwRUREqEKFCipXrpweffRRhYeH273QKAAAAAAA7oYZ6QAAlHB//vmnBg8erAYNGqhz58766aeftGHDBnXt2lWS9Pbbb+uf//yn+vXrpw4dOigoKEgrVqxwcdYAAJQcc+bMUfPmzVWuXDmVK1dO4eHh+uqrr8z7r169qrFjx6pixYoqU6aM+vXrpzNnzrgwYwAA3A8z0gEAKOHmzZvn8H5fX1/Nnj1bs2fPLqKMAABAdtWqVdOrr76qevXqyTAMLVy4UH369NHu3bvVpEkTPfHEE1q7dq2WLVsmf39/jRs3Tvfee69++OEHV6cOAIDboJAOAAAAAEAx1rt3b5vb06ZN05w5cxQbG6tq1app3rx5WrRokTp16iRJmj9/vho1aqTY2FiWYgMAoICwtAsAAAAAADeJjIwMLV68WMnJyQoPD9fOnTuVlpamLl26mDENGzZU9erVtXXrVrvtpKSkKCkpyWYDAAD2UUgHAAAAAKCY27dvn8qUKSOr1apRo0Zp5cqVaty4seLj4+Xj46Py5cvbxFeuXFnx8fF224uKipK/v7+5hYSEFPIrAADg5kYhHQAAAACAYq5BgwaKi4vTtm3bNHr0aA0ZMkS//PJLvtuLjIxUYmKiuZ04caIAswUAwP3kq5A+e/Zs1axZU76+vmrTpo22b9/uMH7GjBlq0KCBSpUqpZCQED3xxBO6evXq32oTAAAAAICSwsfHR3Xr1lVYWJiioqLUokULzZw5U0FBQUpNTdWFCxds4s+cOaOgoCC77VmtVpUrV85mAwAA9jldSF+yZIkiIiI0efJk7dq1Sy1atFD37t31559/5hq/aNEiPfvss5o8ebL279+vefPmacmSJXruuefy3SYAAAAAACVZZmamUlJSFBYWJm9vb0VHR5v3HThwQMePH1d4eLgLMwQAwL04XUh/6623NHLkSA0bNkyNGzfW3Llz5efnp48//jjX+B9//FFt27bVwIEDVbNmTXXr1k0DBgywmXHubJsAAAAAAJQUkZGR+u6773T06FHt27dPkZGRiomJ0aBBg+Tv76/hw4crIiJC3377rXbu3Klhw4YpPDxct99+u6tTBwDAbThVSE9NTdXOnTttrgbu4eGhLl262L0a+D/+8Q/t3LnTLJwfOXJE69atU69evfLdJlcXBwAAAACUFH/++acGDx6sBg0aqHPnzvrpp5+0YcMGde3aVZL09ttv65///Kf69eunDh06KCgoSCtWrHBx1gAAuBcvZ4LPnj2rjIwMVa5c2WZ/5cqV9euvv+b6mIEDB+rs2bNq166dDMNQenq6Ro0aZS7tkp82o6KiNGXKFGdSBwAAAADgpjRv3jyH9/v6+mr27NmaPXt2EWUEAEDJk6+LjTojJiZGr7zyit577z3t2rVLK1as0Nq1a/XSSy/lu02uLg4AAAAAAAAAKCpOzUgPCAiQp6enzpw5Y7Pf0dXAJ02apAcffFAjRoyQJDVr1kzJycl6+OGH9fzzz+erTavVKqvV6kzqAAAAAAAAAADki1Mz0n18fBQWFmZzNfDMzExFR0fbvRr45cuX5eFh+zSenp6SJMMw8tUmAAAAAAAAAABFxakZ6ZIUERGhIUOGqFWrVmrdurVmzJih5ORkDRs2TJI0ePBgVa1aVVFRUZKk3r1766233lLLli3Vpk0bHTp0SJMmTVLv3r3NgvqN2gQAAAAAAAAAwFWcLqT3799fCQkJeuGFFxQfH6/Q0FCtX7/evFjo8ePHbWagT5w4URaLRRMnTtQff/yhSpUqqXfv3po2bVqe2wQAAAAAAAAAwFWcLqRL0rhx4zRu3Lhc74uJibF9Ai8vTZ48WZMnT853mwAAAHB/Z58c6OoUikTAm4tcnQIAAAAAJzm1RjoAAAAAAAAAACUNhXQAAAAAAAAAABygkA4AAAAAAAAAgAMU0gEAAAAAAAAAcIBCOgAAAAAAAAAADlBIBwAAAAAAAADAAQrpAAAAAAAAAAA4QCEdAAAAAAAAAAAHKKQDAAAAAAAAAOAAhXQAAAAAAAAAABzwcnUCAAAAANzPM/tWuzqFIvN6s96uTgEAAACFjBnpAAAAAAAAAAA4QCEdAAAAAAAAAAAHKKQDAAAAAAAAAOAAhXQAAAAAAAAAABygkA4AAAAAAAAAgAMU0gEAAAAAAAAAcIBCOgAAAAAAAAAADlBIBwAAAAAAAADAAQrpAAAAAAAAAAA4QCEdAAAAAAAAAAAHKKQDAAAAAAAAAOAAhXQAAAAAAAAAABygkA4AAAAAAAAAgAMU0gEAAAAAAAAAcIBCOgAAAAAAAAAADlBIBwAAAAAAAADAAQrpAAAAAAAAAAA4QCEdAAAAAAAAAAAHKKQDAFDCRUVF6bbbblPZsmUVGBiovn376sCBAzYxHTt2lMVisdlGjRrloowBAAAAAChaFNIBACjhNm/erLFjxyo2NlYbN25UWlqaunXrpuTkZJu4kSNH6vTp0+b2+uuvuyhjAAAAAACKlperEwAAAK61fv16m9sLFixQYGCgdu7cqQ4dOpj7/fz8FBQUlKc2U1JSlJKSYt5OSkoqmGQBAAAAAHABZqQDAAAbiYmJkqQKFSrY7P/ss88UEBCgpk2bKjIyUpcvX7bbRlRUlPz9/c0tJCSkUHMGAAAAAKAwMSMdAACYMjMzNX78eLVt21ZNmzY19w8cOFA1atRQlSpVtHfvXk2YMEEHDhzQihUrcm0nMjJSERER5u2kpCSK6QAAAACAmxaFdAAAYBo7dqx+/vlnff/99zb7H374YfPnZs2aKTg4WJ07d9bhw4dVp06dHO1YrVZZrdZCzxcAAAAAgKLA0i4AAECSNG7cOK1Zs0bffvutqlWr5jC2TZs2kqRDhw4VRWoAAAAAALgUM9IBACjhDMPQo48+qpUrVyomJka1atW64WPi4uIkScHBwYWcHQAAAAAArseMdAAASrixY8fq008/1aJFi1S2bFnFx8crPj5eV65ckSQdPnxYL730knbu3KmjR4/qyy+/1ODBg9WhQwc1b97cxdkDAOD+oqKidNttt6ls2bIKDAxU3759deDAAZuYjh07ymKx2GyjRo1yUcYAALgfCukAAJRwc+bMUWJiojp27Kjg4GBzW7JkiSTJx8dHmzZtUrdu3dSwYUM9+eST6tevn1avXu3izAEAKBk2b96ssWPHKjY2Vhs3blRaWpq6deum5ORkm7iRI0fq9OnT5vb666+7KGMAANwPS7sAAFDCGYbh8P6QkBBt3ry5iLIBAADXW79+vc3tBQsWKDAwUDt37lSHDh3M/X5+fgoKCspTmykpKUpJSTFvJyUlFUyyAAC4KWakAwAAAABwE0lMTJQkVahQwWb/Z599poCAADVt2lSRkZG6fPmy3TaioqLk7+9vbiEhIYWaMwAANztmpAMAAAAAcJPIzMzU+PHj1bZtWzVt2tTcP3DgQNWoUUNVqlTR3r17NWHCBB04cEArVqzItZ3IyEhFRESYt5OSkiimAwDgAIV0AAAAAABuEmPHjtXPP/+s77//3mb/ww8/bP7crFkzBQcHq3Pnzjp8+LDq1KmTox2r1Sqr1Vro+QIA4C5Y2gUAAAAAgJvAuHHjtGbNGn377beqVq2aw9g2bdpIkg4dOlQUqQEA4PaYkQ4AAAAAQDFmGIYeffRRrVy5UjExMapVq9YNHxMXFydJCg4OLuTsAAAoGSikAwAAAABQjI0dO1aLFi3SF198obJlyyo+Pl6S5O/vr1KlSunw4cNatGiRevXqpYoVK2rv3r164okn1KFDBzVv3tzF2QMA4B4opAMAAAAAUIzNmTNHktSxY0eb/fPnz9fQoUPl4+OjTZs2acaMGUpOTlZISIj69euniRMnuiBbAADcE4V0AAAAAACKMcMwHN4fEhKizZs3F1E2AACUTFxsFAAAAAAAAAAAByikAwAAAAAAAADgAIV0AAAAAAAAAAAcoJAOAAAAAAAAAIADFNIBAAAAAAAAAHCAQjoAAAAAAAAAAA5QSAcAAAAAAAAAwAEK6QAAAAAAAAAAOEAhHQAAAAAAAAAAB7xcnUBBSk1NVWpqao79Hh4e8vLysomzx2KxyNvbO1+xaWlpMgyjSGMlycfHJ1+x6enpyszMLJBYb29vWSyWQo3NyMhQRkZGgcR6eXnJw8Oj2MRmZmYqPT3dbqynp6c8PT2LTaxhGEpLSyuQ2Oy/n4UVKzn+XeYckXss54ib5xyRvS8AAAAAAEDBc6tC+ptvvilfX98c++vVq6eBAweat6dPn263AFejRg0NHTrUvD1z5kxdvnw519gqVapo5MiR5u3Zs2crMTEx19hKlSppzJgx5u0PP/xQCQkJucb6+/tr/Pjx5u0FCxbo1KlTucb6+fnp6aefNm9/9tlnOnbsWK6x3t7eeu6558zbS5cu1cGDB3ONlaTJkyebP69cuVK//PKL3djIyEizkLNmzRrt2bPHbuxTTz2l0qVLS5I2bNigHTt22I19/PHHVb58eUlSdHS0tm7dajd29OjRCgwMlCRt2bJFmzdvths7YsQIVa1aVZIUGxurTZs22Y0dMmSIatasKUnauXOnvvrqK7uxAwYMUP369SVJ+/bt0xdffGE39r777lOTJk0kSfv379fy5cvtxvbp00ehoaGSpEOHDunzzz+3G9uzZ0+1bt1aknT8+HEtXLjQbmyXLl3Utm1bSdLp06f10Ucf2Y2944471LFjR0lSQkKC5syZYzc2PDxc3bp1kyQlJiZq5syZdmNbtWqlu+66S5J0+fJlTZ8+3W5sixYt1LdvX0nXCsJRUVF2Yxs3bqz777/fvO0olnPENZwj/nKznSOy9wUAAAAAACh4blVIL2izpp/Qlcv2Z0KeiU/VrOknzNsXL9ufWXj+bJpNbOJl+zNpLyZl2MZesT/j9crlTJvYpCspdmPT0gzbfK9esRsLAAAAAAAAALjGYjj6jv9NIikpSf7+/kpISFC5cuVy3J/fZRtmTT8hw7Bf8JYsslj+atcw0iXZezsLK1ayWLz/Vuyox6vlGsuyDUUXWxyWa2FpF5Z2uT6WpV1unnPEzbC0S9ZYnZiYmOtYnR/Z/zns7h59KsTVKRSJs08OvHGQGwh4c5GrUygSz+xb7eoUiszrzXq7OoUicWVNV1enUCRK/XOjq1NwicIYq+F+GKvdS0kZq0vKOI3C51Yz0n18fPJUTHCm4JC98Hzj2Ly/ncUpNi/vR/Yio6tisxdn3S3Ww8Mjz8dlcYi1WCw3Vazk3O99YcVmL37fDLHF4feec8Q1zvx+AgAAAACAgufh6gQAAAAAAAAAACjOKKQDAAAAAAAAAOAAhXQAAAAAAAAAABygkA4AAAAAAAAAgAMU0gEAAAAAAAAAcIBCOgAAAAAAAAAADuSrkD579mzVrFlTvr6+atOmjbZv3243tmPHjrJYLDm2u+66y4wZOnRojvt79OiRn9QAAAAAAAAAAChQXs4+YMmSJYqIiNDcuXPVpk0bzZgxQ927d9eBAwcUGBiYI37FihVKTU01b587d04tWrTQ/fffbxPXo0cPzZ8/37xttVqdTQ0AAAAAAAAAgALn9Iz0t956SyNHjtSwYcPUuHFjzZ07V35+fvr4449zja9QoYKCgoLMbePGjfLz88tRSLdarTZxt9xyS/5eEQAAAAAAAAAABcipQnpqaqp27typLl26/NWAh4e6dOmirVu35qmNefPm6YEHHlDp0qVt9sfExCgwMFANGjTQ6NGjde7cObttpKSkKCkpyWYDAAAAAAAAAKAwOFVIP3v2rDIyMlS5cmWb/ZUrV1Z8fPwNH799+3b9/PPPGjFihM3+Hj166JNPPlF0dLRee+01bd68WT179lRGRkau7URFRcnf39/cQkJCnHkZAAAAAAAAAADkmdNrpP8d8+bNU7NmzdS6dWub/Q888ID5c7NmzdS8eXPVqVNHMTEx6ty5c452IiMjFRERYd5OSkqimA4AAAAAAAAAKBROzUgPCAiQp6enzpw5Y7P/zJkzCgoKcvjY5ORkLV68WMOHD7/h89SuXVsBAQE6dOhQrvdbrVaVK1fOZgMAAAAAAAAAoDA4VUj38fFRWFiYoqOjzX2ZmZmKjo5WeHi4w8cuW7ZMKSkp+ve//33D5zl58qTOnTun4OBgZ9IDAAAAAAAAAKDAOVVIl6SIiAh9+OGHWrhwofbv36/Ro0crOTlZw4YNkyQNHjxYkZGROR43b9489e3bVxUrVrTZf+nSJT399NOKjY3V0aNHFR0drT59+qhu3brq3r17Pl8WAAAAAAAAAAAFw+k10vv376+EhAS98MILio+PV2hoqNavX29egPT48ePy8LCtzx84cEDff/+9vv766xzteXp6au/evVq4cKEuXLigKlWqqFu3bnrppZdktVrz+bIAAAAAAAAAACgY+brY6Lhx4zRu3Lhc74uJicmxr0GDBjIMI9f4UqVKacOGDflJAwAAAAAAAACAQuf00i4AAAAAAAAAAJQkFNIBAAAAAAAAAHCAQjoAAAAAAAAAAA5QSAcAAAAAAAAAwAEK6QAAAAAAAAAAOEAhHQCAEi4qKkq33XabypYtq8DAQPXt21cHDhywibl69arGjh2rihUrqkyZMurXr5/OnDnjoowBAAAAAChaFNIBACjhNm/erLFjxyo2NlYbN25UWlqaunXrpuTkZDPmiSee0OrVq7Vs2TJt3rxZp06d0r333uvCrAEAAAAAKDperk4AAAC41vr1621uL1iwQIGBgdq5c6c6dOigxMREzZs3T4sWLVKnTp0kSfPnz1ejRo0UGxur22+/PUebKSkpSklJMW8nJSUV7osAAAAAAKAQMSMdAADYSExMlCRVqFBBkrRz506lpaWpS5cuZkzDhg1VvXp1bd26Ndc2oqKi5O/vb24hISGFnzgAAAAAAIWEQjoAADBlZmZq/Pjxatu2rZo2bSpJio+Pl4+Pj8qXL28TW7lyZcXHx+faTmRkpBITE83txIkThZ06AAAAAACFhqVdAACAaezYsfr555/1/fff/612rFarrFZrAWUFAAAAAIBrMSMdAABIksaNG6c1a9bo22+/VbVq1cz9QUFBSk1N1YULF2ziz5w5o6CgoCLOEgCAkicqKkq33XabypYtq8DAQPXt21cHDhywibl69arGjh2rihUrqkyZMurXr5/OnDnjoowBAHA/FNIBACjhDMPQuHHjtHLlSn3zzTeqVauWzf1hYWHy9vZWdHS0ue/AgQM6fvy4wsPDizpdAABKnM2bN2vs2LGKjY3Vxo0blZaWpm7duik5OdmMeeKJJ7R69WotW7ZMmzdv1qlTp3Tvvfe6MGsAANwLS7sAAFDCjR07VosWLdIXX3yhsmXLmuue+/v7q1SpUvL399fw4cMVERGhChUqqFy5cnr00UcVHh6u22+/3cXZAwDg/tavX29ze8GCBQoMDNTOnTvVoUMHJSYmat68eVq0aJE6deokSZo/f74aNWqk2NhYxmsAAAoAhXQAAEq4OXPmSJI6duxos3/+/PkaOnSoJOntt9+Wh4eH+vXrp5SUFHXv3l3vvfdeEWcKAAAkKTExUZJUoUIFSdLOnTuVlpamLl26mDENGzZU9erVtXXr1lwL6SkpKUpJSTFvJyUlFXLWAADc3CikAwBQwhmGccMYX19fzZ49W7Nnzy6CjAAAgD2ZmZkaP3682rZtq6ZNm0qS4uPj5ePjo/Lly9vEVq5c2fym2fWioqI0ZcqUwk4XAFBErqzp6uoUikypf250yfOyRjoAAAAAADeJsWPH6ueff9bixYv/VjuRkZFKTEw0txMnThRQhgAAuCdmpAMAAAAAcBMYN26c1qxZo++++07VqlUz9wcFBSk1NVUXLlywmZV+5swZBQUF5dqW1WqV1Wot7JQBAHAbzEgHAAAAAKAYMwxD48aN08qVK/XNN9+oVq1aNveHhYXJ29tb0dHR5r4DBw7o+PHjCg8PL+p0AQBwS8xIBwAAAACgGBs7dqwWLVqkL774QmXLljXXPff391epUqXk7++v4cOHKyIiQhUqVFC5cuX06KOPKjw8PNcLjQIAAOdRSAcAAAAAoBibM2eOJKljx442++fPn6+hQ4dKkt5++215eHioX79+SklJUffu3fXee+8VcaYAALgvCukAAAAAABRjhmHcMMbX11ezZ8/W7NmziyAjAABKHtZIBwAAAAAAAADAAQrpAAAAAAAAAAA4QCEdAAAAAAAAAAAHKKQDAAAAAAAAAOAAhXQAAAAAAAAAABygkA4AAAAAAAAAgAMU0gEAAAAAAAAAcMDL1QkAACBJV9Z0dXUKRaLUPze6OgUAAAAAAOAkZqQDAAAAAAAAAOAAhXQAAAAAAAAAABygkA4AAAAAAAAAgAMU0gEAAAAAAAAAcICLjQIAAAAAAElSamqqUlNTc+z38PCQl5eXTZw9FotF3t7e+YpNS0uTYRhFGitJPj4++YpNT09XZmZmgcR6e3vLYrEUamxGRoYyMjLyHZsmi/mzpwxzdmaGpMxs912vKGIzJWU4iPWQIc88xmZkZMjT81p0Zmam0tPT7efg6ZmvWMMwlJaWViCx2X8/nYmVYUgZ9o8dWSySZ7Y5uOn2j52ii82UZO/30yJ55YzN7RzkjueI1Iy/Xru3R6b+f6jSMy3KNOwf79ljMzItyiigWC+PTHnkJ9awKCPTcWyWG53TvLy85OFx7X1x9PuZvR8coZAOAAAAAAAkSW+++aZ8fX1z7K9Xr54GDhxo3p4+fbrdYl2NGjU0dOhQ8/bMmTN1+fLlXGOrVKmikSNHmrdnz56txMTEXGMrVaqkMWPGmLc//PBDJSQk5Brr7++v8ePHm7cXLFigU6dO5Rrr5+enp59+2rz92Wef6dixY7nGent767nnnjNvL126VAcPHsw1VpImT55s/rxy5Ur98ssvdmMjIyPNYs6aNWu0Z88eu7FPPfWUSpcuLUnasGGDduzYYTf28ccfV/ny5SVJ0dHR2rp1q93Y0aNHKzAwUJK0ZcsWbd682TagXH3zx/suHVPlzKuSpD0+t2irb6DddvsmH1fVjCuSpF+8y+u7UpXtxt51+aRqpidLkn7zLqdvSgXbje1++Q/VTb8kSTriVUYb/Kraje105bQapSVJko57ldZav2p2Y3vu3KnWrVtfiz1+XAsXLrQb26VLF7Vt21aSdPr0aX300Ud2Y++44w517NhRkpSQkKA5c+bYjQ0PD1e3bt0kSYmJiZo5c6bd2FatWumuu+6SJF2+fFnTp0+3G9uiRQv17dv32o2MTJX+0v5xll61vFLa1DZvO4ytXE4pbeuat/3W7pPFTpE+I6CMrnb461jyW/8/WVJzL3BmlPfT1U4NzdulNv0ij8u5/3Mus6yvrnRt/Ffst7/K4+JVReWSt3ueI/5h/jSueaz8vK+9p9+erKXdCVXstvtI05/kb02RJH13qoZ+OmP/d+OhxrsUUOra+XxrfIh+PF3dbuyDDeMUXPra7+eOP6to8x+17MY+UH+fqpe9du7fkxCkTSfq2I3tV/d/avr/f963b5+++OILu7H33XefmjRpIknav3+/li9fnmtc9n5whEI6AAAAAAAocLOmn5AkXblsf4blmfhUM06SLl62P7Pw/Nk0m9jEy/Zn3V5MyrCNvWJ/VvyVy5k2sUlXUuzGpqUZtvlevWI3FgDgXiyGo+8i3CSSkpLk7++vxMRElStXrsDazT44urNHnwpxdQoAoCtruro6hSJR6p8bXZ2CSxTGWF1Sxmmp5IzVZ58ceOMgNxDw5iJXp1Akntm32tUpFJnXm/V2dQpFgrHavWWN1QkJCbmO1flZ2iVrrDYM+wVvySKL5a92DSNdjpZtKJxYyWLxznfsqMftz4J2t6VdzkUOM39256VdAl//pEQs7fLM3i9LxNIuLzfplUuz7re0y5Wv/vp7xN2Xdind+9pYzdIuAAAAAADAJXx8fPJUUMhr0UGyLTzfODbvZYriEpvnAoxX3tstrNjsxdn8xHrbKWB66lpRO0/tFlKsh64VywsiNvvr9vDwyHMfOxNrsVhcHiuLRfLK2/EgqZjEetw45rrYvLwf2YvqBRlblL/3GZ65F+G9PAw5+udgdp4eRt5/Pwsr1mLI0zOPsU6c05z5/bTbxt96NAAAAAAAAAAAbo5COgAAAAAAAAAADlBIBwAAAAAAAADAAQrpAAAAAAAAAAA4QCEdAAAAAAAAAAAHKKQDAAAAAAAAAOAAhXQAAAAAAAAAABygkA4AAAAAAAAAgAMU0gEAAAAAAAAAcIBCOgAAAAAAAAAADlBIBwAAAAAAAADAAQrpAAAAAAAAAAA4QCEdAAAAAAAAAAAHKKQDAAAAAAAAAOAAhXQAAAAAAAAAABygkA4AAAAAAAAAgAMU0gEAAAAAAAAAcIBCOgAAAAAAAAAADlBIBwAAAAAAAADAAQrpAAAAAAAAAAA4QCEdAAAAAAAAAAAHKKQDAFDCfffdd+rdu7eqVKkii8WiVatW2dw/dOhQWSwWm61Hjx6uSRYAAAAAABegkA4AQAmXnJysFi1aaPbs2XZjevToodOnT5vb559/XoQZAgAAAADgWl6uTgAAALhWz5491bNnT4cxVqtVQUFBeW4zJSVFKSkp5u2kpKR85wcAAAAAgKtRSAdw03pm32pXp1AkXm/W29UpAIqJiVFgYKBuueUWderUSS+//LIqVqxoNz4qKkpTpkwpwgwBAAAAACg8LO0CAAAc6tGjhz755BNFR0frtdde0+bNm9WzZ09lZGTYfUxkZKQSExPN7cSJE0WYMQAAAAAABYtCOgAAcOiBBx7Q3XffrWbNmqlv375as2aNfvrpJ8XExNh9jNVqVbly5Ww2AACQP1wYHAAA16OQDgAAnFK7dm0FBATo0KFDrk4FAIASgQuDAwDgeqyRDgAAnHLy5EmdO3dOwcHBrk4FAIASgQuDAwDgevmakT579mzVrFlTvr6+atOmjbZv3243tmPHjjm+YmaxWHTXXXeZMYZh6IUXXlBwcLBKlSqlLl266ODBg/lJDQAAOOnSpUuKi4tTXFycJOn3339XXFycjh8/rkuXLunpp59WbGysjh49qujoaPXp00d169ZV9+7dXZs4AAAwZV0YvEGDBho9erTOnTvnMD4qKkr+/v7mFhISUkSZAgBwc3K6kL5kyRJFRERo8uTJ2rVrl1q0aKHu3bvrzz//zDV+xYoVNl8v+/nnn+Xp6an777/fjHn99df1zjvvaO7cudq2bZtKly6t7t276+rVq/l/ZQAAIE927Nihli1bqmXLlpKkiIgItWzZUi+88II8PT21d+9e3X333apfv76GDx+usLAwbdmyRVar1cWZAwAAiQuDAwBQFJxe2uWtt97SyJEjNWzYMEnS3LlztXbtWn388cd69tlnc8RXqFDB5vbixYvl5+dnFtINw9CMGTM0ceJE9enTR5L0ySefqHLlylq1apUeeOCBHG3yFTQAAApOx44dZRiG3fs3bNhQhNkAAABnZf/c3KxZMzVv3lx16tRRTEyMOnfunOtjrFYr/xQHAMAJTs1IT01N1c6dO9WlS5e/GvDwUJcuXbR169Y8tTFv3jw98MADKl26tKRrXx+Pj4+3adPf319t2rSx2yZfQQMAAAAAIHdcGBwAgILnVCH97NmzysjIUOXKlW32V65cWfHx8Td8/Pbt2/Xzzz9rxIgR5r6sxznTJl9BAwAAAAAgd1wYHACAguf00i5/x7x589SsWTO1bt36b7XDV9AAAAAAACXFpUuXbGaXZ10YvEKFCqpQoYKmTJmifv36KSgoSIcPH9YzzzzDhcEBAChgTs1IDwgIkKenp86cOWOz/8yZMwoKCnL42OTkZC1evFjDhw+32Z/1uPy0CQAAAACAu+PC4AAAuJ5TM9J9fHwUFham6Oho9e3bV5KUmZmp6OhojRs3zuFjly1bppSUFP373/+22V+rVi0FBQUpOjpaoaGhkq5dPHTbtm0aPXq0M+kBAAAAAOB2uDA4AACu5/TSLhERERoyZIhatWql1q1ba8aMGUpOTtawYcMkSYMHD1bVqlUVFRVl87h58+apb9++qlixos1+i8Wi8ePH6+WXX1a9evVUq1YtTZo0SVWqVDGL9QAAAAAAAAAAuIrThfT+/fsrISFBL7zwguLj4xUaGqr169ebFws9fvy4PDxsV4w5cOCAvv/+e3399de5tvnMM88oOTlZDz/8sC5cuKB27dpp/fr18vX1zcdLAgAAAAAAAACg4OTrYqPjxo2zu5RLTExMjn0NGjRw+DU0i8WiqVOnaurUqflJBwAAAAAAAACAQuPUxUYBAAAAAAAAAChpKKQDAAAAAAAAAOAAhXQAAAAAAAAAABygkA4AAAAAAAAAgAMU0gEAAAAAAAAAcIBCOgAAAAAAAAAADlBIBwAAAAAAAADAAQrpAAAAAAAAAAA4QCEdAAAAAAAAAAAHKKQDAAAAAAAAAOAAhXQAAAAAAAAAABygkA4AAAAAAAAAgAMU0gEAAAAAAAAAcIBCOgAAAAAAAAAADlBIBwAAAAAAAADAAS9XJwAUlbNPDnR1CkUm4M1Frk4BAAAAAAAAcBvMSAcAAAAAAAAAwAEK6QAAAAAAAAAAOEAhHQAAAAAAAAAAByikAwAAAAAAAADgAIV0AAAAAAAAAAAcoJAOAAAAAAAAAIADFNIBAAAAAAAAAHCAQjoAAAAAAAAAAA5QSAcAAAAAAAAAwAEK6QAAAAAAAAAAOEAhHQAAAAAAAAAAByikAwAAAAAAAADgAIV0AAAAAAAAAAAcoJAOAAAAAAAAAIADFNIBAAAAAAAAAHCAQjoAAAAAAAAAAA5QSAcAAAAAAAAAwAEK6QAAAAAAAAAAOEAhHQAAAAAAAAAAByikAwAAAAAAAADgAIV0AABKuO+++069e/dWlSpVZLFYtGrVKpv7DcPQCy+8oODgYJUqVUpdunTRwYMHXZMsAAAAAAAuQCEdAIASLjk5WS1atNDs2bNzvf/111/XO++8o7lz52rbtm0qXbq0unfvrqtXrxZxpgAAAAAAuIaXqxMAAACu1bNnT/Xs2TPX+wzD0IwZMzRx4kT16dNHkvTJJ5+ocuXKWrVqlR544IFcH5eSkqKUlBTzdlJSUsEnDgAAAABAEWFGOgAAsOv3339XfHy8unTpYu7z9/dXmzZttHXrVruPi4qKkr+/v7mFhIQURboAALgllmEDAMD1KKQDAAC74uPjJUmVK1e22V+5cmXzvtxERkYqMTHR3E6cOFGoeQIA4M5Yhg0AANdjaRcAAFDgrFarrFarq9MAAMAtsAwbAACux4x0AABgV1BQkCTpzJkzNvvPnDlj3gcAAFyHZdgAACgaFNIBAIBdtWrVUlBQkKKjo819SUlJ2rZtm8LDw12YGQAAkFiGDQCAosLSLgAAlHCXLl3SoUOHzNu///674uLiVKFCBVWvXl3jx4/Xyy+/rHr16qlWrVqaNGmSqlSpor59+7ouaQAA8LewDBsAAM6hkA4AQAm3Y8cO3XnnnebtiIgISdKQIUO0YMECPfPMM0pOTtbDDz+sCxcuqF27dlq/fr18fX1dlTIAAPj/si/DFhwcbO4/c+aMQkNDXZQVAADuh0I6AAAlXMeOHWUYht37LRaLpk6dqqlTpxZhVgAAIC+yL8OWVTjPWoZt9OjRrk0OAAA3QiEdAAAAAIBijGXYAABwPQrpAAAAAAAUYyzDBgCA61FIBwAAAACgGGMZNgAAXM/D1QkAAAAAAAAAAFCcUUgHAAAAAAAAAMABCukAAAAAAAAAADhAIR0AAAAAAAAAAAcopAMAAAAAAAAA4ACFdAAAAAAAAAAAHKCQDgAAAAAAAACAAxTSAQAAAAAAAABwgEI6AAAAAAAAAAAOUEgHAAAAAAAAAMABCukAAAAAAAAAADhAIR0AAAAAAAAAAAcopAMAAAAAAAAA4ACFdAAAAAAAAAAAHKCQDgAAAAAAAACAAxTSAQAAAAAAAABwgEI6AAAAAAAAAAAO5KuQPnv2bNWsWVO+vr5q06aNtm/f7jD+woULGjt2rIKDg2W1WlW/fn2tW7fOvP/FF1+UxWKx2Ro2bJif1AAAAAAAAAAAKFBezj5gyZIlioiI0Ny5c9WmTRvNmDFD3bt314EDBxQYGJgjPjU1VV27dlVgYKCWL1+uqlWr6tixYypfvrxNXJMmTbRp06a/EvNyOjUAAAAAAAAAAAqc09Xqt956SyNHjtSwYcMkSXPnztXatWv18ccf69lnn80R//HHH+v8+fP68ccf5e3tLUmqWbNmzkS8vBQUFORsOgAAAAAAAAAAFCqnlnZJTU3Vzp071aVLl78a8PBQly5dtHXr1lwf8+WXXyo8PFxjx45V5cqV1bRpU73yyivKyMiwiTt48KCqVKmi2rVra9CgQTp+/LjdPFJSUpSUlGSzAQAAAAAAAABQGJwqpJ89e1YZGRmqXLmyzf7KlSsrPj4+18ccOXJEy5cvV0ZGhtatW6dJkybpzTff1Msvv2zGtGnTRgsWLND69es1Z84c/f7772rfvr0uXryYa5tRUVHy9/c3t5CQEGdeBgAAAAAAAAAAeVboC5FnZmYqMDBQH3zwgTw9PRUWFqY//vhDb7zxhiZPnixJ6tmzpxnfvHlztWnTRjVq1NDSpUs1fPjwHG1GRkYqIiLCvJ2UlEQxHQAAAAAAAABQKJwqpAcEBMjT01Nnzpyx2X/mzBm765sHBwfL29tbnp6e5r5GjRopPj5eqamp8vHxyfGY8uXLq379+jp06FCubVqtVlmtVmdSBwAAAAAAAAAgX5xa2sXHx0dhYWGKjo4292VmZio6Olrh4eG5PqZt27Y6dOiQMjMzzX2//fabgoODcy2iS9KlS5d0+PBhBQcHO5MeAAAAAAAAAAAFzqlCuiRFREToww8/1MKFC7V//36NHj1aycnJGjZsmCRp8ODBioyMNONHjx6t8+fP6/HHH9dvv/2mtWvX6pVXXtHYsWPNmKeeekqbN2/W0aNH9eOPP+qee+6Rp6enBgwYUAAvEQAAAAAAAACA/HN6jfT+/fsrISFBL7zwguLj4xUaGqr169ebFyA9fvy4PDz+qs+HhIRow4YNeuKJJ9S8eXNVrVpVjz/+uCZMmGDGnDx5UgMGDNC5c+dUqVIltWvXTrGxsapUqVIBvEQAAAAAAAAAAPIvXxcbHTdunMaNG5frfTExMTn2hYeHKzY21m57ixcvzk8aAAAAAAAAAAAUOqeXdgEAAAAAAAAAoCShkA4AAAAAAAAAgAMU0gEAAAAAAAAAcIBCOgAAAAAAAAAADlBIBwAAAAAAAADAAQrpAAAAAAAAAAA4QCEdAAAAAAAAAAAHKKQDAAAAAAAAAOAAhXQAAAAAAAAAABygkA4AAAAAAAAAgAMU0gEAAAAAAAAAcIBCOgAAAAAAAAAADlBIBwAAAAAAAADAAQrpAADghl588UVZLBabrWHDhq5OCwAAAACAIkEhHQAA5EmTJk10+vRpc/v+++9dnRIAABD/8AYAoCh4uToBAABwc/Dy8lJQUFCeYlNSUpSSkmLeTkpKKqy0AACArv3De9OmTeZtLy8+7gMAUJCYkQ4AAPLk4MGDqlKlimrXrq1Bgwbp+PHjdmOjoqLk7+9vbiEhIUWYKQAAJU/WP7yztoCAAFenBACAW6GQDgAAbqhNmzZasGCB1q9frzlz5uj3339X+/btdfHixVzjIyMjlZiYaG4nTpwo4owBAChZnPmHt3Tt22NJSUk2GwAAsI/vegEAgBvq2bOn+XPz5s3Vpk0b1ahRQ0uXLtXw4cNzxFutVlmt1qJMEQCAEivrH94NGjTQ6dOnNWXKFLVv314///yzypYtm+tjoqKiNGXKlCLOFACAmxcz0gEAgNPKly+v+vXr69ChQ65OBQCAEq9nz566//771bx5c3Xv3l3r1q3ThQsXtHTpUruP4dtjAAA4h0I6AABw2qVLl3T48GEFBwe7OhUAAHCdvPzD22q1qly5cjYbAACwj0I6AAC4oaeeekqbN2/W0aNH9eOPP+qee+6Rp6enBgwY4OrUAADAdfiHNwAABY810gEAwA2dPHlSAwYM0Llz51SpUiW1a9dOsbGxqlSpkqtTAwCgxHvqqafUu3dv1ahRQ6dOndLkyZP5hzcAAAWMQjoAALihxYsXuzoFAABgB//wBgCg8FFIBwAAAADgJsY/vAEAKHyskQ4AAAAAAAAAgAMU0gEAAAAAAAAAcIBCOgAAAAAAAAAADlBIBwAAAAAAAADAAQrpAAAAAAAAAAA4QCEdAAAAAAAAAAAHKKQDAAAAAAAAAOAAhXQAAAAAAAAAABygkA4AAAAAAAAAgAMU0gEAAAAAAAAAcIBCOgAAAAAAAAAADlBIBwAAAAAAAADAAQrpAAAAAAAAAAA4QCEdAAAAAAAAAAAHKKQDAAAAAAAAAOAAhXQAAAAAAAAAABygkA4AAAAAAAAAgAMU0gEAAAAAAAAAcIBCOgAAAAAAAAAADlBIBwAAAAAAAADAAQrpAAAAAAAAAAA4QCEdAAAAAAAAAAAHKKQDAAAAAAAAAOAAhXQAAAAAAAAAABygkA4AAAAAAAAAgAMU0gEAAAAAAAAAcIBCOgAAAAAAAAAADlBIBwAAAAAAAADAAQrpAAAAAAAAAAA4QCEdAAAAAAAAAAAHKKQDAAAAAAAAAOAAhXQAAAAAAAAAABygkA4AAAAAAAAAgAMU0gEAAAAAAAAAcIBCOgAAAAAAAAAADlBIBwAAAAAAAADAAQrpAAAAAAAAAAA4QCEdAAAAAAAAAAAHKKQDAAAAAAAAAOAAhXQAAAAAAAAAABygkA4AAAAAAAAAgAMU0gEAAAAAAAAAcIBCOgAAAAAAAAAADuSrkD579mzVrFlTvr6+atOmjbZv3+4w/sKFCxo7dqyCg4NltVpVv359rVu37m+1CQAAih7jNQAAxRfjNAAAhcfpQvqSJUsUERGhyZMna9euXWrRooW6d++uP//8M9f41NRUde3aVUePHtXy5ct14MABffjhh6patWq+2wQAAEWP8RoAgOKLcRoAgMLl5ewD3nrrLY0cOVLDhg2TJM2dO1dr167Vxx9/rGeffTZH/Mcff6zz58/rxx9/lLe3tySpZs2af6vNlJQUpaSkmLcTExMlSUlJSc6+HIeuXL1YoO0VVwX9vhVXF1PSXJ1CkfEpIX2acumyq1MoEiXld/TK5XRXp1Ak0gqpP8uWLSuLxVIobWdxZrwuirG6pIzTUsk5D5SUsZpx2v2UlN9Rxur8K27jtMRYXZBKyjlAYqx2NyVlrC4pv6MlZZyWXDhWG05ISUkxPD09jZUrV9rsHzx4sHH33Xfn+piePXsagwYNMkaOHGkEBgYaTZo0MaZNm2akp6fnu83JkycbktjY2NjY2Nj+/5aYmOjMkO40Z8drxmo2NjY2Nra/tuI2TjNWs7GxsbGx2W55GaudmpF+9uxZZWRkqHLlyjb7K1eurF9//TXXxxw5ckTffPONBg0apHXr1unQoUMaM2aM0tLSNHny5Hy1GRkZqYiICPN2Zmamzp8/r4oVKxb6f/kLU1JSkkJCQnTixAmVK1fO1engb6I/3Q996l7crT/Lli1bqO07O14zVuNmQH+6F/rT/bhTnxa3cVpyz7HanY4ZXEOfuhf60/24U5/mZax2emkXZ2VmZiowMFAffPCBPD09FRYWpj/++ENvvPGGJk+enK82rVarrFarzb7y5csXQLbFQ7ly5W76gw9/oT/dD33qXujPwsFYjZsJ/ele6E/3Q58WDnceqzlm3A996l7oT/dTUvrUqUJ6QECAPD09debMGZv9Z86cUVBQUK6PCQ4Olre3tzw9Pc19jRo1Unx8vFJTU/PVJgAAKFqM1wAAFF+M0wAAFD4PZ4J9fHwUFham6Ohoc19mZqaio6MVHh6e62Patm2rQ4cOKTMz09z322+/KTg4WD4+PvlqEwAAFC3GawAAii/GaQAACp9ThXRJioiI0IcffqiFCxdq//79Gj16tJKTk80rgw8ePFiRkZFm/OjRo3X+/Hk9/vjj+u2337R27Vq98sorGjt2bJ7bLCmsVqsmT56c4+t1uDnRn+6HPnUv9KfzGK85btwN/ele6E/3Q586h3GaY8Yd0afuhf50PyWtTy2GYRjOPujdd9/VG2+8ofj4eIWGhuqdd95RmzZtJEkdO3ZUzZo1tWDBAjN+69ateuKJJxQXF6eqVatq+PDhmjBhgs1yL47aBAAAxQPjNQAAxRfjNAAAhSdfhXQAAAAAAAAAAEoKp5d2AQAAAAAAAACgJKGQDgAAAAAAAACAAxTSAQAAAAAAAABwgEK6i9SsWVNxcXE2+4YOHaqqVasqNDRUDRs21IMPPqjLly+7JkE4jT51L/Sne6E/kR8cN+6F/nQ/9Kl7oT/hLI4Z90Ofuhf60/3QpxTSi52nn35acXFx2rNnj44cOaJ3333X1Snhb6JP3Qv96V7oT+QHx417oT/dD33qXuhPOItjxv3Qp+6F/nQ/JalPKaQXU1arVe3atdOxY8dcnQoKCH3qXuhP90J/Ij84btwL/el+6FP3Qn/CWRwz7oc+dS/0p/spCX1KIb2YSkxMVExMjPr16+fqVFBA6FP3Qn+6F/oT+cFx417oT/dDn7oX+hPO4phxP/Spe6E/3U9J6FMK6cXMG2+8oebNm6ty5cqqVq2a7rzzTlenhL+JPnUv9Kd7oT+RHxw37oX+dD/0qXuhP+Esjhn3Q5+6F/rT/ZSkPqWQXsw8/fTT2rt3r3777Tft2LFDc+fOdXVK+JvoU/dCf7oX+hP5wXHjXuhP90Ofuhf6E87imHE/9Kl7oT/dT0nqUwrpxVT16tU1a9YsTZ06VVeuXHF1OigA9Kl7oT/dC/2J/OC4cS/0p/uhT90L/Qlnccy4H/rUvdCf7qck9CmFdBfq3r27qlWrZm4nT560uf/uu+9Ww4YN9d5777koQziLPnUv9Kd7oT+RHxw37oX+dD/0qXuhP+Esjhn3Q5+6F/rT/ZT0PrUYhmG4OgkAAAAAAAAAAIorZqQDAAAAAAAAAOAAhXQAAAAAAAAAABygkA4AAAAAAAAAgAMU0gvBiy++qKtXrxbZ87377rsaOnRokT0fAAA3O8ZqAACKL8ZpAEBxRCG9EEyZMqVIB30UXx07dtTRo0ddnQYKCP3pfujTkouxGlk4D7gX+tO90J8lF+M0snAecD/0qXspaf3p5eoE3M2oUaMkSe3bt5enp6eqVKmibt26afz48ZKkp556SmXKlNGLL76oF198Ufv379fly5d1+PBhBQUFafny5apQoYIkafr06Vq6dKnS09MVGBio999/XzVq1NDFixc1YsQIxcXFqVKlSmrSpImrXi4AADcdxmoAAIovxmkAQHHFjPQCNnfuXEnSli1bFBcXp8DAQIfx27Zt04IFC/TLL7+YA7skLVq0SAcOHNDWrVu1a9cuDRo0SGPGjJEkTZ06VVarVb/++qvWrl2r7777rnBfFAAAboSxGgCA4otxGgBQXDEj3cV69OihihUrSpLCw8O1b98+SdKqVav0008/KSwsTJKUkZFhPiY6Olpvv/22LBaL/P39NXDgQB0+fLjok0euBg8erL1790qSDh06pF69esnHx0fStX6tWbOmC7ODs+hP90OfwlmM1e6H84B7oT/dC/0JZzFOux/OA+6HPnUvJbk/KaQXMi8vL5sB++rVqypTpox529fX1/zZ09NT6enpkiTDMBQZGamHH374hs9hsVgKMGP8XZ988on5c8eOHbVgwQK3Pom4O/rT/dCnuB5jdcnDecC90J/uhf7E9RinSx7OA+6HPnUvJbk/WdqlEJQtW1aJiYmSpLp162r79u2SpHPnzmndunV5aqNv376aO3euzp8/L0lKS0vT7t27JUldunTR/PnzZRiGkpKS9PnnnxfCqwAAwH0xVgMAUHwxTgMAiiNmpBeCJ598Ul27dpWfn5++/vprPfDAA2rUqJFq166t22+/PU9tDBo0SOfOndOdd94pSUpPT9dDDz2kli1batKkSRoxYoQaNmyoSpUqqV27dkpJSSnMlwQAgFthrAYAoPhinAYAFEcWwzAMVycBAAAAAAAAAEBxxdIuAAAAAAAAAAA4QCEdAAAAAAAAAAAHKKSjxJsyZYpGjBhh3v7+++9lsVgUExNj7hs1apQmTZqU7+d49913NXToUElSTEyMLBaLXnrpJfP+n3/+OU9XOL5w4YJeffXVfOcB+2rWrKkGDRooNDTU3Pbt22fub9GiherWras+ffroxx9/zPH4O+64Q3Xr1hWrZf192fuiUaNGGjhwoJKTk/PV1oIFC9S3b98c+3v16mX2s8ViUbNmzRQaGqr27dv/zewBFDTGaUiM08UNYzWA7BirITFWFyeM04WHQnoRu///tXf/MVXVjx/HX+g10xTUUKzZpHSCAvdeDUQcLkBEJWfO/NFKxdSl6w9zQ6eWOtdctdks5Q9zipQl6VqmW5JOEcwm/lqCaMzf5BimqJgYXBF5f/9gnMlHQ/h84d7zwedjuxvn3Pd5v9/nnnvua7zPr8mTlZeX12iZ5ORknT171ks9Qnx8fIOAz8nJUXR09CPzEhISmlRfTU3NE8v07t1baWlpunHjRrP6Sui3ru3btys/P996RUREWPMLCgp04cIFpaSkKDk5WUePHrWWO3/+vM6fP6+OHTvq4MGDvup+m1K/Lc6cOaO///5bX3/9dYvWn5WVZW1nSTp06JDy8/N16NAhq0xT9mW0PeS0/ZDTqEdO2wtZDV8hq+2HrEY9sto+yOnWwUC6Fx07dky3bt1STExMo+WysrIUEhLipV5h2LBhKi0tVUlJiaS6o9srVqywQv/q1au6cuWK+vXrp4kTJyoiIkLh4eHasGGDVUdwcLAWL16soUOHKiUlRRUVFZo6dapCQkIUGxurwsLCBm0GBQVp+vTpDY6gP+z48eNKSEhQZGSkBg8erB9++EFS3VH8iooKud1uRUZGtsKngSeZOHGi5s2bp88//9yat3nzZk2bNk1z5sxRenq6D3vX9lRXV6uyslLdu3dXYWGhYmNjNWTIEA0aNEirVq1qUG7RokUKDw+Xy+XSmDFjHqmrtLRUUVFR2rx587+2FxcXp/nz5ysmJkZJSUmqqanR6NGjFRkZqbCwsAZH8nNzcxUeHq73339fLpdLYWFhOnHihCSprKxMSUlJioiIkNPp1LvvvtvCnwxaAzltT+Q0moOc9j6yGt5EVtsTWY3mIKu9i5xuYQZeM2vWLLNp0yZreuPGjWbgwIHG5XKZ8PBwc+TIEWOMMX379jUnT540xhjz2muvmdTUVBMbG2teeeUVM3fuXF90vc0bOXKk2bJli/F4PObll182xhjTr18/U1VVZbZu3Wri4+PNlClTzJIlS4wxxly7ds306dPH5OXlGWPqttns2bNNbW2tMcaYhQsXmunTp5va2lpz+/ZtExoaalJSUowxxuTk5BiXy2Vu3rxpevbsaS5dumQKCwtN3759jTHGlJeXG7fbbUpLS40xxpSVlZmXXnrJlJSUmMuXL5uAgADvfTBPkb59+5oBAwYYl8tlvSorKxvsj/V27NhhBg4caIwxpqamxrzwwgumqKjIlJWVmYCAAHP79m0frEHb8fC2CAgIMAkJCeb+/fvmzp07xuPxGGOMqaysNG6329oHV65cacaPH2+9f/36dWOMMRkZGeaNN94wp06dMoMGDTJ79+59pD1Jpry83BhT95s7evRoU11dbYwxpra21ty4ccP6e968eebTTz81xtTty+3bt7d+u9evX2+SkpKMMcasWbPGvPfee1YbN2/ebNHPCK2DnLYvchrktL2Q1fAVstq+yGqQ1fZBTrcezkj3otzcXEVHR1vTqampys7OVn5+vn7//XeFhYU9drmLFy8qJydHp0+f1t69e594GRuar/5StKNHj2ro0KGS6o6q5+XlKTc3V/Hx8dq/f7/mzp0rSerVq5cmTpyo/fv3W3XMnDlTfn5+kqTs7GzNnj1bfn5+CggI0Ntvv/1Imz169NCCBQu0bNmyBvMPHz6sS5cuaezYsXK73UpMTJQkLk30gv+8DK1Tp06PLWceumdbVlaWgoODFRoaqsDAQCUmJiozM9NbXW6z6rfFjRs3rLNTqqqqNGfOHEVERGjYsGH6888/rcvIfv75Z33wwQfq2LGjJKlnz55WXWfOnNH48eOVmZmppKSkJ7Y9bdo0dejQQVLdtv7iiy80ePBgOZ1O7d6922pTkvr372/9rsfExOjixYuS6n4/fvnlF6WmpmrXrl167rnnWuJjQSsjp+2LnIZETtsNWQ1fIKvti6yGRFbbCTndOhhI96KSkhIFBQVZ0yNHjtT06dO1du1aXb58WV26dHnsclOnTpXD4VCnTp3kdrutLxVaTnx8vHJycpSTk6O4uDhJdQ+6qJ/3uHu51Qd8vX/bfo8rW2/BggU6ePCgTp48ac0zxigsLKxB+Fy5cqXJ95ND6zt+/LjCw8MlSenp6Tp37pyCg4MVHBysQ4cOcSlaC3I4HHrzzTe1Z88effjhhwoMDNTJkydVUFCguLg4eTyeJ9bx4osvKigoSAcOHGhSmw/vy5mZmTpw4IAOHjyowsJCLVy4sEGbzz77rPV3+/btrXvAxcTEKD8/X9HR0dqxY4eioqL04MGDpq42fIScti9yGs1BTnsXWQ1vIqvti6xGc5DV3kNOtywG0r2oc+fODb4sP/74oz777DPdv39fycnJ2rZt22OX+7cvFVpOVFSUrl+/rq1btzYI/W3btunq1asaOnSoEhMTtXHjRkl192rasWOHRo0a9dj6EhMTlZGRIWOM7ty5o++///6x5Tp37qzly5drxYoV1rzhw4fr8uXLDY7M5+fnq7q6Wv7+/qqqqlJ1dXULrTmaa9euXVq/fr1SU1N17do1ZWdn68KFCyouLlZxcbGuXr2q0tJSFRQU+LqrbcaBAwcUEhKi8vJy9enTRw6HQ2fPntW+ffusMuPHj9fatWt17949SXX7aL3u3btr37592rlzpz7++ONmtV1eXq7AwED5+/uroqKiyQ9oqf9HbsqUKUpLS9O5c+d09+7dZrUN7yOn7YucRlOR075BVsNbyGr7IqvRVGS195HTLYeBdC9yOp3WpUQ1NTW6ePGiIiMjtXDhQk2aNEnHjh3zcQ+fXh06dFBsbKwqKioUGhoqSRowYIAqKioUGxurDh06aN26dSoqKlJERITi4+P10UcfNbis8GHLly9XVVWVQkNDlZycrNjY2H9te/bs2XrmmWes6e7du2v37t365JNP5HK5NGjQIC1ZskS1tbXq0aOHZsyYIafTyYNRWsHUqVPldrutV05OjjXf5XKpf//+Sk9PV1ZWlqKjo/XNN98oKSlJ3bp1s+po166d3nrrLY6g/z/Vb4vw8HAVFRVp7dq1WrZsmTIyMuR0OrVkyZIGZ5QsXrxYAwYM0JAhQ+R2u5WSktKgvq5du2rPnj06fPiwFi1a1OR+zJgxQ5WVlQoJCdHYsWM1YsSIJi2Xm5urV199VW63W8OHD9fq1asVEBDQ5HbhG+S0fZHTkMhpuyGr4QtktX2R1ZDIajshp1uHn3n4xkRoVWlpabpy5YpWr16te/fuadSoUbp165YcDod69uypjIwM9enTR8HBwdq5c6fcbrfi4uK0YMECTZgwQZI0adIkjRs3TjNnzvTpugAA0NaQ0wAA2BtZDQDwJQbSveju3bsaPny48vLybHOTfAAAUIecBgDA3shqAIAvMZDuZdnZ2QoKCrIeqgAAAOyDnAYAwN7IagCArzCQDgAAAAAAAABAI3jY6P+gyZMn6/Dhw77uBgAAeAxyGgAAeyOrAQD/Dc5I/x+Un5+v+fPn69dff/V1VwAAwH8gpwEAsDeyGgDw3+CMdC945513FBkZKafTqddff11//fWXiouL1a1bN6vM3bt35efnZ03v2rVLAwcOlMvl0uLFixUYGKji4mJJktvtVllZmYqKiry8JgAAtD3kNAAA9kZWAwDsgIF0L/jyyy914sQJnTp1SiNGjNDKlSsbLX/9+nXNmjVLP/30kwoKChQaGqqbN282KBMTE6Ps7OxW7DUAAE8HchoAAHsjqwEAduDwdQeeBpmZmfr222/l8Xjk8XgUGBjYaPkjR47I6XQqNDRUkpSSkqJ58+Y1KNO7d2+VlJS0Wp8BAHhakNMAANgbWQ0AsAPOSG9lv/32m9atW6esrCydPn1aa9askcfjkcPh0IMHD6xyHo+nWfV6PB516tSppbsLAMBThZwGAMDeyGoAgF0wkN7KysvL1bVrVz3//POqrq7Whg0bJNUd/TbG6I8//pAkbdmyxVpm2LBhOnXqlM6ePStJ+u6771RdXd2g3qKiIrlcLi+tBQAAbRM5DQCAvZHVAAC7YCC9lY0ZM0YhISEKCQnRiBEj5Ha7JUkOh0NpaWkaN26coqKidP/+fWuZXr16adOmTZowYYLcbrcKCwvVpUsX60Eq//zzjwoLC5WYmOiDNQIAoO0gpwEAsDeyGgBgF37GGOPrTuBRFRUV6tq1qyRp586dWrp0qfVE8a+++kolJSVatWqVL7sIAMBTi5wGAMDeyGoAQEvjYaM2lZaWpu3bt+vBgwfy9/fX1q1brffatWunpUuX+rB3AAA83chpAADsjawGALQ0zkgHAAAAAAAAAKAR3CMdAAAAAAAAAIBGMJAOAAAAAAAAAEAjGEgHAAAAAAAAAKARDKQDAAAAAAAAANAIBtIBAAAAAAAAAGgEA+kAAAAAAAAAADSCgXQAAAAAAAAAABrBQDoAAAAAAAAAAI34P/GmpUAj5WVJAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1500x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guardado en reports/v2/16_augmentation_comparativa.png\n"
     ]
    }
   ],
   "source": [
    "fig, axes = plt.subplots(1, 3, figsize=(15, 5))\n",
    "\n",
    "models = list(comp_df.index)\n",
    "colors = ['#7F77DD','#E8593C','#5DCAA5','#F5A623'][:len(models)]\n",
    "\n",
    "# F1 test\n",
    "axes[0].bar(models, comp_df['f1_test'], color=colors, alpha=0.85, width=0.5)\n",
    "axes[0].axhline(metrics_base['f1_test'], color='gray', linestyle='--',\n",
    "                label=f'Baseline {metrics_base[\"f1_test\"]:.4f}')\n",
    "axes[0].set_title('F1 Test', fontweight='bold')\n",
    "axes[0].set_ylim(0.6, 0.85)\n",
    "axes[0].set_xticklabels([m.replace(' ','\\n') for m in models], fontsize=8)\n",
    "axes[0].legend(fontsize=8)\n",
    "\n",
    "# FN comparison\n",
    "axes[1].bar(models, comp_df['fn'], color=colors, alpha=0.85, width=0.5)\n",
    "axes[1].axhline(metrics_base['fn'], color='gray', linestyle='--',\n",
    "                label=f'Baseline {metrics_base[\"fn\"]}')\n",
    "axes[1].set_title('Falsos Negativos (menor = mejor)', fontweight='bold')\n",
    "axes[1].set_xticklabels([m.replace(' ','\\n') for m in models], fontsize=8)\n",
    "axes[1].legend(fontsize=8)\n",
    "\n",
    "# FP comparison\n",
    "axes[2].bar(models, comp_df['fp'], color=colors, alpha=0.85, width=0.5)\n",
    "axes[2].axhline(metrics_base['fp'], color='gray', linestyle='--',\n",
    "                label=f'Baseline {metrics_base[\"fp\"]}')\n",
    "axes[2].set_title('Falsos Positivos (menor = mejor)', fontweight='bold')\n",
    "axes[2].set_xticklabels([m.replace(' ','\\n') for m in models], fontsize=8)\n",
    "axes[2].legend(fontsize=8)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig(PROJECT_ROOT / 'reports' / 'v2' / '15_augmentation_comparativa.png',\n",
    "            dpi=150, bbox_inches='tight')\n",
    "plt.show()\n",
    "print('Guardado en reports/v2/15_augmentation_comparativa.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x400 with 8 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_models = len(all_m)\n",
    "fig, axes = plt.subplots(1, n_models, figsize=(5*n_models, 4))\n",
    "if n_models == 1:\n",
    "    axes = [axes]\n",
    "\n",
    "model_pipes = {\n",
    "    metrics_base['name']: lr_base,\n",
    "    metrics_wn['name']  : lr_wn,\n",
    "    metrics_eda['name'] : lr_eda,\n",
    "}\n",
    "if metrics_bt:\n",
    "    model_pipes[metrics_bt['name']] = lr_bt\n",
    "\n",
    "for ax, m in zip(axes, all_m):\n",
    "    pipe = model_pipes[m['name']]\n",
    "    cm   = confusion_matrix(y_test, pipe.predict(X_test))\n",
    "    import seaborn as sns\n",
    "    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', ax=ax,\n",
    "                xticklabels=['No tox','Tox'],\n",
    "                yticklabels=['No tox','Tox'], linewidths=0.5)\n",
    "    ax.set_title(m['name'].replace('LR + ','').replace('LR tuned ',''),\n",
    "                 fontweight='bold')\n",
    "    ax.set_xlabel('Pred')\n",
    "    ax.set_ylabel('Real')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig(PROJECT_ROOT / 'reports' / 'v2' / '16_augmentation_confusion.png',\n",
    "            dpi=150, bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. Decisión y guardado del modelo\n",
    "\n",
    "Solo guardamos un modelo augmentado si supera el baseline en F1 test.\n",
    "Si ninguno mejora, el modelo de producción sigue siendo `final_model.joblib`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mejor modelo augmentado: LR tuned (sin aug) — F1=0.7579\n",
      "Baseline               : LR tuned (sin aug) — F1=0.7579\n",
      "\n",
      "⚠️ Ninguna estrategia supero el baseline en F1 test\n",
      "El modelo de produccion sigue siendo: models/final_model.joblib\n",
      "El augmentation se documenta como tecnica explorada — resultado negativo\n"
     ]
    }
   ],
   "source": [
    "best_aug_name = comp_df['f1_test'].idxmax()\n",
    "best_aug_f1   = comp_df.loc[best_aug_name, 'f1_test']\n",
    "\n",
    "print(f'Mejor modelo augmentado: {best_aug_name} — F1={best_aug_f1:.4f}')\n",
    "print(f'Baseline               : {metrics_base[\"name\"]} — F1={metrics_base[\"f1_test\"]:.4f}')\n",
    "\n",
    "if best_aug_f1 > metrics_base['f1_test'] and best_aug_name != metrics_base['name']:\n",
    "    # El augmentation mejoro — guardar\n",
    "    best_aug_pipe = model_pipes[best_aug_name]\n",
    "    aug_path = PROJECT_ROOT / 'models' / 'lr_augmented.joblib'\n",
    "    joblib.dump(best_aug_pipe, aug_path)\n",
    "    print(f'\\n✅ Modelo augmentado guardado: {aug_path}')\n",
    "    print('Actualizar final_model.joblib si se decide usar este en produccion')\n",
    "else:\n",
    "    print('\\n⚠️ Ninguna estrategia supero el baseline en F1 test')\n",
    "    print('El modelo de produccion sigue siendo: models/final_model.joblib')\n",
    "    print('El augmentation se documenta como tecnica explorada — resultado negativo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10. Conclusiones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "CONCLUSIONES — DATA AUGMENTATION\n",
      "==========================================================\n",
      "Estrategias evaluadas:\n",
      "  1. Synonym Replacement (WordNet/nlpaug)\n",
      "  2. EDA - Random Swap + Delete\n",
      "  3. Back-Translation EN->ES->EN (si disponible)\n",
      "\n",
      "Hallazgos:\n",
      "  - WordNet: cobertura baja en jerga y lenguaje informal.\n",
      "    Los sinonimos formales pueden degradar el F1 del modelo.\n",
      "\n",
      "  - EDA: perturbacion minima. Util si el dataset es extremadamente\n",
      "    pequeno pero no aporta suficiente diversidad semantica.\n",
      "\n",
      "  - Back-Translation: mejor estrategia teoricamente porque produce\n",
      "    parafrasis naturales. La calidad depende de la API disponible.\n",
      "\n",
      "Limitacion principal del proyecto:\n",
      "  El problema NO es la tecnica de augmentation.\n",
      "  Es la falta de DIVERSIDAD en los datos originales:\n",
      "  - 1000 comentarios de solo 8 videos sobre el mismo tema\n",
      "  - El modelo aprende patrones de esos 8 videos, no hate speech general\n",
      "  - Aumentar datos del mismo dominio no resuelve este problema\n",
      "\n",
      "¿Que realmente ayudaria?\n",
      "  - Mas datos de videos de temas diversos\n",
      "  - Datasets externos (HateXplain, Twitter Hate Speech, etc.)\n",
      "  - Fine-tuning de un transformer preentrenado en hate speech\n",
      "\n",
      "Modelo de produccion final: models/final_model.joblib\n",
      "  LR tuned — F1 test ~0.7579 | CV-test gap ~4.76pp\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"\"\"\n",
    "CONCLUSIONES — DATA AUGMENTATION\n",
    "==========================================================\n",
    "Estrategias evaluadas:\n",
    "  1. Synonym Replacement (WordNet/nlpaug)\n",
    "  2. EDA - Random Swap + Delete\n",
    "  3. Back-Translation EN->ES->EN (si disponible)\n",
    "\n",
    "Hallazgos:\n",
    "  - WordNet: cobertura baja en jerga y lenguaje informal.\n",
    "    Los sinonimos formales pueden degradar el F1 del modelo.\n",
    "\n",
    "  - EDA: perturbacion minima. Util si el dataset es extremadamente\n",
    "    pequeno pero no aporta suficiente diversidad semantica.\n",
    "\n",
    "  - Back-Translation: mejor estrategia teoricamente porque produce\n",
    "    parafrasis naturales. La calidad depende de la API disponible.\n",
    "\n",
    "Limitacion principal del proyecto:\n",
    "  El problema NO es la tecnica de augmentation.\n",
    "  Es la falta de DIVERSIDAD en los datos originales:\n",
    "  - 1000 comentarios de solo 8 videos sobre el mismo tema\n",
    "  - El modelo aprende patrones de esos 8 videos, no hate speech general\n",
    "  - Aumentar datos del mismo dominio no resuelve este problema\n",
    "\n",
    "¿Que realmente ayudaria?\n",
    "  - Mas datos de videos de temas diversos\n",
    "  - Datasets externos (HateXplain, Twitter Hate Speech, etc.)\n",
    "  - Fine-tuning de un transformer preentrenado en hate speech\n",
    "\n",
    "Modelo de produccion final: models/final_model.joblib\n",
    "  LR tuned — F1 test ~0.7579 | CV-test gap ~4.76pp\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
}