From 5ba20605c30e2548a2888852c48e6c506f45773c Mon Sep 17 00:00:00 2001 From: Alejandro Lembke Barrientos Date: Wed, 24 Jun 2026 07:43:49 +0000 Subject: [PATCH] Agregando Proyecto Final --- README.md | 6 + proyecto-final/README.md | 87 ++ proyecto-final/dry_bean_classifier.ipynb | 1332 +++++++++++++++++ .../outputs/bitacora_experimentos.csv | 16 + proyecto-final/outputs/figures/.gitkeep | 0 .../feature_importance__random_forest.png | Bin 0 -> 64011 bytes .../figures/feature_importance__xgboost.png | Bin 0 -> 64702 bytes proyecto-final/requirements.txt | 9 + proyecto-final/src/utils.py | 57 + 9 files changed, 1507 insertions(+) create mode 100644 proyecto-final/README.md create mode 100644 proyecto-final/dry_bean_classifier.ipynb create mode 100644 proyecto-final/outputs/bitacora_experimentos.csv create mode 100644 proyecto-final/outputs/figures/.gitkeep create mode 100644 proyecto-final/outputs/figures/feature_importance__random_forest.png create mode 100644 proyecto-final/outputs/figures/feature_importance__xgboost.png create mode 100644 proyecto-final/requirements.txt create mode 100644 proyecto-final/src/utils.py diff --git a/README.md b/README.md index 79e3133..3861ed2 100644 --- a/README.md +++ b/README.md @@ -15,3 +15,9 @@ Este repositorio contiene las tareas y laboratorios del curso. | 2 | Práctica Feature Engineering, Scaling y Vectorización | [Practica_02_feature_engineering.ipynb](Practica_02_feature_engineering.ipynb) | | 3 | Clasificador K-Nearest Neighbors | [KNN/K-nearest neighbor.ipynb](KNN/K-nearest%20neighbor.ipynb) | | 4 | Inferencia (Forward Propagation) en Redes Neuronales | [Tarea_4_Forward_Propagation.ipynb](Tarea_4_Forward_Propagation.ipynb) | + +## Proyecto Final + +| Nombre | Enlace | +|--------|--------| +| Clasificador Multiclase — Dry Bean Dataset | [proyecto-final/README.md](proyecto-final/README.md) | diff --git a/proyecto-final/README.md b/proyecto-final/README.md new file mode 100644 index 0000000..7fedf9b --- /dev/null +++ b/proyecto-final/README.md @@ -0,0 +1,87 @@ +# Clasificador Multiclase — Dry Bean Dataset + +**Curso:** Fundamentos de Machine Learning +**Nombre:** Alejandro Lembke Barrientos | Carné: 12002840 +**Dataset:** Dry Bean Dataset (UCI ID 602) — 7 clases, 16 features morfológicas, 13,611 instancias +**Repo:** https://gitea.p-lao.com/aleleba/Machine_Learning_Aplicado + +## Objetivo + +Clasificar automáticamente variedades de frijol seco (BARBUNYA, BOMBAY, CALI, DERMASON, HOROZ, SEKER, SIRA) a partir de 16 medidas morfológicas extraídas de imágenes. El problema replica un sistema de control de calidad agrícola automatizado. + +Se comparan tres familias de modelos (Random Forest, XGBoost, Red Neuronal) con ≥5 experimentos cada una, y se construye un ensamble por majority voting con bootstrap. + +## Setup + +```bash +pip install -r requirements.txt +``` + +El dataset se descarga automáticamente desde UCI vía `ucimlrepo` — no requiere ningún archivo local. + +## Estructura + +``` +proyecto-final/ +├── dry_bean_classifier.ipynb # único notebook entregable +├── outputs/ +│ ├── bitacora_experimentos.csv # log append de todos los experimentos +│ └── figures/ # gráficas de feature importance +├── src/ +│ └── utils.py # metricas(), registrar(), plot_importancia() +└── requirements.txt +``` + +## Secciones del Notebook + +| # | Sección | Descripción | +|---|---------|-------------| +| 1 | Setup & Imports | Librerías, `RANDOM_STATE = 42`, `fetch_ucirepo` | +| 2 | Carga y Exploración | `fetch_ucirepo(id=602)`, distribución de clases, estadísticas | +| 3 | Preparación de Datos | Split 80/20 estratificado + `StandardScaler` para la NN | +| 4 | Bitácora — Funciones | `metricas()` y `registrar()` (helpers en `src/utils.py`) | +| 5 | Experimentos — Random Forest | ≥5 experimentos variando `n_estimators`, `max_depth`, `min_samples_leaf`, `max_features`, `criterion` | +| 6 | Experimentos — XGBoost | ≥5 experimentos variando `n_estimators`, `max_depth`, `learning_rate`, `subsample`, `colsample_bytree`, `reg_lambda` | +| 7 | Experimentos — Red Neuronal (Keras) | ≥5 experimentos variando capas, neuronas, `dropout`, `lr`, `batch_size`, `epochs` | +| 8 | Feature Importance | `mejor_rf` vs `mejor_xgb` — barplots + comparación de rankings | +| 9 | Ensamble | Majority voting + bootstrap; NN usa features escaladas | +| 10 | Tabla Comparativa | F1 train/test de los 4 modelos + Δ + diagnóstico | +| 11 | Conclusiones | Resumen automático basado en resultados reales | + +## Archivos del Proyecto + +| Archivo | Descripción | +|---------|-------------| +| [dry_bean_classifier.ipynb](dry_bean_classifier.ipynb) | Notebook principal con todo el código | +| [outputs/bitacora_experimentos.csv](outputs/bitacora_experimentos.csv) | Bitácora de todos los experimentos (append) | +| [outputs/figures/feature_importance__random_forest.png](outputs/figures/feature_importance__random_forest.png) | Feature importance — Random Forest | +| [outputs/figures/feature_importance__xgboost.png](outputs/figures/feature_importance__xgboost.png) | Feature importance — XGBoost | +| [src/utils.py](src/utils.py) | Helpers: `metricas()`, `registrar()`, `plot_importancia()` | +| [requirements.txt](requirements.txt) | Dependencias del proyecto | + +--- + +## Tabla Comparativa Final + +| Modelo | F1 train | F1 test | Δ | Diagnóstico | +|--------|----------|---------|---|-------------| +| Random Forest | 0.9739 | 0.9280 | 0.0459 | Bien ajustado | +| XGBoost | 0.9779 | 0.9327 | 0.0452 | Bien ajustado | +| **Red Neuronal (Keras)** | **0.9565** | **0.9404** | **0.0161** | **Bien ajustado** | +| Ensamble (majority voting) | 0.9754 | 0.9361 | 0.0393 | Bien ajustado | + +**Mejor modelo individual:** Red Neuronal (Keras) con F1 test = **0.9404** + +--- + +## Conclusiones + +1. **Mejor modelo:** La Red Neuronal (Keras + StandardScaler) obtuvo el mayor F1 en test (0.9404), superando a XGBoost (0.9327) y Random Forest (0.9280). + +2. **Ensamble:** El majority voting con bootstrap obtuvo F1 test = 0.9361, sin superar al mejor modelo individual (Δ = 0.0043). Los tres modelos votaron de forma coherente en la mayoría de casos. + +3. **Diagnóstico:** Los cuatro modelos quedaron bien ajustados. La NN tuvo el menor Δ (0.0161), lo que indica muy buena generalización sin overfitting. + +4. **Feature Importance:** ShapeFactor3 fue la feature más importante para RF y XGBoost. ShapeFactor4, Solidity y Extent coincidieron como las menos relevantes. Mayor discrepancia en Perimeter (RF rank 2 vs XGB rank 9). + +5. **Aprendizaje clave:** La Red Neuronal (Keras) con `StandardScaler` superó a los modelos basados en árboles cuando las features están correctamente escaladas. El escalado es crítico para el desempeño de redes neuronales con datos de magnitudes muy distintas. diff --git a/proyecto-final/dry_bean_classifier.ipynb b/proyecto-final/dry_bean_classifier.ipynb new file mode 100644 index 0000000..5c36f63 --- /dev/null +++ b/proyecto-final/dry_bean_classifier.ipynb @@ -0,0 +1,1332 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Clasificador Multiclase — Dry Bean Dataset\n", + "\n", + "**Curso:** Fundamentos de Machine Learning \n", + "**Nombre:** Alejandro Lembke Barrientos | Carné: 12002840 \n", + "**Dataset:** Dry Bean Dataset (UCI ID 602) — 7 clases, 16 features, 13,611 instancias" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Setup & Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "b18469ee", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "from ucimlrepo import fetch_ucirepo\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import precision_score, recall_score, f1_score, accuracy_score\n", + "from sklearn.preprocessing import LabelEncoder\n", + "from xgboost import XGBClassifier\n", + "from scipy.stats import mode\n", + "\n", + "sys.path.append(os.path.join(os.getcwd(), 'src'))\n", + "from utils import metricas, registrar, plot_importancia\n", + "\n", + "RANDOM_STATE = 42\n", + "np.random.seed(RANDOM_STATE)" + ] + }, + { + "cell_type": "markdown", + "id": "41902be2", + "metadata": {}, + "source": [ + "## 2. Carga y Exploración del Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "f264ed2e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shape: (13611, 17)\n", + "\n", + "Metadata:\n", + "Images of 13,611 grains of 7 different registered dry beans were taken with a high-resolution camera. A total of 16 features; 12 dimensions and 4 shape forms, were obtained from the grains.\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AreaPerimeterMajorAxisLengthMinorAxisLengthAspectRatioEccentricityConvexAreaEquivDiameterExtentSolidityRoundnessCompactnessShapeFactor1ShapeFactor2ShapeFactor3ShapeFactor4Class
028395610.291208.178117173.8887471.1971910.54981228715190.1410970.7639230.9888560.9580270.9133580.0073320.0031470.8342220.998724SEKER
128734638.018200.524796182.7344191.0973560.41178529172191.2727510.7839680.9849860.8870340.9538610.0069790.0035640.9098510.998430SEKER
229380624.110212.826130175.9311431.2097130.56272729690193.4109040.7781130.9895590.9478490.9087740.0072440.0030480.8258710.999066SEKER
330008645.884210.557999182.5165161.1536380.49861630724195.4670620.7826810.9766960.9039360.9283290.0070170.0032150.8617940.994199SEKER
430140620.134201.847882190.2792791.0607980.33368030417195.8965030.7730980.9908930.9848770.9705160.0066970.0036650.9419000.999166SEKER
\n", + "
" + ], + "text/plain": [ + " Area Perimeter MajorAxisLength MinorAxisLength AspectRatio \\\n", + "0 28395 610.291 208.178117 173.888747 1.197191 \n", + "1 28734 638.018 200.524796 182.734419 1.097356 \n", + "2 29380 624.110 212.826130 175.931143 1.209713 \n", + "3 30008 645.884 210.557999 182.516516 1.153638 \n", + "4 30140 620.134 201.847882 190.279279 1.060798 \n", + "\n", + " Eccentricity ConvexArea EquivDiameter Extent Solidity Roundness \\\n", + "0 0.549812 28715 190.141097 0.763923 0.988856 0.958027 \n", + "1 0.411785 29172 191.272751 0.783968 0.984986 0.887034 \n", + "2 0.562727 29690 193.410904 0.778113 0.989559 0.947849 \n", + "3 0.498616 30724 195.467062 0.782681 0.976696 0.903936 \n", + "4 0.333680 30417 195.896503 0.773098 0.990893 0.984877 \n", + "\n", + " Compactness ShapeFactor1 ShapeFactor2 ShapeFactor3 ShapeFactor4 Class \n", + "0 0.913358 0.007332 0.003147 0.834222 0.998724 SEKER \n", + "1 0.953861 0.006979 0.003564 0.909851 0.998430 SEKER \n", + "2 0.908774 0.007244 0.003048 0.825871 0.999066 SEKER \n", + "3 0.928329 0.007017 0.003215 0.861794 0.994199 SEKER \n", + "4 0.970516 0.006697 0.003665 0.941900 0.999166 SEKER " + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dry_bean = fetch_ucirepo(id=602)\n", + "\n", + "X_df = dry_bean.data.features # DataFrame 13611 x 16\n", + "y_raw = dry_bean.data.targets.squeeze() # Series con etiquetas de clase\n", + "\n", + "df = X_df.copy()\n", + "df['Class'] = y_raw.values\n", + "\n", + "print('Shape:', df.shape)\n", + "print('\\nMetadata:')\n", + "print(dry_bean.metadata['abstract'])\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "13e1a95a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Valores nulos por columna:\n", + "Area 0\n", + "Perimeter 0\n", + "MajorAxisLength 0\n", + "MinorAxisLength 0\n", + "AspectRatio 0\n", + "Eccentricity 0\n", + "ConvexArea 0\n", + "EquivDiameter 0\n", + "Extent 0\n", + "Solidity 0\n", + "Roundness 0\n", + "Compactness 0\n", + "ShapeFactor1 0\n", + "ShapeFactor2 0\n", + "ShapeFactor3 0\n", + "ShapeFactor4 0\n", + "Class 0\n", + "dtype: int64\n", + "\n", + "Distribución de clases:\n", + "Class\n", + "DERMASON 3546\n", + "SIRA 2636\n", + "SEKER 2027\n", + "HOROZ 1928\n", + "CALI 1630\n", + "BARBUNYA 1322\n", + "BOMBAY 522\n", + "Name: count, dtype: int64\n" + ] + } + ], + "source": [ + "print('Valores nulos por columna:')\n", + "print(df.isnull().sum())\n", + "print('\\nDistribución de clases:')\n", + "print(df['Class'].value_counts())" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "caa5998f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AreaPerimeterMajorAxisLengthMinorAxisLengthAspectRatioEccentricityConvexAreaEquivDiameterExtentSolidityRoundnessCompactnessShapeFactor1ShapeFactor2ShapeFactor3ShapeFactor4
count13611.00000013611.00000013611.00000013611.00000013611.00000013611.00000013611.00000013611.00000013611.00000013611.00000013611.00000013611.00000013611.00000013611.00000013611.00000013611.000000
mean53048.284549855.283459320.141867202.2707141.5832420.75089553768.200206253.0642200.7497330.9871430.8732820.7998640.0065640.0017160.6435900.995063
std29324.095717214.28969685.69418644.9700910.2466780.09200229774.91581759.1771200.0490860.0046600.0595200.0617130.0011280.0005960.0989960.004366
min20420.000000524.736000183.601165122.5126531.0248680.21895120684.000000161.2437640.5553150.9192460.4896180.6405770.0027780.0005640.4103390.947687
25%36328.000000703.523500253.303633175.8481701.4323070.71592836714.500000215.0680030.7186340.9856700.8320960.7624690.0059000.0011540.5813590.993703
50%44652.000000794.941000296.883367192.4317331.5511240.76444145178.000000238.4380260.7598590.9882830.8831570.8012770.0066450.0016940.6420440.996386
75%61332.000000977.213000376.495012217.0317411.7071090.81046662294.000000279.4464670.7868510.9900130.9168690.8342700.0072710.0021700.6960060.997883
max254616.0000001985.370000738.860154460.1984972.4303060.911423263261.000000569.3743580.8661950.9946770.9906850.9873030.0104510.0036650.9747670.999733
\n", + "
" + ], + "text/plain": [ + " Area Perimeter MajorAxisLength MinorAxisLength \\\n", + "count 13611.000000 13611.000000 13611.000000 13611.000000 \n", + "mean 53048.284549 855.283459 320.141867 202.270714 \n", + "std 29324.095717 214.289696 85.694186 44.970091 \n", + "min 20420.000000 524.736000 183.601165 122.512653 \n", + "25% 36328.000000 703.523500 253.303633 175.848170 \n", + "50% 44652.000000 794.941000 296.883367 192.431733 \n", + "75% 61332.000000 977.213000 376.495012 217.031741 \n", + "max 254616.000000 1985.370000 738.860154 460.198497 \n", + "\n", + " AspectRatio Eccentricity ConvexArea EquivDiameter Extent \\\n", + "count 13611.000000 13611.000000 13611.000000 13611.000000 13611.000000 \n", + "mean 1.583242 0.750895 53768.200206 253.064220 0.749733 \n", + "std 0.246678 0.092002 29774.915817 59.177120 0.049086 \n", + "min 1.024868 0.218951 20684.000000 161.243764 0.555315 \n", + "25% 1.432307 0.715928 36714.500000 215.068003 0.718634 \n", + "50% 1.551124 0.764441 45178.000000 238.438026 0.759859 \n", + "75% 1.707109 0.810466 62294.000000 279.446467 0.786851 \n", + "max 2.430306 0.911423 263261.000000 569.374358 0.866195 \n", + "\n", + " Solidity Roundness Compactness ShapeFactor1 ShapeFactor2 \\\n", + "count 13611.000000 13611.000000 13611.000000 13611.000000 13611.000000 \n", + "mean 0.987143 0.873282 0.799864 0.006564 0.001716 \n", + "std 0.004660 0.059520 0.061713 0.001128 0.000596 \n", + "min 0.919246 0.489618 0.640577 0.002778 0.000564 \n", + "25% 0.985670 0.832096 0.762469 0.005900 0.001154 \n", + "50% 0.988283 0.883157 0.801277 0.006645 0.001694 \n", + "75% 0.990013 0.916869 0.834270 0.007271 0.002170 \n", + "max 0.994677 0.990685 0.987303 0.010451 0.003665 \n", + "\n", + " ShapeFactor3 ShapeFactor4 \n", + "count 13611.000000 13611.000000 \n", + "mean 0.643590 0.995063 \n", + "std 0.098996 0.004366 \n", + "min 0.410339 0.947687 \n", + "25% 0.581359 0.993703 \n", + "50% 0.642044 0.996386 \n", + "75% 0.696006 0.997883 \n", + "max 0.974767 0.999733 " + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "92e35ff2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAVTlJREFUeJzt3Xl8Duf+//H3nUQiREKQxVL7Fku1tOTY14jQKlpbUWtpOCWn1qqtWi1H0Vbr9BDB4diqraVFGkRL7A1qO6glLQlFEksEyfz+6M/97d0shMidjNfz8ZjHcc913TOfmVPxzsw111gMwzAEAACAPM/B3gUAAAAgexDsAAAATIJgBwAAYBIEOwAAAJMg2AEAAJgEwQ4AAMAkCHYAAAAmQbADAAAwCYIdAGQiOTlZ77//vjZu3GjvUgDgvgh2ACRJEydOlMViyZF9NW3aVE2bNrV+3rp1qywWi1atWpUj+/8zi8WiiRMnZtgeEhKiJUuWqF69ejlSz2uvvaayZcvmyL7Sc7/zASB3I9gBJhQWFiaLxWJd8ufPrxIlSiggIEAff/yxrl27li37OX/+vCZOnKjo6Ohs2V5us2LFCn399df67rvvVLhwYXuX80iio6P16quvqnTp0nJxcZGnp6datmypBQsWKCUlxd7lAcgmTvYuAMDjM3nyZJUrV0537txRbGystm7dqmHDhumjjz7SmjVrVKtWLWvfcePGafTo0Vna/vnz5zVp0iSVLVtWtWvXfuDvbdq0KUv7eZySkpLk5JT2R6FhGPr111/13Xff6amnnrJDZdln3rx5GjRokLy9vdWzZ09VqlRJ165dU0REhPr166cLFy5o7Nix9i4TQDYg2AEmFhgYqLp161o/jxkzRps3b1a7du30wgsv6OjRo3J1dZUkOTk5pRtwstPNmzdVoEABOTs7P9b9ZEX+/PnTXW+xWBQSEpLD1WS/nTt3atCgQfL399e3336rQoUKWduGDRumvXv36ueff7ZjhQCyE7digSdM8+bN9c477+js2bP6z3/+Y12f3hi78PBwNWzYUIULF5abm5uqVKlivbKzdetWPffcc5KkPn36WG/7hoWFSfpjHF2NGjW0b98+NW7cWAUKFLB+969j7O5JSUnR2LFj5ePjo4IFC+qFF15QTEyMTZ+yZcvqtddeS/Pd9LZ569YtTZw4UZUrV1b+/Pnl6+urjh076tSpU9Y+6Y0p++mnnxQYGCh3d3e5ubmpRYsW2rlzp02fe7e7t2/frpCQEBUvXlwFCxbUSy+9pEuXLqWpLz1ff/21atSoofz586tGjRr66quv0u2XmpqqWbNmqXr16sqfP7+8vb31+uuv6+rVq/fdx6RJk2SxWLRkyRKbUHdP3bp10z2f95w9e1ZvvPGGqlSpIldXVxUtWlQvv/yyzpw5Y9Pvzp07mjRpkipVqqT8+fOraNGiatiwocLDw236HTt2TJ07d5anp6fy58+vunXras2aNQ+1LQBpccUOeAL17NlTY8eO1aZNmzRgwIB0+xw+fFjt2rVTrVq1NHnyZLm4uOjkyZPavn27JKlatWqaPHmyxo8fr4EDB6pRo0aSpL/97W/WbVy+fFmBgYHq2rWrXn31VXl7e2da13vvvSeLxaJRo0bp4sWLmjVrllq2bKno6GjrlcUHlZKSonbt2ikiIkJdu3bVm2++qWvXrik8PFw///yzKlSokOFxN2rUSO7u7ho5cqTy5cunf/3rX2ratKkiIyPTPEQxdOhQFSlSRBMmTNCZM2c0a9YsDRkyRMuXL8+0vk2bNqlTp07y8/PT1KlTdfnyZfXp00elSpVK0/f1119XWFiY+vTpo7///e86ffq0Pv30U/3000/avn278uXLl+4+bt68qYiICDVu3Pihbyfv2bNHO3bsUNeuXVWqVCmdOXNGn3/+uZo2baojR46oQIECkv74xWDq1Knq37+/nn/+eSUmJmrv3r3av3+/WrVqJemPc9ugQQOVLFlSo0ePVsGCBbVixQp16NBBX375pV566aUH3haADBgATGfBggWGJGPPnj0Z9vHw8DCeeeYZ6+cJEyYYf/6RMHPmTEOScenSpQy3sWfPHkOSsWDBgjRtTZo0MSQZc+fOTbetSZMm1s9btmwxJBklS5Y0EhMTretXrFhhSDJmz55tXVemTBmjd+/e991maGioIcn46KOP0vRNTU21/lmSMWHCBOvnDh06GM7OzsapU6es686fP28UKlTIaNy4sXXdvXPcsmVLm+0NHz7ccHR0NOLj49Ps989q165t+Pr62vTbtGmTIckoU6aMdd0PP/xgSDKWLFli8/0NGzaku/7PDhw4YEgy3nzzzUxr+bO/no+bN2+m6RMVFWVIMhYtWmRd9/TTTxtBQUGZbrtFixZGzZo1jVu3blnXpaamGn/729+MSpUqZWlbANLHrVjgCeXm5pbp07H3ngL95ptvlJqa+lD7cHFxUZ8+fR64f69evWxuF3bu3Fm+vr769ttvs7zvL7/8UsWKFdPQoUPTtGU0rUtKSoo2bdqkDh06qHz58tb1vr6+6t69u3788UclJibafGfgwIE222vUqJFSUlJ09uzZDGu7cOGCoqOj1bt3b3l4eFjXt2rVSn5+fjZ9V65cKQ8PD7Vq1Uq///67dalTp47c3Ny0ZcuWDPdzr9b0bsE+qD9fKb1z544uX76sihUrqnDhwtq/f7+1rXDhwjp8+LBOnDiR7nauXLmizZs365VXXtG1a9esx3H58mUFBAToxIkT+u233x5oWwAyRrADnlDXr1/P9B/8Ll26qEGDBurfv7+8vb3VtWtXrVixIkshr2TJkll6UKJSpUo2ny0WiypWrJhmPNeDOHXqlKpUqZKlB0IuXbqkmzdvqkqVKmnaqlWrptTU1DRj/v56i7NIkSKSlOn4t3uh76/HKynNvk+cOKGEhAR5eXmpePHiNsv169d18eLFDPfj7u4uSY80vU1SUpLGjx9vnSalWLFiKl68uOLj45WQkGDtN3nyZMXHx6ty5cqqWbOmRowYoYMHD1rbT548KcMw9M4776Q5jgkTJkiS9Vjuty0AGWOMHfAE+vXXX5WQkKCKFStm2MfV1VXbtm3Tli1btH79em3YsEHLly9X8+bNtWnTJjk6Ot53P1kdF/cgMrva9iA1ZbeM9mkYRrZsPzU1VV5eXlqyZEm67cWLF8/wuxUrVpSTk5MOHTr00PsfOnSoFixYoGHDhsnf318eHh6yWCzq2rWrTchv3LixTp06pW+++UabNm3SvHnzNHPmTM2dO1f9+/e39n3rrbcUEBCQYb0Psi0AGSPYAU+gxYsXS1KG/8De4+DgoBYtWqhFixb66KOP9P777+vtt9/Wli1b1LJly2x/U8Vfb70ZhqGTJ0/azLdXpEgRxcfHp/nu2bNnbW6fVqhQQbt27dKdO3cyfLjgr4oXL64CBQro+PHjadqOHTsmBwcHlS5d+gGPJmNlypSRlPZ4JaXZd4UKFfT999+rQYMGWQ7KBQoUUPPmzbV582bFxMQ8VO2rVq1S7969NWPGDOu6W7dupfv/gaenp/r06aM+ffro+vXraty4sSZOnKj+/ftb/7/Jly+fWrZsed/9ZrYtABnjVizwhNm8ebPeffddlStXTj169Miw35UrV9KsuzcJcXJysiSpYMGCkpTuP/IPY9GiRTa3DVetWqULFy4oMDDQuq5ChQrauXOnbt++bV23bt26NLdIO3XqpN9//12ffvppmv1kdDXN0dFRrVu31jfffGNz+zcuLk5Lly5Vw4YNrbc3H4Wvr69q166thQsX2tzODA8P15EjR2z6vvLKK0pJSdG7776bZjt3796977mfMGGCDMNQz549df369TTt+/bt08KFCzP8vqOjY5rz9cknn6R5W8Xly5dtPru5ualixYrW/1a8vLzUtGlT/etf/9KFCxfS7OfPU8Tcb1sAMsYVO8DEvvvuOx07dkx3795VXFycNm/erPDwcJUpU0Zr1qzJcHJe6Y9xTtu2bVNQUJDKlCmjixcv6rPPPlOpUqXUsGFDSX+ErMKFC2vu3LkqVKiQChYsqHr16qlcuXIPVa+np6caNmyoPn36KC4uTrNmzVLFihVtpmTp37+/Vq1apTZt2uiVV17RqVOn9J///CfN9CW9evXSokWLFBISot27d6tRo0a6ceOGvv/+e73xxht68cUX061hypQp1vn73njjDTk5Oelf//qXkpOTNW3atIc6rvRMnTpVQUFBatiwofr27asrV67ok08+UfXq1W0CWJMmTfT6669r6tSpio6OVuvWrZUvXz6dOHFCK1eu1OzZs9W5c+cM9/O3v/1Nc+bM0RtvvKGqVavavHli69atWrNmjaZMmZLh99u1a6fFixfLw8NDfn5+ioqK0vfff6+iRYva9PPz81PTpk1Vp04deXp6au/evVq1apWGDBli7TNnzhw1bNhQNWvW1IABA1S+fHnFxcUpKipKv/76qw4cOPDA2wKQAXs+kgvg8bg3Fce9xdnZ2fDx8TFatWplzJ4922ZKkXv+Ot1JRESE8eKLLxolSpQwnJ2djRIlShjdunUz/ve//9l875tvvjH8/PwMJycnm6lPmjRpYlSvXj3d+jKa7uS///2vMWbMGMPLy8twdXU1goKCjLNnz6b5/owZM4ySJUsaLi4uRoMGDYy9e/em2aZh/DFVx9tvv22UK1fOyJcvn+Hj42N07tzZZioT/WV6D8MwjP379xsBAQGGm5ubUaBAAaNZs2bGjh070j3Hf51S5t6xbNmyJd1j/7Mvv/zSqFatmuHi4mL4+fkZq1evNnr37m0z3ck9X3zxhVGnTh3D1dXVKFSokFGzZk1j5MiRxvnz5++7H8MwjH379hndu3c3SpQoYeTLl88oUqSI0aJFC2PhwoVGSkpKhufj6tWrRp8+fYxixYoZbm5uRkBAgHHs2LE0085MmTLFeP75543ChQsbrq6uRtWqVY333nvPuH37tk0dp06dMnr16mX4+PgY+fLlM0qWLGm0a9fOWLVqVZa3BSAti2Fk0whfAAAA2BVj7AAAAEyCYAcAAGASBDsAAACTINgBAACYBMEOAADAJAh2AAAAJmHaCYpTU1N1/vx5FSpUKNtfewQAAJBTDMPQtWvXVKJECTk4ZH5NzrTB7vz589nyTkcAAIDcICYmRqVKlcq0j2mDXaFChST9cRKy492OAAAA9pCYmKjSpUtbs01mTBvs7t1+dXd3J9gBAIA870GGlvHwBAAAgEkQ7AAAAEyCYAcAAGASBDsAAACTINgBAACYBMEOAADAJAh2AAAAJkGwAwAAMAmCHQAAgEkQ7AAAAEyCYAcAAGASBDsAAACTcMpK588//1yff/65zpw5I0mqXr26xo8fr8DAQElS06ZNFRkZafOd119/XXPnzrV+PnfunAYPHqwtW7bIzc1NvXv31tSpU+Xk9H+lbN26VSEhITp8+LBKly6tcePG6bXXXnvIQ8w+ZUevt3cJmTrzQZC9SwAAAHaUpWBXqlQpffDBB6pUqZIMw9DChQv14osv6qefflL16tUlSQMGDNDkyZOt3ylQoID1zykpKQoKCpKPj4927NihCxcuqFevXsqXL5/ef/99SdLp06cVFBSkQYMGacmSJYqIiFD//v3l6+urgICA7DhmAAAAU7IYhmE8ygY8PT01ffp09evXT02bNlXt2rU1a9asdPt+9913ateunc6fPy9vb29J0ty5czVq1ChdunRJzs7OGjVqlNavX6+ff/7Z+r2uXbsqPj5eGzZseOC6EhMT5eHhoYSEBLm7uz/KIVpxxQ4AAOS0rGSahx5jl5KSomXLlunGjRvy9/e3rl+yZImKFSumGjVqaMyYMbp586a1LSoqSjVr1rSGOkkKCAhQYmKiDh8+bO3TsmVLm30FBAQoKioq03qSk5OVmJhoswAAADxJsnQrVpIOHTokf39/3bp1S25ubvrqq6/k5+cnSerevbvKlCmjEiVK6ODBgxo1apSOHz+u1atXS5JiY2NtQp0k6+fY2NhM+yQmJiopKUmurq7p1jV16lRNmjQpq4cDAABgGlkOdlWqVFF0dLQSEhK0atUq9e7dW5GRkfLz89PAgQOt/WrWrClfX1+1aNFCp06dUoUKFbK18L8aM2aMQkJCrJ8TExNVunTpx7pPAACA3CTLt2KdnZ1VsWJF1alTR1OnTtXTTz+t2bNnp9u3Xr16kqSTJ09Kknx8fBQXF2fT595nHx+fTPu4u7tneLVOklxcXOTu7m6zAAAAPEkeeR671NRUJScnp9sWHR0tSfL19ZUk+fv769ChQ7p48aK1T3h4uNzd3a23c/39/RUREWGznfDwcJtxfAAAAEgrS7dix4wZo8DAQD311FO6du2ali5dqq1bt2rjxo06deqUli5dqrZt26po0aI6ePCghg8frsaNG6tWrVqSpNatW8vPz089e/bUtGnTFBsbq3Hjxik4OFguLi6SpEGDBunTTz/VyJEj1bdvX23evFkrVqzQ+vW5+4lUAAAAe8tSsLt48aJ69eqlCxcuyMPDQ7Vq1dLGjRvVqlUrxcTE6Pvvv9esWbN048YNlS5dWp06ddK4ceOs33d0dNS6des0ePBg+fv7q2DBgurdu7fNvHflypXT+vXrNXz4cM2ePVulSpXSvHnzmMMOAADgPh55HrvcinnsAACAGeTIPHYAAADIXQh2AAAAJkGwAwAAMAmCHQAAgEkQ7AAAAEyCYAcAAGASBDsAAACTINgBAACYBMEOAADAJAh2AAAAJkGwAwAAMAmCHQAAgEkQ7AAAAEyCYAcAAGASBDsAAACTINgBAACYBMEOAADAJAh2AAAAJkGwAwAAMAmCHQAAgEkQ7AAAAEyCYAcAAGASBDsAAACTINgBAACYBMEOAADAJAh2AAAAJkGwAwAAMAmCHQAAgEkQ7AAAAEyCYAcAAGASBDsAAACTINgBAACYRJaC3eeff65atWrJ3d1d7u7u8vf313fffWdtv3XrloKDg1W0aFG5ubmpU6dOiouLs9nGuXPnFBQUpAIFCsjLy0sjRozQ3bt3bfps3bpVzz77rFxcXFSxYkWFhYU9/BECAAA8IbIU7EqVKqUPPvhA+/bt0969e9W8eXO9+OKLOnz4sCRp+PDhWrt2rVauXKnIyEidP39eHTt2tH4/JSVFQUFBun37tnbs2KGFCxcqLCxM48ePt/Y5ffq0goKC1KxZM0VHR2vYsGHq37+/Nm7cmE2HDAAAYE4WwzCMR9mAp6enpk+frs6dO6t48eJaunSpOnfuLEk6duyYqlWrpqioKNWvX1/fffed2rVrp/Pnz8vb21uSNHfuXI0aNUqXLl2Ss7OzRo0apfXr1+vnn3+27qNr166Kj4/Xhg0bHriuxMREeXh4KCEhQe7u7o9yiFZlR6/Plu08Lmc+CLJ3CQAAIJtlJdM89Bi7lJQULVu2TDdu3JC/v7/27dunO3fuqGXLltY+VatW1VNPPaWoqChJUlRUlGrWrGkNdZIUEBCgxMRE61W/qKgom23c63NvGxlJTk5WYmKizQIAAPAkyXKwO3TokNzc3OTi4qJBgwbpq6++kp+fn2JjY+Xs7KzChQvb9Pf29lZsbKwkKTY21ibU3Wu/15ZZn8TERCUlJWVY19SpU+Xh4WFdSpcundVDAwAAyNOyHOyqVKmi6Oho7dq1S4MHD1bv3r115MiRx1FblowZM0YJCQnWJSYmxt4lAQAA5CinrH7B2dlZFStWlCTVqVNHe/bs0ezZs9WlSxfdvn1b8fHxNlft4uLi5OPjI0ny8fHR7t27bbZ376nZP/f565O0cXFxcnd3l6ura4Z1ubi4yMXFJauHAwAAYBqPPI9damqqkpOTVadOHeXLl08RERHWtuPHj+vcuXPy9/eXJPn7++vQoUO6ePGitU94eLjc3d3l5+dn7fPnbdzrc28bAAAASF+WrtiNGTNGgYGBeuqpp3Tt2jUtXbpUW7du1caNG+Xh4aF+/fopJCREnp6ecnd319ChQ+Xv76/69etLklq3bi0/Pz/17NlT06ZNU2xsrMaNG6fg4GDr1bZBgwbp008/1ciRI9W3b19t3rxZK1as0Pr1ufuJVAAAAHvLUrC7ePGievXqpQsXLsjDw0O1atXSxo0b1apVK0nSzJkz5eDgoE6dOik5OVkBAQH67LPPrN93dHTUunXrNHjwYPn7+6tgwYLq3bu3Jk+ebO1Trlw5rV+/XsOHD9fs2bNVqlQpzZs3TwEBAdl0yAAAAOb0yPPY5VbMYwcAAMwgR+axAwAAQO5CsAMAADAJgh0AAIBJEOwAAABMgmAHAABgEgQ7AAAAkyDYAQAAmATBDgAAwCQIdgAAACZBsAMAADAJgh0AAIBJEOwAAABMgmAHAABgEgQ7AAAAkyDYAQAAmATBDgAAwCQIdgAAACZBsAMAADAJgh0AAIBJEOwAAABMgmAHAABgEgQ7AAAAkyDYAQAAmATBDgAAwCSc7F0AnixlR6+3dwmZOvNBkL1LAADgoXHFDgAAwCQIdgAAACZBsAMAADAJgh0AAIBJEOwAAABMgmAHAABgElkKdlOnTtVzzz2nQoUKycvLSx06dNDx48dt+jRt2lQWi8VmGTRokE2fc+fOKSgoSAUKFJCXl5dGjBihu3fv2vTZunWrnn32Wbm4uKhixYoKCwt7uCMEAAB4QmQp2EVGRio4OFg7d+5UeHi47ty5o9atW+vGjRs2/QYMGKALFy5Yl2nTplnbUlJSFBQUpNu3b2vHjh1auHChwsLCNH78eGuf06dPKygoSM2aNVN0dLSGDRum/v37a+PGjY94uAAAAOaVpQmKN2zYYPM5LCxMXl5e2rdvnxo3bmxdX6BAAfn4+KS7jU2bNunIkSP6/vvv5e3trdq1a+vdd9/VqFGjNHHiRDk7O2vu3LkqV66cZsyYIUmqVq2afvzxR82cOVMBAQFZPUYAAIAnwiONsUtISJAkeXp62qxfsmSJihUrpho1amjMmDG6efOmtS0qKko1a9aUt7e3dV1AQIASExN1+PBha5+WLVvabDMgIEBRUVGPUi4AAICpPfQrxVJTUzVs2DA1aNBANWrUsK7v3r27ypQpoxIlSujgwYMaNWqUjh8/rtWrV0uSYmNjbUKdJOvn2NjYTPskJiYqKSlJrq6uaepJTk5WcnKy9XNiYuLDHhoAAECe9NDBLjg4WD///LN+/PFHm/UDBw60/rlmzZry9fVVixYtdOrUKVWoUOHhK72PqVOnatKkSY9t+wAAALndQ92KHTJkiNatW6ctW7aoVKlSmfatV6+eJOnkyZOSJB8fH8XFxdn0uff53ri8jPq4u7une7VOksaMGaOEhATrEhMTk/UDAwAAyMOyFOwMw9CQIUP01VdfafPmzSpXrtx9vxMdHS1J8vX1lST5+/vr0KFDunjxorVPeHi43N3d5efnZ+0TERFhs53w8HD5+/tnuB8XFxe5u7vbLAAAAE+SLAW74OBg/ec//9HSpUtVqFAhxcbGKjY2VklJSZKkU6dO6d1339W+fft05swZrVmzRr169VLjxo1Vq1YtSVLr1q3l5+ennj176sCBA9q4caPGjRun4OBgubi4SJIGDRqkX375RSNHjtSxY8f02WefacWKFRo+fHg2Hz4AAIB5ZCnYff7550pISFDTpk3l6+trXZYvXy5JcnZ21vfff6/WrVuratWq+sc//qFOnTpp7dq11m04Ojpq3bp1cnR0lL+/v1599VX16tVLkydPtvYpV66c1q9fr/DwcD399NOaMWOG5s2bx1QnAAAAmcjSwxOGYWTaXrp0aUVGRt53O2XKlNG3336baZ+mTZvqp59+ykp5AAAATzTeFQsAAGASBDsAAACTINgBAACYBMEOAADAJAh2AAAAJkGwAwAAMAmCHQAAgEkQ7AAAAEyCYAcAAGASBDsAAACTINgBAACYBMEOAADAJAh2AAAAJkGwAwAAMAmCHQAAgEkQ7AAAAEyCYAcAAGASBDsAAACTINgBAACYBMEOAADAJAh2AAAAJkGwAwAAMAmCHQAAgEkQ7AAAAEyCYAcAAGASBDsAAACTINgBAACYBMEOAADAJAh2AAAAJkGwAwAAMAmCHQAAgEkQ7AAAAEwiS8Fu6tSpeu6551SoUCF5eXmpQ4cOOn78uE2fW7duKTg4WEWLFpWbm5s6deqkuLg4mz7nzp1TUFCQChQoIC8vL40YMUJ379616bN161Y9++yzcnFxUcWKFRUWFvZwRwgAAPCEyFKwi4yMVHBwsHbu3Knw8HDduXNHrVu31o0bN6x9hg8frrVr12rlypWKjIzU+fPn1bFjR2t7SkqKgoKCdPv2be3YsUMLFy5UWFiYxo8fb+1z+vRpBQUFqVmzZoqOjtawYcPUv39/bdy4MRsOGQAAwJwshmEYD/vlS5cuycvLS5GRkWrcuLESEhJUvHhxLV26VJ07d5YkHTt2TNWqVVNUVJTq16+v7777Tu3atdP58+fl7e0tSZo7d65GjRqlS5cuydnZWaNGjdL69ev1888/W/fVtWtXxcfHa8OGDQ9UW2Jiojw8PJSQkCB3d/eHPUQbZUevz5btPC5nPgiydwn3xTl8dJxDAHiyZCXTPNIYu4SEBEmSp6enJGnfvn26c+eOWrZsae1TtWpVPfXUU4qKipIkRUVFqWbNmtZQJ0kBAQFKTEzU4cOHrX3+vI17fe5tIz3JyclKTEy0WQAAAJ4kDx3sUlNTNWzYMDVo0EA1atSQJMXGxsrZ2VmFCxe26evt7a3Y2Fhrnz+Hunvt99oy65OYmKikpKR065k6dao8PDysS+nSpR/20AAAAPKkhw52wcHB+vnnn7Vs2bLsrOehjRkzRgkJCdYlJibG3iUBAADkKKeH+dKQIUO0bt06bdu2TaVKlbKu9/Hx0e3btxUfH29z1S4uLk4+Pj7WPrt377bZ3r2nZv/c569P0sbFxcnd3V2urq7p1uTi4iIXF5eHORwAAABTyNIVO8MwNGTIEH311VfavHmzypUrZ9Nep04d5cuXTxEREdZ1x48f17lz5+Tv7y9J8vf316FDh3Tx4kVrn/DwcLm7u8vPz8/a58/buNfn3jYAAACQVpau2AUHB2vp0qX65ptvVKhQIeuYOA8PD7m6usrDw0P9+vVTSEiIPD095e7urqFDh8rf31/169eXJLVu3Vp+fn7q2bOnpk2bptjYWI0bN07BwcHWK26DBg3Sp59+qpEjR6pv377avHmzVqxYofXrc/fTgAAAAPaUpSt2n3/+uRISEtS0aVP5+vpal+XLl1v7zJw5U+3atVOnTp3UuHFj+fj4aPXq1dZ2R0dHrVu3To6OjvL399err76qXr16afLkydY+5cqV0/r16xUeHq6nn35aM2bM0Lx58xQQEJANhwwAAGBOWbpi9yBT3uXPn19z5szRnDlzMuxTpkwZffvtt5lup2nTpvrpp5+yUh4AAMAT7aEengCAvCq3T/AsMckzgIf3SBMUAwAAIPcg2AEAAJgEwQ4AAMAkCHYAAAAmQbADAAAwCYIdAACASRDsAAAATIJgBwAAYBIEOwAAAJMg2AEAAJgEwQ4AAMAkCHYAAAAmQbADAAAwCYIdAACASRDsAAAATIJgBwAAYBIEOwAAAJMg2AEAAJgEwQ4AAMAkCHYAAAAmQbADAAAwCYIdAACASRDsAAAATIJgBwAAYBJO9i4AAJC3lB293t4lZOrMB0H2LgGwG67YAQAAmATBDgAAwCQIdgAAACZBsAMAADAJgh0AAIBJEOwAAABMIsvBbtu2bWrfvr1KlCghi8Wir7/+2qb9tddek8VisVnatGlj0+fKlSvq0aOH3N3dVbhwYfXr10/Xr1+36XPw4EE1atRI+fPnV+nSpTVt2rSsHx0AAMATJMvB7saNG3r66ac1Z86cDPu0adNGFy5csC7//e9/bdp79Oihw4cPKzw8XOvWrdO2bds0cOBAa3tiYqJat26tMmXKaN++fZo+fbomTpyoL774IqvlAgAAPDGyPEFxYGCgAgMDM+3j4uIiHx+fdNuOHj2qDRs2aM+ePapbt64k6ZNPPlHbtm31z3/+UyVKlNCSJUt0+/ZthYaGytnZWdWrV1d0dLQ++ugjmwAIAACA//NYxtht3bpVXl5eqlKligYPHqzLly9b26KiolS4cGFrqJOkli1bysHBQbt27bL2ady4sZydna19AgICdPz4cV29ejXdfSYnJysxMdFmAQAAeJJke7Br06aNFi1apIiICH344YeKjIxUYGCgUlJSJEmxsbHy8vKy+Y6Tk5M8PT0VGxtr7ePt7W3T597ne33+aurUqfLw8LAupUuXzu5DAwAAyNWy/V2xXbt2tf65Zs2aqlWrlipUqKCtW7eqRYsW2b07qzFjxigkJMT6OTExkXAHAACeKI99upPy5curWLFiOnnypCTJx8dHFy9etOlz9+5dXblyxTouz8fHR3FxcTZ97n3OaOyei4uL3N3dbRYAAIAnyWMPdr/++qsuX74sX19fSZK/v7/i4+O1b98+a5/NmzcrNTVV9erVs/bZtm2b7ty5Y+0THh6uKlWqqEiRIo+7ZAAAgDwpy8Hu+vXrio6OVnR0tCTp9OnTio6O1rlz53T9+nWNGDFCO3fu1JkzZxQREaEXX3xRFStWVEBAgCSpWrVqatOmjQYMGKDdu3dr+/btGjJkiLp27aoSJUpIkrp37y5nZ2f169dPhw8f1vLlyzV79mybW60AAACwleVgt3fvXj3zzDN65plnJEkhISF65plnNH78eDk6OurgwYN64YUXVLlyZfXr10916tTRDz/8IBcXF+s2lixZoqpVq6pFixZq27atGjZsaDNHnYeHhzZt2qTTp0+rTp06+sc//qHx48cz1QkAAEAmsvzwRNOmTWUYRobtGzduvO82PD09tXTp0kz71KpVSz/88ENWywMAAHhi8a5YAAAAkyDYAQAAmATBDgAAwCQIdgAAACZBsAMAADAJgh0AAIBJEOwAAABMgmAHAABgElmeoBgAADyasqPX27uETJ35IMjeJeAhccUOAADAJAh2AAAAJkGwAwAAMAmCHQAAgEkQ7AAAAEyCYAcAAGASBDsAAACTINgBAACYBMEOAADAJAh2AAAAJkGwAwAAMAmCHQAAgEkQ7AAAAEyCYAcAAGASBDsAAACTINgBAACYBMEOAADAJAh2AAAAJkGwAwAAMAmCHQAAgEkQ7AAAAEyCYAcAAGASWQ5227ZtU/v27VWiRAlZLBZ9/fXXNu2GYWj8+PHy9fWVq6urWrZsqRMnTtj0uXLlinr06CF3d3cVLlxY/fr10/Xr1236HDx4UI0aNVL+/PlVunRpTZs2LetHBwAA8ATJcrC7ceOGnn76ac2ZMyfd9mnTpunjjz/W3LlztWvXLhUsWFABAQG6deuWtU+PHj10+PBhhYeHa926ddq2bZsGDhxobU9MTFTr1q1VpkwZ7du3T9OnT9fEiRP1xRdfPMQhAgAAPBmcsvqFwMBABQYGpttmGIZmzZqlcePG6cUXX5QkLVq0SN7e3vr666/VtWtXHT16VBs2bNCePXtUt25dSdInn3yitm3b6p///KdKlCihJUuW6Pbt2woNDZWzs7OqV6+u6OhoffTRRzYBEAAAAP8nW8fYnT59WrGxsWrZsqV1nYeHh+rVq6eoqChJUlRUlAoXLmwNdZLUsmVLOTg4aNeuXdY+jRs3lrOzs7VPQECAjh8/rqtXr2ZnyQAAAKaR5St2mYmNjZUkeXt726z39va2tsXGxsrLy8u2CCcneXp62vQpV65cmm3caytSpEiafScnJys5Odn6OTEx8RGPBgAAIG8xzVOxU6dOlYeHh3UpXbq0vUsCAADIUdka7Hx8fCRJcXFxNuvj4uKsbT4+Prp48aJN+927d3XlyhWbPult48/7+KsxY8YoISHBusTExDz6AQEAAOQh2RrsypUrJx8fH0VERFjXJSYmateuXfL395ck+fv7Kz4+Xvv27bP22bx5s1JTU1WvXj1rn23btunOnTvWPuHh4apSpUq6t2ElycXFRe7u7jYLAADAkyTLwe769euKjo5WdHS0pD8emIiOjta5c+dksVg0bNgwTZkyRWvWrNGhQ4fUq1cvlShRQh06dJAkVatWTW3atNGAAQO0e/dubd++XUOGDFHXrl1VokQJSVL37t3l7Oysfv366fDhw1q+fLlmz56tkJCQbDtwAAAAs8nywxN79+5Vs2bNrJ/vha3evXsrLCxMI0eO1I0bNzRw4EDFx8erYcOG2rBhg/Lnz2/9zpIlSzRkyBC1aNFCDg4O6tSpkz7++GNru4eHhzZt2qTg4GDVqVNHxYoV0/jx45nqBAAAIBNZDnZNmzaVYRgZtlssFk2ePFmTJ0/OsI+np6eWLl2a6X5q1aqlH374IavlAQAAPLFM81QsAADAk45gBwAAYBIEOwAAAJMg2AEAAJgEwQ4AAMAkCHYAAAAmQbADAAAwCYIdAACASRDsAAAATIJgBwAAYBIEOwAAAJMg2AEAAJgEwQ4AAMAkCHYAAAAmQbADAAAwCYIdAACASRDsAAAATIJgBwAAYBIEOwAAAJMg2AEAAJgEwQ4AAMAkCHYAAAAmQbADAAAwCYIdAACASRDsAAAATIJgBwAAYBIEOwAAAJMg2AEAAJgEwQ4AAMAkCHYAAAAmQbADAAAwCYIdAACASWR7sJs4caIsFovNUrVqVWv7rVu3FBwcrKJFi8rNzU2dOnVSXFyczTbOnTunoKAgFShQQF5eXhoxYoTu3r2b3aUCAACYitPj2Gj16tX1/fff/99OnP5vN8OHD9f69eu1cuVKeXh4aMiQIerYsaO2b98uSUpJSVFQUJB8fHy0Y8cOXbhwQb169VK+fPn0/vvvP45yAQAATOGxBDsnJyf5+PikWZ+QkKD58+dr6dKlat68uSRpwYIFqlatmnbu3Kn69etr06ZNOnLkiL7//nt5e3urdu3aevfddzVq1ChNnDhRzs7Oj6NkAACAPO+xBLsTJ06oRIkSyp8/v/z9/TV16lQ99dRT2rdvn+7cuaOWLVta+1atWlVPPfWUoqKiVL9+fUVFRalmzZry9va29gkICNDgwYN1+PBhPfPMM+nuMzk5WcnJydbPiYmJj+PQAACAnZUdvd7eJdzXmQ+C7LLfbB9jV69ePYWFhWnDhg36/PPPdfr0aTVq1EjXrl1TbGysnJ2dVbhwYZvveHt7KzY2VpIUGxtrE+rutd9ry8jUqVPl4eFhXUqXLp29BwYAAJDLZfsVu8DAQOufa9WqpXr16qlMmTJasWKFXF1ds3t3VmPGjFFISIj1c2JiIuEOAAA8UR77dCeFCxdW5cqVdfLkSfn4+Oj27duKj4+36RMXF2cdk+fj45PmKdl7n9Mbt3ePi4uL3N3dbRYAAIAnyWMPdtevX9epU6fk6+urOnXqKF++fIqIiLC2Hz9+XOfOnZO/v78kyd/fX4cOHdLFixetfcLDw+Xu7i4/P7/HXS4AAECele23Yt966y21b99eZcqU0fnz5zVhwgQ5OjqqW7du8vDwUL9+/RQSEiJPT0+5u7tr6NCh8vf3V/369SVJrVu3lp+fn3r27Klp06YpNjZW48aNU3BwsFxcXLK7XAAAANPI9mD366+/qlu3brp8+bKKFy+uhg0baufOnSpevLgkaebMmXJwcFCnTp2UnJysgIAAffbZZ9bvOzo6at26dRo8eLD8/f1VsGBB9e7dW5MnT87uUgEAAEwl24PdsmXLMm3Pnz+/5syZozlz5mTYp0yZMvr222+zuzQAAABT412xAAAAJkGwAwAAMAmCHQAAgEkQ7AAAAEyCYAcAAGASBDsAAACTINgBAACYBMEOAADAJAh2AAAAJkGwAwAAMAmCHQAAgEkQ7AAAAEyCYAcAAGASBDsAAACTINgBAACYBMEOAADAJAh2AAAAJkGwAwAAMAmCHQAAgEkQ7AAAAEyCYAcAAGASBDsAAACTINgBAACYBMEOAADAJAh2AAAAJkGwAwAAMAmCHQAAgEkQ7AAAAEyCYAcAAGASBDsAAACTINgBAACYBMEOAADAJHJ1sJszZ47Kli2r/Pnzq169etq9e7e9SwIAAMi1cm2wW758uUJCQjRhwgTt379fTz/9tAICAnTx4kV7lwYAAJAr5dpg99FHH2nAgAHq06eP/Pz8NHfuXBUoUEChoaH2Lg0AACBXcrJ3Aem5ffu29u3bpzFjxljXOTg4qGXLloqKikr3O8nJyUpOTrZ+TkhIkCQlJiZmW12pyTezbVuPQ3Ye6+PCOXx0nMNHk9vPn8Q5fFS5/fxJnMNHldvPn5S95/DetgzDuH9nIxf67bffDEnGjh07bNaPGDHCeP7559P9zoQJEwxJLCwsLCwsLCymXGJiYu6boXLlFbuHMWbMGIWEhFg/p6am6sqVKypatKgsFosdK0tfYmKiSpcurZiYGLm7u9u7nDyJc/joOIePhvP36DiHj45z+Ohy+zk0DEPXrl1TiRIl7ts3Vwa7YsWKydHRUXFxcTbr4+Li5OPjk+53XFxc5OLiYrOucOHCj6vEbOPu7p4r/yPKSziHj45z+Gg4f4+Oc/joOIePLjefQw8PjwfqlysfnnB2dladOnUUERFhXZeamqqIiAj5+/vbsTIAAIDcK1desZOkkJAQ9e7dW3Xr1tXzzz+vWbNm6caNG+rTp4+9SwMAAMiVcm2w69Kliy5duqTx48crNjZWtWvX1oYNG+Tt7W3v0rKFi4uLJkyYkOb2MR4c5/DRcQ4fDefv0XEOHx3n8NGZ6RxaDONBnp0FAABAbpcrx9gBAAAg6wh2AAAAJkGwAwAAMAmCHQAAgEkQ7GAaV65csXcJAADYFcEOed6mTZv0yiuvqGTJkvYuJc/bu3evvUsA8AhSU1O1bt06e5eRq3377bf2LuGxyrXz2JnNtm3bHqhf48aNH3Ml5nD27FmFhoZq4cKFunr1qgIDA7Vo0SJ7l5UnXL9+XY6OjnJ1dbWui46O1jvvvKNvv/1WKSkpdqwud3v33XfVvXt3VahQId32xMREDRs2TKGhoTlcWd7QsWPHB+q3evXqx1yJ+Zw8eVKhoaEKCwvTpUuXdOfOHXuXlGt17NhRvXr10kcffSQ3Nzd7l5PtmMcuhzg4ZHxx1GKxWP/37t27OVVSnnP79m2tXr1a8+bN0/bt29WyZUt99913+umnn1SzZk17l5frxcTE6JVXXtHu3bvl6OioIUOGaMqUKRo0aJCWL1+ul156ScOHD1e9evXsXWqu5eDgoCJFimj58uVq2bJlmva4uDiVKFGCcJyBB31z0IIFCx5zJeaQlJSklStXWn8mNmrUSF27dtVLL71kmsn8H4cDBw7otddeU0JCgsLCwsx3QcVAjoiPj093OX/+vDFq1CjD1dXVqF69ur3LzLWGDBliFC1a1Khfv77x6aefGr///rthGIbh5ORkHD582M7V5Q1dunQxateubXzyySdGs2bNDAcHB6Nu3bpGcHCwERMTY+/y8gSLxWL06dPHyJcvn/HRRx+laY+NjTUcHBzsUBmeJLt37zYGDhxouLu7G88884zxz3/+03B0dORnYRbcuXPHmDBhguHi4mKEhIQYly9fNhISEmyWvIpgZycpKSnGv//9b6NUqVLGU089ZYSGhhopKSn2LivXcnR0NMaOHWskJibarCfYPThfX18jKirKMAzDiIuLMywWizFz5kz7FpXHODg4GHFxccZ//vMfo0CBAkbv3r2N5ORkazvB7tEcPXrUqFSpkr3LyNVq1qxplClTxhgzZozx888/W9fzs/DhbNy40XB0dDQcHBysi8ViydN/jxljZwerV6/W2LFjdenSJY0ZM0ZDhw41xfvpHqfFixcrNDRUvr6+CgoKUs+ePRUYGGjvsvKUuLg4lStXTpLk5eWlAgUKcA6zyPj/I1d69OihqlWrqmPHjmrcuLG++uor+fr62rm6vC85OVmnTp2ydxm52vHjx9WlSxc1a9ZMfn5+9i4nT1u9erUGDx6sxo0b6+2335aTkzkiEU/F5qDIyEjVr19fPXv2VMeOHfXLL7/orbfeItQ9gG7duik8PFyHDh1S1apVFRwcLB8fH6WmpurIkSP2Li/P+PNYTwcHBzk7O9uxmrytTp062rNnj5ydnVW3bl3t2rXL3iXhCfDLL7+oSpUqGjx4sEqVKqW33npLP/30k3WsNu4vPj5e3bt3V8+ePTV27Fht3rxZLVq0UJMmTWyWPMvelwyfFIGBgUa+fPmM119/3bhw4YK9y8nzUlNTjQ0bNhgvv/yy4eLiYpQsWdIYOnSovcvK1SwWi1G4cGGjSJEiRpEiRQyLxWJ4eHhYP99bkLF7t2L/7M6dO8agQYOM/PnzG++//36evoVjb9HR0Zy/LIiIiDB69OhhuLq6GhaLxRgxYoRx/Phxe5eV6/n6+hr16tUzjh07lmGfy5cv52BF2YunYnOIg4ODnJycVLBgwUx/s2KS3ay7cuWKFi1apLCwMEVHR9u7nFxr4cKFD9Svd+/ej7mSvMvBwUGxsbHy8vJK0/bFF1/o73//u+7cucNTsQ/pwIEDevbZZzl/mbhx44YKFixosy4hIUFLlixRaGio9u/frxo1aujgwYN2qjD3mzJlisaMGSNHR8c0bZs2bdK8efO0du1aJSUl2aG6R2eOG8p5AI/vPz6enp5q1KiRvv/+e3uXkqsR2B7dhAkTMpz3auDAgapevbrmz5+fw1XlHUWKFMn0F1ume7q/WrVqaeHChWrYsKF1nYeHh9544w298cYbio6OZh7F+xg3bpzNZ7PNi8oVO+QZGzduVHh4uJydndW/f3+VL19ex44d0+jRo7V27VoFBASYfkbxR7F7927VqVMn3d9SpT8Grn/zzTd65ZVXcrgyPCm4avzoRo4cqVmzZunNN9/Ue++9xzjZh2TmeVEJdjksKSlJ4eHh+t///idJqlKlilq2bGnzFgCkNX/+fA0YMECenp66evWqihYtqo8++khDhw5Vly5d9Oabb6patWr2LjNXc3R01IULF6y3Ed3d3RUdHa3y5ctLYnLdB3X37l3NnDlT//3vf61/jytXrqzu3bvrzTffVL58+excYd6WkpKS4S8f+MPOnTvVt29fOTg4aPHixXrmmWfsXVKeMnToUP33v/9VpUqV9Oqrr6pr164qWrSo8uXLpwMHDuT5p40JdjlozZo16t+/v37//Xeb9cWKFdP8+fPVvn17O1WW+9WqVUs9e/bUiBEj9OWXX+rll19W/fr1tWLFCpUqVcre5eUJfx0fVqhQIR04cMAm2Pn6+io1NdWeZeZqSUlJatWqlaKiotSyZUvrLxNHjx7V999/rwYNGmjTpk3Knz+/nSvNe/73v/9p/vz5WrRokS5cuGDvcnK95ORkjRs3Tp9++qlatWqVZqoOXsuWMScnJ40aNUqjR49WoUKFrOvNEuyY7iSH7NixQ507d1bjxo21fft2XblyRVeuXNGPP/6oRo0aqXPnztq5c6e9y8y1Tp06pZdfflnSH+/5c3Jy0vTp0wl12YwpEzL3wQcfKCYmRj/99JM2btyoWbNmadasWdq4caP279+vs2fP6oMPPrB3mXnGzZs3tWDBAjVq1Eh+fn6KjIxUSEiIvcvKE5KTk3Xx4kVZLBZ5eHikWZCxxYsXa/fu3fL19VWXLl20bt06c92psN8DuU+WwMBAY+DAgRm2Dxw40AgMDMzBivIWi8ViM82Em5ubcerUKTtWlPfc7xzy1oT7q1y5srFq1aoM21esWMGbEx5AVFSU0a9fP8Pd3d2oUaOG4ejoaGzbts3eZeUZmzZtMkqVKmU899xzxpEjR+xdTp71yy+/GOPHjzeeeuopo1ixYoaDg4OxcuVKe5f1yLgVm0M8PT0VGRmZ4aDMgwcPqkmTJrp69WoOV5Y3ODg4aMqUKdYnEkeNGqURI0aoWLFiNv3+/ve/26O8PMHBwUGbN2+Wp6enJOlvf/ubza3s33//Xa1atTLXb67ZLH/+/Dpx4oRKly6dbntMTIwqVaqkW7du5XBlecOMGTMUGhqqhIQEdevWTa+++qqefvpp09wCywmvv/66Fi5cqLFjx+rtt99mPGI2MAxDmzZt0vz587VmzRoVK1ZMHTt21Mcff2zv0h4KwS6HuLq66tixYypTpky67WfPnlXVqlXz7Lw5j1vZsmXve5vQYrHol19+yaGK8h4HBwdZLBal91f+3nqLxUKwy4SXl5e+++471alTJ932PXv2qG3btrp06VIOV5Y33BvbNHnyZJtAQrB7cDVq1NCiRYv07LPP2rsUU7p8+bIWL16sBQsW6MCBA/Yu56EQ7HJIrVq1NHz4cPXp0yfd9tDQUM2aNYtJJfHYnD179oH6ZfTLB6QuXbro7t27+vLLL9Nt79SpkxwdHbVixYocrixvmDp1qhYsWKBbt26pW7du6tmzp2rUqEGwy4Lbt28zxQkyxQTFOaRPnz5666235O3trbZt29q0rV+/XiNHjtTYsWPtVB2eBPny5VOJEiUy7bNs2TKCXSYmTJigevXqqX79+goJCVHVqlVlGIaOHj2qmTNn6siRIzwElYkxY8ZozJgxioyMVGhoqOrVq6eKFSvKMAyGoTygB304Z/z48Y+5krztxIkTOnjwoJ599lmVK1dO69ev14cffqikpCR16NBBY8eOzbMPk3HFLoekpqaqS5cu+vLLL1WlShVVq1bN+g/CiRMn1KFDB61cudLmJe34Pw861oExdhmrUaOGfvzxRxUuXDjd9mXLlqlXr166fft2zhaWx+zcuVP9+vXT0aNHrT/4DcNQ1apVNX/+fPn7+9u5wrzj2rVrWrp0qUJDQ7Vv3z49//zz6ty5M0/GZiKzOessFouOHz+uW7duMaQiE1999ZVeeeUV6/CUL774Qq+//rqaNm0qR0dHbdy4UVOmTNGoUaPsXepDIdjlsOXLl6eZ2LRr167q2rWrnSvL3cqVK3ffPoyxy1yzZs1069YtRUREqECBAjZtK1asUI8ePfT+++9rxIgRdqowb4mOjrb5e1y7dm37FpTH/fzzz5o/f76WLFmiixcv2rucPCc6OlqjR4/W5s2b1bdvX82dO9feJeVadevWVUBAgKZMmaKwsDAFBwfr/fff17BhwyT98d7nmTNn6ujRo/Yt9GHl+HO4AOzi2rVrRp06dYxWrVoZt2/ftq5fsWKF4ezsbHzwwQd2rM489uzZY+8Scq2IiAijWrVqRkJCQpq2+Ph4o1q1akZ4eLgdKsu7fvnlF6NHjx6Gk5OT8corrxj/+9//7F1Srufm5macPHnSMAzDSElJMRwdHY1Dhw5Z20+fPm24urraq7xHxn2/HHL37l0lJyfbrIuLi9OkSZM0cuRI/fDDD3aqLG+IiorSunXrbNYtWrRI5cqVk5eXlwYOHJjm/MKWm5ubvvvuO8XExKh79+4yDEOrVq1Sjx49NGHChDx728Eerl+/nuYJ9ujoaLVv31716tWzU1W536xZszRgwAC5u7unafPw8NCgQYM0Z84cO1SW9/z+++8aOnSoqlatqgsXLmjHjh1avny5KlWqZO/Scr0bN25Y3zjh4OAgV1dXm7sYrq6uefrfE4JdDhkwYIDN+K9r167pueee05w5c7Rx40Y1b96cF9hnYtKkSTp8+LD186FDh9SvXz+1bNlSo0eP1tq1azV16lQ7Vpg3FC9eXJs2bdLu3bvVqlUr9ejRQ+PHj+fBnQcUExMjf39/6+z+ISEhunnzpnr16qV69eqpYMGC2rFjh73LzLUOHDigNm3aZNjeunVr7du3Lwcryntu3LihSZMmqUKFCtqxY4fWrl2riIgIPffcc/YuLc+wWCw2D0b89XNex1OxOWT79u369NNPrZ8XLVqklJQUnThxQh4eHho1apSmT5+e5olZ/OHAgQOaMmWK9fOyZctUr149/fvf/5YklS5dWhMmTNDEiRPtVGHu9+epdKZPn65evXqpQ4cOeuGFF2zaatWqZY/y8oQRI0bo1q1bmj17tlavXq3Zs2frhx9+UL169XTq1ClecXcfcXFxypcvX4btTk5OzAF4HxUqVNC1a9c0dOhQdevWTRaLJd1psvh7nDHDMFS5cmVrmLt+/bqeeeYZ68OLRh5/9IBgl0N+++03m0vkERER6tSpk/Wdfr1799aCBQvsVV6ud/XqVXl7e1s/R0ZGKjAw0Pr5ueeeU0xMjD1KyzNq165tMxGxYRhauXKlVq1aZf1BxgTFmdu2bZtWr16t+vXr65VXXpGPj4969OhhHXSNzJUsWVI///yzKlasmG77wYMH5evrm8NV5S33HiyZNm2apk+fbhNCmGj8wZj931qCXQ7Jnz+/zZicnTt3avr06Tbt169ft0dpeYK3t7dOnz6t0qVL6/bt29q/f78mTZpkbb927VqmVwIgnT592t4l5HlxcXHWJ7S9vLxUoEABm18wkLm2bdvqnXfeUZs2bZQ/f36btqSkJE2YMEHt2rWzU3V5A3+PH13v3r3tXcJjRbDLIbVr19bixYs1depU/fDDD4qLi1Pz5s2t7adOnbrv5LFPsrZt22r06NH68MMP9fXXX6tAgQJq1KiRtf3gwYOqUKGCHSvM/Zh4OHv8ea5JBwcH3gKQBePGjdPq1atVuXJlDRkyRFWqVJEkHTt2THPmzFFKSorefvttO1eZu/H3GPfDPHY55N6tQ19fX124cEHdunXT/Pnzre1vvPGGbty4oYULF9qxytzr999/V8eOHfXjjz/Kzc1NCxcu1EsvvWRtb9GiherXr6/33nvPjlXmbtOmTdPQoUPl6uoq6Y9xn3Xr1pWLi4ukP656jho1Sp999pk9y8zVHBwc5OHhYR2bEx8fL3d39zQTi1+5csUe5eUJZ8+e1eDBg7Vx40abIQABAQGaM2fOA81Z+SRbs2ZNuus9PDxUuXJlbmU/gPLlyz9Qv7w6LyrBLgcdPXpUmzZtko+Pj15++WWbfwy++OIL1atXT08//bQdK8z9EhIS5ObmZvMCcemPf0jd3Ny4epIJR0dHXbhwQV5eXpIkd3d3RUdHW3/IxcXFqUSJEozNycSD/uJl9ls92eHq1as6efKkDMNQpUqVVKRIEXuXlCdk9nYii8Wirl276t///neaScjxfxwcHFSmTBl1797d+vMwPW+++WYOVpV9CHa5RGpqqr799lvGl+CxcXBwUGxsrPUHWaFChXTgwAGCHWACCQkJ2rdvn4KDg/XSSy/p/ffft3dJudbKlSsVGhqqrVu3KjAwUH379lXbtm1N80pPgp2dnTx5UqGhoQoLC9OlS5d0584de5cEkyLYZZ+kpCSFh4dbXylWpUoVtWzZ0nqbG7CXDRs2aNiwYTp27Ji9S8n1fvvtN4WFhSksLEw3b95Uz5491a9fvzw/yTPBzg6SkpK0cuVKzZs3T9u3b1ejRo3UtWtXvfTSSzZTegDZiWCXPdasWaP+/fvr999/t1lfrFgxzZ8/X+3bt7dTZYB05swZ1ahRg1kWsigyMlITJ07Utm3b9Pvvv+fpoQE8FZuD9uzZo3nz5mnZsmWqUKGCevTooR07duizzz6Tn5+fvcvDE2DevHlyc3OT9Mdr7sLCwlSsWDFJfzw8gczt2LFDnTt31gsvvKB//OMfqlatmiTpyJEjmjFjhjp37qzIyEjVr1/fzpXiSfXLL78ww0IW3Lp1S6tWrVJoaKh27dqll19+Oc+PT+SKXQ6pVauWEhMT1b17d/Xo0UPVq1eXJOXLl08HDhwg2OGxK1u27AO9Nod5sjLWtm1blS5dWv/617/SbX/99dcVExPD6wFhF9HR0erbt6+aNGmimTNn2rucXG3Xrl2aP3++VqxYofLly6tv377q0aNHnr5Sdw9X7HLI8ePH1aVLFzVr1owQB7s4c+aMvUvI83bu3KkPP/www/bg4GA1adIkByvCk6ZIkSLp/oJ248YN3b17V61atbKZvB1pVa9eXRcvXlT37t0VGRlputkoCHY55JdfflFYWJgGDx6spKQkdevWTT169DDVi4eRu0VFReny5cs2T14vWrRIEyZM0I0bN9ShQwd98skn1nntkFZSUpLc3d0zbPfw8NCtW7dysCI8aWbNmpXuend3d1WpUoULBw/g6NGjKliwoBYtWqTFixdn2C+vzkfJrVg72Lx5s0JDQ7V69WrdunVLb731lvr376/KlSvbuzSYWJs2bdSsWTONGjVKknTo0CE9++yzeu2111StWjVNnz5dr7/+uiZOnGjfQnOxWrVqafjw4erTp0+67aGhoZo1a1a6L2UHkDuYfT5Kgp0dJSQkaMmSJQoNDdX+/ftVo0YN/kHAY+Pr66u1a9eqbt26kqS3335bkZGR+vHHHyX9MbfThAkTdOTIEXuWmavNnDlTU6ZM0eLFi9W2bVubtvXr16t3794aO3asQkJC7FQhnkSGYWjLli1KSkrS3/72N1OME8PDI9jlEtHR0QoNDdXHH39s71JgUvnz59eJEydUunRpSVLDhg0VGBhofTfnmTNnVLNmTZ6OzURqaqq6dOmiL7/8UlWqVFG1atVkGIaOHj2qEydOqEOHDlq5cqVpJjpF7hMfH68333xT+/fvV/369TVjxgy1bdtWO3bskCR5eXlp06ZNqlWrlp0rzf3MOh8lwQ54QpQpU0aLFy9W48aNdfv2bRUuXFhr165VixYtJP1xa7ZJkyZ5dlxJTlq+fLmWLl2qEydOSJIqV66srl27qmvXrnauDGbXv39/bdu2Tb1799batWvl4OAgwzA0a9YsOTg4aOTIkXJzc9PatWvtXWquZub5KAl2OaR58+b37WOxWBQREZED1eBJNHjwYB04cEAffvihvv76ay1cuFDnz5+3vl93yZIlmjVrlvbs2WPnSnOvxMTEB+qX2QMWwKMoWbKkli5dqiZNmui3335T6dKltXnzZjVt2lSStHv3br3wwguKjY21b6G52I4dO9S0adMM56Nct25dnp6PkmCXQ+69dDgoKEj58uXLsB9zD+Fx+f3339WxY0f9+OOPcnNz08KFC/XSSy9Z21u0aKH69evrvffes2OVuZuDg0OmT7IbhiGLxcLbO/DYODk5KSYmRr6+vpKkAgUK6NChQ6pQoYIkKTY2ViVLluS/wUyYfT5Kgl0OmT59uhYsWKDLly+rR48e6tu3r2rUqGHvsvAESkhIkJubmxwdHW3WX7lyRW5ubtYreEgrMjLS+mfDMNS2bVvNmzdPJUuWtOnHXHZ4XHg14KPz9PRUZGSkatasmW77wYMH1aRJE129ejWHK8sezGOXQ0aMGKERI0YoKipKoaGhatCggapUqaK+ffuqe/fu3LpBjvHw8Eh3vaenZw5Xkvf8NbA5Ojqqfv361n9UgZzAqwEfjdnno+SKnZ3cvHlTK1eu1Jw5c3TkyBGdP3+ecAfkMX+9WgI8brwa8NGZfT5KrtjZyf79+xUZGamjR4+qRo0amY67AwBA4tWA2aFPnz5666235O3tne58lCNHjtTYsWPtVN2jI9jloPPnzyssLExhYWFKTEzUq6++ql27dvEKGCAP47WAyG1+++23NOM+8X/efPNN7dixQ+3atUszH+X//vc/vfTSSxo2bJi9y3xo3IrNIW3bttWWLVvUunVr9e3bV0FBQXJyIlcDeUnHjh1tPq9du1bNmzdXwYIFbdavXr06J8sCJP3xROx7772n+fPn6+bNm/YuJ9cz63yUBLsc4uDgIF9fX3l5eWX6G/7+/ftzsCoAWZHRmJy/WrBgwWOuBE+qq1ev6o033lB4eLicnZ01evRoDRkyRBMnTtQ///lP6/ixLl262LvUXO/y5csqWrSoJOncuXOaN2+ekpKS9MILL6hRo0Z2ru7hEexyyKRJkx6o34QJEx5zJQCAvOr111/Xhg0b9PLLL2vjxo06cuSIAgIC5ODgoHHjxuXZSXVz0qFDh9S+fXvFxMSoUqVKWrZsmdq0aaMbN27IwcFBN27c0KpVq9ShQwd7l/pQCHYAAOQRTz31lMLCwtS8eXOdOXNG5cuX1+jRo/X+++/bu7Q8IzAwUE5OTho9erQWL16sdevWqXXr1po3b54kaejQodq3b5927txp50ofDsEul7h165Y+/fRTvfXWW/YuBQCQS6X35om9e/fyEF4WFCtWTJs3b1atWrV0/fp1ubu7a8+ePapTp44k6dixY6pfv77i4+PtW+hDcrB3AU+SS5cuad26ddq0aZN1VvA7d+5o9uzZKlu2rD744AM7VwgAyM0Mw7B58M7R0VGurq52rCjvuXLlinx8fCRJbm5uKliwoIoUKWJtL1KkSJ6e6JnHMnPIjz/+qHbt2ikxMVEWi0V169bVggUL1KFDBzk5OWnixInq3bu3vcsEAORihmGoRYsW1nCXlJSk9u3bp3kVIA/iZe6vDzGaadoibsXmkKZNm6pEiRIaO3asFi5cqBkzZqhSpUp677331LlzZ3uXBwDIA3gQ79E5ODgoMDBQLi4uktJOW5ScnKwNGzbk2fftEuxySNGiRfXDDz/Iz89PSUlJcnNz0+rVq/Xiiy/auzQAAJ4YZp+2iGCXQxwcHBQbGysvLy9Jf7xjMjo6WhUqVLBzZQAAM0hMTNSSJUs0f/587d27197lwE4YY5eDjhw5otjYWEl/jJM4fvy4bty4YdOnVq1a9igNAJBHbdmyRaGhoVq9erU8PDz00ksv2bsk2BFX7HKIg4ODLBaL0jvd99ZbLJY8e08fAJBzfvvtN4WFhWnBggWKj4/X1atXtXTpUr3yyiumehAAWccVuxxy+vRpe5cAAMjjvvzyS82fP1/btm1TYGCgZsyYocDAQBUsWFA1a9Yk1IFgl1PKlClj7xIAAHlcly5dNGrUKC1fvlyFChWydznIhZigOIdMmzZNSUlJ1s/bt29XcnKy9fO1a9f0xhtv2KM0AEAe0a9fP82ZM0dt2rTR3LlzdfXqVXuXhFyGMXY5xNHRURcuXLA+Fevu7q7o6GiVL19ekhQXF6cSJUowxg4AkKmkpCStWLFCoaGh2rVrlwICArR+/XpFR0erRo0a9i4PdsYVuxzy1/xMngYAPAxXV1f17t1bkZGROnTokPz8/OTt7a0GDRqoe/fuWr16tb1LhB0R7AAAyKMqVaqkqVOnKiYmRkuWLNHNmzfVrVs3e5cFOyLYAQCQx1y+fNn655iYGE2cOFGRkZEKCQlRTEyMHSuDvfFUbA6aN2+e3NzcJEl3795VWFiYihUrJumPhycAAMjMoUOH1L59e8XExKhSpUpatmyZ2rRpoxs3bsjBwUEzZ87UqlWr1KFDB3uXCjvh4YkcUrZs2QeaX4j57gAAGQkMDJSTk5NGjx6txYsXa926dQoICNC///1vSdLQoUO1b98+7dy5086Vwl4IdgAA5BHFihXT5s2bVatWLV2/fl3u7u7as2eP6tSpI0k6duyY6tevr/j4ePsWCrvhVmwOSk1NVVhYmFavXq0zZ87IYrGofPny6tSpk3r27MmM4QCATF25ckU+Pj6SJDc3NxUsWFBFihSxthcpUoShPU84Hp7IIYZhqH379urfv79+++031axZU9WrV9eZM2f02muv8dJmAMAD+etFAC4K4M+4YpdDwsLC9MMPPygiIkLNmjWzadu8ebM6dOigRYsWqVevXnaqEACQF7z22mtycXGRJN26dUuDBg1SwYIFJcnmjUZ4MjHGLoe0bt1azZs31+jRo9Ntf//99xUZGamNGzfmcGUAgLyiT58+D9RvwYIFj7kS5FYEuxzi4+OjDRs2qHbt2um2//TTTwoMDFRsbGzOFgYAAEyDMXY55MqVK/L29s6w3dvbm5c5AwCAR0KwyyEpKSlycsp4SKOjo6Pu3r2bgxUBAACz4eGJHGIYhs2A179iwCsAAHhUBLsc0rt37/v24YlYAADwKHh4AgAAwCQYYwcAAGASBDsAAACTINgBAACYBMEOAADAJAh2AHAfFotFX3/9tb3LAID7ItgBeOLFxsZq6NChKl++vFxcXFS6dGm1b99eERER9i4NALKEeewAPNHOnDmjBg0aqHDhwpo+fbpq1qypO3fuaOPGjQoODtaxY8fsXSIAPDCu2AF4or3xxhuyWCzavXu3OnXqpMqVK6t69eoKCQnRzp070/3OqFGjVLlyZRUoUEDly5fXO++8ozt37ljbDxw4oGbNmqlQoUJyd3dXnTp1tHfvXknS2bNn1b59exUpUkQFCxZU9erV9e233+bIsQIwP67YAXhiXblyRRs2bNB7772nggULpmkvXLhwut8rVKiQwsLCVKJECR06dEgDBgxQoUKFNHLkSElSjx499Mwzz+jzzz+Xo6OjoqOjlS9fPklScHCwbt++rW3btqlgwYI6cuSI3NzcHtsxAniyEOwAPLFOnjwpwzBUtWrVLH1v3Lhx1j+XLVtWb731lpYtW2YNdufOndOIESOs261UqZK1/7lz59SpUyfVrFlTklS+fPlHPQwAsOJWLIAn1sO+UXH58uVq0KCBfHx85ObmpnHjxuncuXPW9pCQEPXv318tW7bUBx98oFOnTlnb/v73v2vKlClq0KCBJkyYoIMHDz7ycQDAPQQ7AE+sSpUqyWKxZOkBiaioKPXo0UNt27bVunXr9NNPP+ntt9/W7du3rX0mTpyow4cPKygoSJs3b5afn5+++uorSVL//v31yy+/qGfPnjp06JDq1q2rTz75JNuPDcCTyWI87K+sAGACgYGBOnTokI4fP55mnF18fLwKFy4si8Wir776Sh06dNCMGTP02Wef2VyF69+/v1atWqX4+Ph099GtWzfduHFDa9asSdM2ZswYrV+/nit3ALIFV+wAPNHmzJmjlJQUPf/88/ryyy914sQJHT16VB9//LH8/f3T9K9UqZLOnTunZcuW6dSpU/r444+tV+MkKSkpSUOGDNHWrVt19uxZbd++XXv27FG1atUkScOGDdPGjRt1+vRp7d+/X1u2bLG2AcCj4uEJAE+08uXLa//+/Xrvvff0j3/8QxcuXFDx4sVVp04dff7552n6v/DCCxo+fLiGDBmi5ORkBQUF6Z133tHEiRMlSY6Ojrp8+bJ69eqluLg4FStWTB07dtSkSZMkSSkpKQoODtavv/4qd3d3tWnTRjNnzszJQwZgYtyKBQAAMAluxQIAAJgEwQ4AAMAkCHYAAAAmQbADAAAwCYIdAACASRDsAAAATIJgBwAAYBIEOwAAAJMg2AEAAJgEwQ4AAMAkCHYAAAAmQbADAAAwif8HhwZ7LKJTxSIAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Distribución de clases\n", + "df['Class'].value_counts().plot(kind='bar', title='Distribución de Clases')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "caca2128", + "metadata": {}, + "source": [ + "## 3. Preparación de Datos" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "b19d4476", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Clases: ['BARBUNYA' 'BOMBAY' 'CALI' 'DERMASON' 'HOROZ' 'SEKER' 'SIRA']\n", + "Train: (10888, 16) | Test: (2723, 16)\n", + "Escalado aplicado — X_train_scaled shape: (10888, 16)\n" + ] + } + ], + "source": [ + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "feature_names = [c for c in df.columns if c != 'Class']\n", + "X = df[feature_names].values\n", + "y_raw = df['Class'].values\n", + "\n", + "le = LabelEncoder()\n", + "y = le.fit_transform(y_raw)\n", + "print('Clases:', le.classes_)\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " X, y, test_size=0.2, stratify=y, random_state=RANDOM_STATE\n", + ")\n", + "print(f'Train: {X_train.shape} | Test: {X_test.shape}')\n", + "\n", + "# Escalado para la Red Neuronal (fit solo en train, transform en ambos)\n", + "scaler = StandardScaler()\n", + "X_train_scaled = scaler.fit_transform(X_train)\n", + "X_test_scaled = scaler.transform(X_test)\n", + "print('Escalado aplicado — X_train_scaled shape:', X_train_scaled.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "6ce7295c", + "metadata": {}, + "source": [ + "## 4. Bitácora — Funciones\n", + "\n", + "Las funciones `metricas()` y `registrar()` están en `src/utils.py`. \n", + "Registran cada experimento en `outputs/bitacora_experimentos.csv` en modo append." + ] + }, + { + "cell_type": "markdown", + "id": "f11cba6f", + "metadata": {}, + "source": [ + "## 5. Experimentos — Random Forest\n", + "\n", + "≥5 experimentos variando: `n_estimators`, `max_depth`, `min_samples_leaf`, `max_features`, `criterion`" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "7705ae9c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[bitacora] random_forest | RF_01 | F1 test=0.9328\n", + "[bitacora] random_forest | RF_02 | F1 test=0.9319\n", + "[bitacora] random_forest | RF_03 | F1 test=0.9311\n", + "[bitacora] random_forest | RF_04 | F1 test=0.9317\n", + "[bitacora] random_forest | RF_05 | F1 test=0.9316\n", + "Experimentos RF registrados.\n" + ] + } + ], + "source": [ + "experimentos_rf = [\n", + " {'n_estimators': 100, 'max_depth': None, 'min_samples_leaf': 1, 'max_features': 'sqrt', 'criterion': 'gini'},\n", + " {'n_estimators': 200, 'max_depth': 10, 'min_samples_leaf': 1, 'max_features': 'sqrt', 'criterion': 'gini'},\n", + " {'n_estimators': 200, 'max_depth': 20, 'min_samples_leaf': 2, 'max_features': 'sqrt', 'criterion': 'gini'},\n", + " {'n_estimators': 500, 'max_depth': None, 'min_samples_leaf': 5, 'max_features': 'log2', 'criterion': 'gini'},\n", + " {'n_estimators': 300, 'max_depth': None, 'min_samples_leaf': 1, 'max_features': 'sqrt', 'criterion': 'entropy'},\n", + "]\n", + "\n", + "for i, cfg in enumerate(experimentos_rf, 1):\n", + " model = RandomForestClassifier(**cfg, random_state=RANDOM_STATE, n_jobs=-1)\n", + " model.fit(X_train, y_train)\n", + " registrar(f'RF_{i:02d}', 'random_forest', cfg, '', model, X_train, y_train, X_test, y_test)\n", + "\n", + "print('Experimentos RF registrados.')" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "45162343", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " experimento_id f1_train f1_test\n", + "0 RF_01 1.000000 0.932772\n", + "1 RF_02 0.970755 0.931902\n", + "3 RF_04 0.968360 0.931652\n", + "4 RF_05 1.000000 0.931572\n", + "2 RF_03 0.989488 0.931058\n", + "\n", + "Mejor RF: {'n_estimators': 100, 'max_depth': None, 'min_samples_leaf': 1, 'max_features': 'sqrt', 'criterion': 'gini'}\n" + ] + } + ], + "source": [ + "# Leer bitácora y seleccionar mejor RF\n", + "df_bit = pd.read_csv(os.path.join('outputs', 'bitacora_experimentos.csv'))\n", + "df_rf = df_bit[df_bit['modelo'] == 'random_forest']\n", + "print(df_rf[['experimento_id', 'f1_train', 'f1_test']].sort_values('f1_test', ascending=False))\n", + "\n", + "mejor_rf_cfg = experimentos_rf[df_rf['f1_test'].idxmax() - df_rf.index[0]]\n", + "mejor_rf = RandomForestClassifier(**mejor_rf_cfg, random_state=RANDOM_STATE, n_jobs=-1)\n", + "mejor_rf.fit(X_train, y_train)\n", + "print('\\nMejor RF:', mejor_rf_cfg)" + ] + }, + { + "cell_type": "markdown", + "id": "14a08696", + "metadata": {}, + "source": [ + "## 6. Experimentos — XGBoost\n", + "\n", + "≥5 experimentos variando: `n_estimators`, `max_depth`, `learning_rate`, `subsample`, `colsample_bytree`, `reg_lambda`" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "3cdc3f32", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[bitacora] xgboost | XGB_01 | F1 test=0.9363\n", + "[bitacora] xgboost | XGB_02 | F1 test=0.9377\n", + "[bitacora] xgboost | XGB_03 | F1 test=0.9370\n", + "[bitacora] xgboost | XGB_04 | F1 test=0.9340\n", + "[bitacora] xgboost | XGB_05 | F1 test=0.9365\n", + "Experimentos XGBoost registrados.\n" + ] + } + ], + "source": [ + "experimentos_xgb = [\n", + " {'n_estimators': 100, 'max_depth': 6, 'learning_rate': 0.3, 'subsample': 1.0, 'colsample_bytree': 1.0, 'reg_lambda': 1},\n", + " {'n_estimators': 200, 'max_depth': 6, 'learning_rate': 0.1, 'subsample': 0.8, 'colsample_bytree': 0.8, 'reg_lambda': 1},\n", + " {'n_estimators': 300, 'max_depth': 4, 'learning_rate': 0.05, 'subsample': 0.8, 'colsample_bytree': 0.8, 'reg_lambda': 2},\n", + " {'n_estimators': 200, 'max_depth': 8, 'learning_rate': 0.1, 'subsample': 0.6, 'colsample_bytree': 0.6, 'reg_lambda': 5},\n", + " {'n_estimators': 500, 'max_depth': 6, 'learning_rate': 0.01, 'subsample': 0.8, 'colsample_bytree': 0.8, 'reg_lambda': 1},\n", + "]\n", + "\n", + "for i, cfg in enumerate(experimentos_xgb, 1):\n", + " model = XGBClassifier(**cfg, random_state=RANDOM_STATE, eval_metric='mlogloss', verbosity=0)\n", + " model.fit(X_train, y_train)\n", + " registrar(f'XGB_{i:02d}', 'xgboost', cfg, '', model, X_train, y_train, X_test, y_test)\n", + "\n", + "print('Experimentos XGBoost registrados.')" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "1472d6b1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " experimento_id f1_train f1_test\n", + "6 XGB_02 0.999447 0.937734\n", + "7 XGB_03 0.972587 0.936978\n", + "9 XGB_05 0.969759 0.936526\n", + "5 XGB_01 0.999941 0.936272\n", + "8 XGB_04 0.997685 0.933975\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Mejor XGBoost: {'n_estimators': 200, 'max_depth': 6, 'learning_rate': 0.1, 'subsample': 0.8, 'colsample_bytree': 0.8, 'reg_lambda': 1}\n" + ] + } + ], + "source": [ + "df_bit = pd.read_csv(os.path.join('outputs', 'bitacora_experimentos.csv'))\n", + "df_xgb = df_bit[df_bit['modelo'] == 'xgboost']\n", + "print(df_xgb[['experimento_id', 'f1_train', 'f1_test']].sort_values('f1_test', ascending=False))\n", + "\n", + "mejor_xgb_cfg = experimentos_xgb[df_xgb['f1_test'].idxmax() - df_xgb.index[0]]\n", + "mejor_xgb = XGBClassifier(**mejor_xgb_cfg, random_state=RANDOM_STATE, eval_metric='mlogloss', verbosity=0)\n", + "mejor_xgb.fit(X_train, y_train)\n", + "print('\\nMejor XGBoost:', mejor_xgb_cfg)" + ] + }, + { + "cell_type": "markdown", + "id": "cbfd6199", + "metadata": {}, + "source": [ + "## 7. Experimentos — Red Neuronal (Keras)\n", + "\n", + "≥5 experimentos variando: capas, neuronas, `dropout`, `lr`, `batch_size`, `epochs`" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "6fd7b0c7", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "I0000 00:00:1782283235.163821 678660 cudart_stub.cc:31] Could not find cuda drivers on your machine, GPU will not be used.\n", + "I0000 00:00:1782283235.560729 678660 cpu_feature_guard.cc:227] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "I0000 00:00:1782283237.375377 678660 cudart_stub.cc:31] Could not find cuda drivers on your machine, GPU will not be used.\n", + "E0000 00:00:1782283237.662609 678660 cuda_platform.cc:52] failed call to cuInit: INTERNAL: CUDA error: Failed call to cuInit: UNKNOWN ERROR (303)\n", + "I0000 00:00:1782283237.662748 678660 cuda_diagnostics.cc:171] verbose logging is disabled. Rerun with verbose logging (usually --v=1 or --vmodule=cuda_diagnostics=1) to get more diagnostic output from this module\n", + "I0000 00:00:1782283237.662754 678660 cuda_diagnostics.cc:176] retrieving CUDA diagnostic information for host: 41ad1eab7f7e\n", + "I0000 00:00:1782283237.662760 678660 cuda_diagnostics.cc:183] hostname: 41ad1eab7f7e\n", + "I0000 00:00:1782283237.662891 678660 cuda_diagnostics.cc:190] libcuda reported version is: NOT_FOUND: was unable to find libcuda.so DSO loaded into this program. The library may be missing or provided via another object.\n", + "I0000 00:00:1782283237.663023 678660 cuda_diagnostics.cc:194] kernel reported version is: 580.159.3\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[bitacora] neural_network | NN_01 | F1 test=0.9374\n", + "[bitacora] neural_network | NN_02 | F1 test=0.9408\n", + "[bitacora] neural_network | NN_03 | F1 test=0.9388\n", + "[bitacora] neural_network | NN_04 | F1 test=0.9386\n", + "[bitacora] neural_network | NN_05 | F1 test=0.9383\n", + "Experimentos NN (Keras) registrados.\n" + ] + } + ], + "source": [ + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "from tensorflow.keras import layers\n", + "\n", + "N_CLASES = len(le.classes_) # 7\n", + "N_FEATURES = X_train_scaled.shape[1] # 16\n", + "\n", + "def crear_modelo(capas, activacion='relu', dropout=0.0, lr=0.001):\n", + " model = keras.Sequential()\n", + " model.add(keras.Input(shape=(N_FEATURES,)))\n", + " for neuronas in capas:\n", + " model.add(layers.Dense(neuronas, activation=activacion))\n", + " if dropout > 0:\n", + " model.add(layers.Dropout(dropout))\n", + " model.add(layers.Dense(N_CLASES, activation='softmax'))\n", + " model.compile(\n", + " optimizer=keras.optimizers.Adam(learning_rate=lr),\n", + " loss='sparse_categorical_crossentropy',\n", + " )\n", + " return model\n", + "\n", + "\n", + "class KerasWrapper:\n", + " \"\"\"Wrapper sklearn-compatible para modelos Keras.\"\"\"\n", + " def __init__(self, model, batch_size=64, epochs=100):\n", + " self.model = model\n", + " self.batch_size = batch_size\n", + " self.epochs = epochs\n", + "\n", + " def predict(self, X):\n", + " return np.argmax(self.model.predict(X, verbose=0), axis=1)\n", + "\n", + " def fit(self, X, y, **kwargs):\n", + " self.model.fit(X, y,\n", + " batch_size=self.batch_size,\n", + " epochs=self.epochs,\n", + " verbose=0)\n", + " return self\n", + "\n", + "\n", + "experimentos_nn = [\n", + " {'capas': (64,), 'activacion': 'relu', 'dropout': 0.0, 'lr': 0.001, 'batch_size': 32, 'epochs': 50, 'arquitectura': '[64]→softmax'},\n", + " {'capas': (128, 64), 'activacion': 'relu', 'dropout': 0.3, 'lr': 0.001, 'batch_size': 64, 'epochs': 100, 'arquitectura': '[128,64]+Dropout(0.3)→softmax'},\n", + " {'capas': (256, 128, 64), 'activacion': 'relu', 'dropout': 0.3, 'lr': 0.001, 'batch_size': 64, 'epochs': 100, 'arquitectura': '[256,128,64]+Dropout(0.3)→softmax'},\n", + " {'capas': (128, 64), 'activacion': 'relu', 'dropout': 0.2, 'lr': 0.0001, 'batch_size': 32, 'epochs': 150, 'arquitectura': '[128,64]+Dropout(0.2)→softmax(lr=0.0001)'},\n", + " {'capas': (256, 128), 'activacion': 'relu', 'dropout': 0.4, 'lr': 0.001, 'batch_size': 128, 'epochs': 100, 'arquitectura': '[256,128]+Dropout(0.4)→softmax'},\n", + "]\n", + "\n", + "for i, cfg in enumerate(experimentos_nn, 1):\n", + " tf.random.set_seed(RANDOM_STATE)\n", + " model = crear_modelo(cfg['capas'], cfg['activacion'], cfg['dropout'], cfg['lr'])\n", + " model.fit(X_train_scaled, y_train,\n", + " batch_size=cfg['batch_size'], epochs=cfg['epochs'], verbose=0)\n", + " wrapper = KerasWrapper(model, cfg['batch_size'], cfg['epochs'])\n", + " hiperparams = {k: v for k, v in cfg.items() if k != 'arquitectura'}\n", + " registrar(f'NN_{i:02d}', 'neural_network', hiperparams, cfg['arquitectura'],\n", + " wrapper, X_train_scaled, y_train, X_test_scaled, y_test)\n", + "\n", + "print('Experimentos NN (Keras) registrados.')" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "4b453a52", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " experimento_id f1_train f1_test\n", + "11 NN_02 0.952976 0.940837\n", + "12 NN_03 0.957654 0.938762\n", + "13 NN_04 0.950294 0.938605\n", + "14 NN_05 0.954552 0.938261\n", + "10 NN_01 0.950540 0.937374\n", + "\n", + "Mejor NN — hiperparámetros: {'capas': (128, 64), 'activacion': 'relu', 'dropout': 0.3, 'lr': 0.001, 'batch_size': 64, 'epochs': 100}\n", + "Arquitectura: [128,64]+Dropout(0.3)→softmax\n" + ] + } + ], + "source": [ + "df_bit = pd.read_csv(os.path.join('outputs', 'bitacora_experimentos.csv'))\n", + "df_nn = df_bit[df_bit['modelo'] == 'neural_network']\n", + "print(df_nn[['experimento_id', 'f1_train', 'f1_test']].sort_values('f1_test', ascending=False))\n", + "\n", + "mejor_nn_idx = df_nn['f1_test'].idxmax() - df_nn.index[0]\n", + "mejor_nn_cfg = experimentos_nn[mejor_nn_idx]\n", + "\n", + "tf.random.set_seed(RANDOM_STATE)\n", + "model_nn = crear_modelo(mejor_nn_cfg['capas'], mejor_nn_cfg['activacion'],\n", + " mejor_nn_cfg['dropout'], mejor_nn_cfg['lr'])\n", + "model_nn.fit(X_train_scaled, y_train,\n", + " batch_size=mejor_nn_cfg['batch_size'],\n", + " epochs=mejor_nn_cfg['epochs'], verbose=0)\n", + "mejor_nn = KerasWrapper(model_nn, mejor_nn_cfg['batch_size'], mejor_nn_cfg['epochs'])\n", + "print('\\nMejor NN — hiperparámetros:', {k: v for k, v in mejor_nn_cfg.items() if k != 'arquitectura'})\n", + "print('Arquitectura:', mejor_nn_cfg['arquitectura'])" + ] + }, + { + "cell_type": "markdown", + "id": "a897674a", + "metadata": {}, + "source": [ + "## 8. Feature Importance — Random Forest vs XGBoost" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "fa2d947c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[figura] guardada en /home/aleleba/projects/cursos/Universidad/Machine Learning Aplicado/proyecto-final/outputs/figures/feature_importance__random_forest.png\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[figura] guardada en /home/aleleba/projects/cursos/Universidad/Machine Learning Aplicado/proyecto-final/outputs/figures/feature_importance__xgboost.png\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxYAAAJ2CAYAAADCPRRJAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAnglJREFUeJzs3Xl4DXf///HnScjJcrJYQiwhIbHv6225kaKCprbWUkpsrb1oLFFbqvZqS6tohdAW1VKUorgbJbRoUSW0UsH9bVq1JWJJSM7vD7/M3dMEidP2UK/Hdc11ZWY+85n3TPTqeeUznzkmq9VqRURERERExA5Oji5AREREREQefgoWIiIiIiJiNwULERERERGxm4KFiIiIiIjYTcFCRERERETspmAhIiIiIiJ2U7AQERERERG7KViIiIiIiIjdFCxERERERMRuChYiIiIiImI3BQsRkTuIiYnBZDLluIwdO/YvOeeePXuYPHkyly9f/kv6t0fW/Thw4ICjS7lvb7/9NjExMY4u44G2ePFiTCYTy5Yty7Zv7969ODk5ERERkW3fp59+SlhYGEWLFsXFxYWCBQvSpEkT5syZQ0pKik3bgIAAm/+eXF1dCQ4OZtSoUVy8ePEvu7bc+uyzz5g8ebKjyxB56JisVqvV0UWIiDyIYmJi6N27Ny+//DKBgYE2+6pUqUKNGjX+9HO++uqrjBo1ilOnThEQEPCn92+PrPuxf/9+6tSp4+hy7kuVKlUoXLgwsbGxji7lgWW1WmnSpAnHjx/n+PHjFCpUCICbN29Sq1YtUlJSOHbsGB4eHgBkZmbSt29fYmJiqFq1Kp06dcLf358rV66wd+9e1q9fT8OGDdmxY4dxjoCAAAoUKMCLL74IwI0bN/jmm29YvHgxNWvWZN++fX//hf/OkCFDmD9/PvqIJJI3+RxdgIjIg65169YP7QfpLFevXjU+CD6Krl27hru7u6PLeCiYTCYWLVpEjRo1iIiIYOnSpQDMmTOH77//ng0bNtj8W5o1axYxMTGMGDGCOXPmYDKZjH0vvPACSUlJLF++PNt5SpQoQY8ePYz1fv36YbFYePXVV/nxxx8JDg7+C69SRP4KehRKRMROmzdv5t///jceHh54enrStm1bjh49atPmu+++Izw8nDJlyuDq6oqfnx99+vThwoULRpvJkyczatQoAAIDA43HRBITE0lMTMRkMuX4GI/JZLJ5bGPy5MmYTCaOHTvGM888Q4ECBWjcuLGx//3336d27dq4ublRsGBBunbtytmzZ+/r2sPDw7FYLJw5c4YnnngCi8VCiRIlmD9/PgBHjhzhsccew8PDg9KlS7NixQqb47Mer/ryyy95/vnnKVSoEF5eXvTs2ZNLly5lO9/bb79N5cqVMZvNFC9enMGDB2d7bKxZs2ZUqVKFb775hiZNmuDu7s64ceMICAjg6NGj7Ny507i3zZo1A+DixYtERERQtWpVLBYLXl5etG7dmsOHD9v0HRsbi8lkYvXq1UydOpWSJUvi6upK8+bNOXnyZLZ6v/76a9q0aUOBAgXw8PCgWrVqzJ0716bN8ePHeeqppyhYsCCurq7UqVOHDRs25PVX8aeqVKkSo0aNIiYmhp07d3Lq1ClefvllOnbsSFhYmNHu2rVrzJw5k8qVKzN79mybUJGlWLFijBkzJlfn9fPzAyBfPtu/e/7nP/8x/hvz8fGhXbt2xMfHZzv+4MGDtG7dGi8vLywWC82bN+err76yaXPz5k2ioqIIDg7G1dWVQoUK0bhxY7Zt2wbc/jed9e/3949rici9acRCROQekpOTOX/+vM22woULA/Dee+/Rq1cvWrVqxcyZM7l27RoLFiygcePGHDx40Hicadu2bfz000/07t0bPz8/jh49yjvvvMPRo0f56quvMJlMdOzYkR9++IGVK1fy+uuvG+fw9fXlt99+y3PdTz/9NMHBwUybNs14pGPq1KlMmDCBzp07069fP3777TfefPNNmjRpwsGDB/Hx8cnzeTIyMmjdujVNmjRh1qxZfPDBBwwZMgQPDw9eeuklunfvTseOHVm4cCE9e/akQYMG2R4tGzJkCD4+PkyePJkTJ06wYMECTp8+bXyQh9uBKSoqihYtWjBw4ECj3f79+4mLiyN//vxGfxcuXKB169Z07dqVHj16ULRoUZo1a8bQoUOxWCy89NJLABQtWhSAn376iXXr1vH0008TGBjIr7/+yqJFi2jatCnHjh2jePHiNvXOmDHDmGuQnJzMrFmz6N69O19//bXRZtu2bTzxxBMUK1aMF154AT8/P+Lj49m4cSMvvPACAEePHqVRo0aUKFGCsWPH4uHhwerVq2nfvj1r1qyhQ4cOef59/FnGjx/PqlWreP755yldujT58uVj3rx5Nm12797N5cuXiYiIwNnZOU/937x50/jv6saNGxw8eJDXXnuNJk2a2Pz72L59O61bt6ZMmTJMnjyZ69ev8+abb9KoUSO+/fZb47+xo0eP8u9//xsvLy9Gjx5N/vz5WbRoEc2aNWPnzp3Ur18fuP3vaPr06fTr14969eqRkpLCgQMH+Pbbb2nZsiXPP/88P//8M9u2beO9996z4w6KPIKsIiKSo6VLl1qBHBer1Wq9cuWK1cfHx9q/f3+b43755Rert7e3zfZr165l63/lypVWwPrll18a22bPnm0FrKdOnbJpe+rUKStgXbp0abZ+AOukSZOM9UmTJlkBa7du3WzaJSYmWp2dna1Tp0612X7kyBFrvnz5sm2/0/3Yv3+/sa1Xr15WwDpt2jRj26VLl6xubm5Wk8lkXbVqlbH9+PHj2WrN6rN27drW9PR0Y/usWbOsgHX9+vVWq9VqPXfunNXFxcX6+OOPWzMyMox2b731lhWwLlmyxNjWtGlTK2BduHBhtmuoXLmytWnTptm237hxw6Zfq/X2PTebzdaXX37Z2PbFF19YAWvFihWtaWlpxva5c+daAeuRI0esVqvVeuvWLWtgYKC1dOnS1kuXLtn0m5mZafzcvHlza9WqVa03btyw2d+wYUNrcHBwtjr/blu3bjX+zb/xxhvZ9mdd97p162y237p1y/rbb7/ZLL+/7tKlS+f431WjRo2s58+ft+mrRo0a1iJFilgvXLhgbDt8+LDVycnJ2rNnT2Nb+/btrS4uLtaEhARj288//2z19PS0NmnSxNhWvXp1a9u2be963YMHD7bqI5JI3ulRKBGRe5g/fz7btm2zWeD2X6QvX75Mt27dOH/+vLE4OztTv359vvjiC6MPNzc34+cbN25w/vx5/vWvfwHw7bff/iV1DxgwwGZ97dq1ZGZm0rlzZ5t6/fz8CA4Otqk3r/r162f87OPjQ/ny5fHw8KBz587G9vLly+Pj48NPP/2U7fjnnnvOZsRh4MCB5MuXj88++wy4/Vfr9PR0hg8fjpPT//7X1b9/f7y8vNi0aZNNf2azmd69e+e6frPZbPSbkZHBhQsXsFgslC9fPsffT+/evXFxcTHW//3vfwMY13bw4EFOnTrF8OHDs40CZY3AXLx4kf/85z907tyZK1euGL+PCxcu0KpVK3788Uf+7//+L9fX8FcoWLCgcV8ef/zxbPuz3vZksVhsth85cgRfX1+b5feP/QHUr1/f+O9p48aNTJ06laNHj/Lkk09y/fp1AJKSkjh06BDh4eEULFjQOLZatWq0bNnS+PeRkZHB559/Tvv27SlTpozRrlixYjzzzDPs3r3bqNXHx4ejR4/y448/2nt7ROQP9CiUiMg91KtXL8fJ21kfTB577LEcj/Py8jJ+vnjxIlFRUaxatYpz587ZtEtOTv4Tq/2fPz5u9OOPP2K1Wu84Kfb3H+zzwtXVFV9fX5tt3t7elCxZMtuz6d7e3jnOnfhjTRaLhWLFipGYmAjA6dOngdvh5PdcXFwoU6aMsT9LiRIlbD7430tmZiZz587l7bff5tSpU2RkZBj7st6K9HulSpWyWS9QoACAcW0JCQnA7bdQ3cnJkyexWq1MmDCBCRMm5Njm3LlzlChRIsd9v/32m02deeHr63vPR5cyMjJ47rnnKF68OKmpqQwbNswI1Vk8PT0BSE1NtdkeFBRktF2+fHmOjxQVLlyYFi1aGOtt27alfPnyPPXUUyxevJihQ4fe8fcOULFiRbZu3crVq1e5cuUK165du2O7zMxMzp49S+XKlXn55Zdp164d5cqVo0qVKoSGhvLss89SrVq1u94PEbk3BQsRkfuUmZkJ3J5nkTXp9Pd+PwG1c+fO7Nmzh1GjRlGjRg0sFguZmZmEhoYa/dzNnSaP3u2D5e9HSbLqNZlMbN68OccPlX/8q3Nu3ekD6p22W/+GV3j+8drvZdq0aUyYMIE+ffowZcoU4y/1w4cPz/H382dcW1a/ERERtGrVKsc2QUFBdzy+bt262QJVbuXmdcZz587l4MGDrFu3jv/7v/9j8ODBrFixgmeeecZoU6FCBQC+//572rVrZ2y3WCxGaNi9e3eu62revDkAX375JUOHDs31cXnRpEkTEhISWL9+PZ9//jmLFy/m9ddfZ+HChTYjbyKSdwoWIiL3qWzZsgAUKVLE5i+vf3Tp0iV27NhBVFQUEydONLbn9CjGnQJE1l/E//gGpLx8sCxbtixWq5XAwEDKlSuX6+P+Dj/++CMhISHGempqKklJSbRp0waA0qVLA3DixAmbR13S09M5derUXe//793p/n788ceEhIQQHR1ts/3y5cvGJPq8yPq38f3339+xtqzryJ8/f67r/70PPvjAeGQor3IKwr939uxZJk2aRLt27WjXrh2ZmZksW7aMkSNH0rZtW7y9vYHbj4B5e3uzatUqIiMjbR5Tux+3bt0C/jcC8vvf+x8dP36cwoUL4+HhgaurK+7u7nds5+TkhL+/v7GtYMGC9O7dm969e5OamkqTJk2YPHmyESz0FiiR+6M5FiIi96lVq1Z4eXkxbdo0bt68mW1/1pucsv66/ce/Zr/xxhvZjsn6foA/BggvLy8KFy7Ml19+abP97bffznW9HTt2xNnZmaioqGy1WK3WbM/A/53eeecdm3u4YMECbt26RevWrQFo0aIFLi4uzJs3z6b26OhokpOTadu2ba7O4+HhkeO3mjs7O2e7Jx999NF9z3GoVasWgYGBvPHGG9nOl3WeIkWK0KxZMxYtWkRSUlK2Pu71JrBGjRrRokWL+1pcXV3v2vfQoUOxWq28+eabADg5ObFw4ULOnz/PuHHjjHbu7u6MHj2a77//nrFjx+Y4YpOXUZxPP/0UgOrVqwO350jUqFGDZcuW2dzH77//ns8//9wIns7Ozjz++OOsX7/eeHwO4Ndff2XFihU0btzYeDTxj//OLRYLQUFBpKWlGdvu9N+hiNydRixERO6Tl5cXCxYs4Nlnn6VWrVp07doVX19fzpw5w6ZNm2jUqBFvvfUWXl5exqtYb968SYkSJfj88885depUtj5r164NwEsvvUTXrl3Jnz8/YWFheHh40K9fP2bMmEG/fv2oU6cOX375JT/88EOu6y1btiyvvPIKkZGRJCYm0r59ezw9PTl16hSffPIJzz33HBEREX/a/cmL9PR0mjdvTufOnTlx4gRvv/02jRs35sknnwRuzwmIjIwkKiqK0NBQnnzySaNd3bp1bb5o7W5q167NggULeOWVVwgKCqJIkSI89thjPPHEE7z88sv07t2bhg0bcuTIET744AOb0ZG8cHJyYsGCBYSFhVGjRg169+5NsWLFOH78OEePHmXr1q3A7RcDNG7cmKpVq9K/f3/KlCnDr7/+yt69e/nvf/+b7Xs0/g6ffPIJ69evZ86cOTZ/5a9ZsyaDBw/mrbfeIjw8nLp16wIwduxY4uPjmT17Np9//jmdOnWiZMmSXLp0iW+//ZaPPvqIIkWKZAsz//d//8f7778P3P79Hz58mEWLFlG4cGGbx6Bmz55N69atadCgAX379jVeN+vt7W3z/S2vvPIK27Zto3HjxgwaNIh8+fKxaNEi0tLSmDVrltGuUqVKNGvWjNq1a1OwYEEOHDjAxx9/zJAhQ4w2Wf8dDhs2jFatWuHs7EzXrl3/vJss8k/liFdRiYg8DHJ6vWpOvvjiC2urVq2s3t7eVldXV2vZsmWt4eHh1gMHDhht/vvf/1o7dOhg9fHxsXp7e1uffvpp688//5zt9atWq9U6ZcoUa4kSJaxOTk42r569du2atW/fvlZvb2+rp6entXPnztZz587d8XWzv/32W471rlmzxtq4cWOrh4eH1cPDw1qhQgXr4MGDrSdOnMjz/ejVq5fVw8MjW9umTZtaK1eunG176dKlbV71mdXnzp07rc8995y1QIECVovFYu3evbvN60WzvPXWW9YKFSpY8+fPby1atKh14MCB2V7neqdzW623XwXctm1bq6enpxUwXj1748YN64svvmgtVqyY1c3NzdqoUSPr3r17rU2bNrV5PW3W62Y/+ugjm37v9Drg3bt3W1u2bGn19PS0enh4WKtVq2Z98803bdokJCRYe/bsafXz87Pmz5/fWqJECesTTzxh/fjjj3O8hr/SlStXrCVLlrTWqFHDeuvWrWz7U1JSrMWLF7fWqlUr2/5PPvnE2qZNG6uvr681X758Vh8fH2vjxo2ts2fPtl6+fNmm7R9fN+vk5GQtUqSItVu3btaTJ09mO+/27dutjRo1srq5uVm9vLysYWFh1mPHjmVr9+2331pbtWpltVgsVnd3d2tISIh1z549Nm1eeeUVa7169aw+Pj5WNzc3a4UKFaxTp061ed3xrVu3rEOHDrX6+vpaTSaTXj0rkksmq/VvmEUnIiKSg5iYGHr37s3+/ftzfPOWiIg8PDTHQkRERERE7KZgISIiIiIidlOwEBERERERu2mOhYiIiIiI2E0jFiIiIiIiYjcFCxERERERsZu+IE9ylJmZyc8//4ynpycmk8nR5YiIiIiIA1itVq5cuULx4sVxcrr7mISCheTo559/tvnGVRERERF5dJ09e5aSJUvetY2CheTI09MTuP2PyMvLy8HViIiIiIgjpKSk4O/vb3w2vBsFC8lR1uNPXl5eChYiIiIij7jcPBqvydsiIiIiImI3BQsREREREbGbgoWIiIiIiNhNwUJEREREROymYCEiIiIiInZTsBAREREREbvpdbNyV1UmbcXJ7O7oMkREREQeaYkz2jq6hHvSiIWIiIiIiNhNwUJEREREROz2wAcLk8nEunXrHF2GiIiIiIjchcODxW+//cbAgQMpVaoUZrMZPz8/WrVqRVxcnKNLs5GYmIjJZMq29OjRw+6+Y2NjMZlMXL582f5Cgd27d9OoUSMKFSqEm5sbFSpU4PXXX/9T+hYRERERyYnDJ2936tSJ9PR0li1bRpkyZfj111/ZsWMHFy5ccHRpOdq+fTuVK1c21t3c3BxYjS2r1UpGRgYeHh4MGTKEatWq4eHhwe7du3n++efx8PDgueeec3SZIiIiIvIP5NARi8uXL7Nr1y5mzpxJSEgIpUuXpl69ekRGRvLkk08a7c6fP0+HDh1wd3cnODiYDRs2GPsyMjLo27cvgYGBuLm5Ub58eebOnWtznvDwcNq3b09UVBS+vr54eXkxYMAA0tPTjTaZmZlMnz7d6Kd69ep8/PHH2WouVKgQfn5+xuLt7U1CQgLt2rWjaNGiWCwW6taty/bt222OS0tLY8yYMfj7+2M2mwkKCiI6OprExERCQkIAKFCgACaTifDwcOOYYcOGUaRIEVxdXWncuDH79+83+swa6di8eTO1a9fGbDaze/duatasSbdu3ahcuTIBAQH06NGDVq1asWvXrvv/ZYmIiIiI3IVDg4XFYsFisbBu3TrS0tLu2C4qKorOnTvz3Xff0aZNG7p3787FixeB24GgZMmSfPTRRxw7doyJEycybtw4Vq9ebdPHjh07iI+PJzY2lpUrV7J27VqioqKM/dOnT2f58uUsXLiQo0ePMmLECHr06MHOnTvveR2pqam0adOGHTt2cPDgQUJDQwkLC+PMmTNGm549e7Jy5UrmzZtHfHw8ixYtwmKx4O/vz5o1awA4ceIESUlJRjAaPXo0a9asYdmyZXz77bcEBQXRqlUr49qzjB07lhkzZhAfH0+1atWy1Xfw4EH27NlD06ZN73gNaWlppKSk2CwiIiIiIrllslqtVkcWsGbNGvr378/169epVasWTZs2pWvXrsYHZJPJxPjx45kyZQoAV69exWKxsHnzZkJDQ3Psc8iQIfzyyy/GiEN4eDiffvopZ8+exd399ncyLFy4kFGjRpGcnMzNmzcpWLAg27dvp0GDBkY//fr149q1a6xYsYLExERjNMPJ6X95bNeuXdSsWTNbDVWqVGHAgAEMGTKEH374gfLly7Nt2zZatGiRrW1sbCwhISFcunQJHx8f4zoLFChATEwMzzzzDAA3b94kICCA4cOHM2rUKOO4devW0a5du2z9lixZkt9++41bt24xefJkJkyYcMffw+TJk22CVhb/4av1PRYiIiIiDuao77FISUnB29ub5ORkvLy87tr2gZhj0bZtW3bt2sVXX33F5s2bmTVrFosXLzYeCfr9X+E9PDzw8vLi3Llzxrb58+ezZMkSzpw5w/Xr10lPT6dGjRo256levboRKgAaNGhAamoqZ8+eJTU1lWvXrtGyZUubY9LT07OFhg8//JCKFSsa6/7+/qSmpjJ58mQ2bdpEUlISt27d4vr168aIxaFDh3B2dr7riMEfJSQkcPPmTRo1amRsy58/P/Xq1SM+Pt6mbZ06dXLsY9euXaSmpvLVV18xduxYgoKC6NatW45tIyMjGTlypLGekpKCv79/rusVERERkUebw4MFgKurKy1btqRly5ZMmDCBfv36MWnSJCNY5M+f36a9yWQiMzMTgFWrVhEREcGcOXNo0KABnp6ezJ49m6+//jrX509NTQVg06ZNlChRwmaf2Wy2Wff39ycoKMhm2wsvvMC2bdt49dVXCQoKws3NjaeeesqYw/FXT/D28PDIcXtgYCAAVatW5ddff2Xy5Ml3DBZmsznbtYqIiIiI5NYDESz+qFKlSrn+7oq4uDgaNmzIoEGDjG0JCQnZ2h0+fJjr168bH/K/+uorY45DwYIFMZvNnDlzJk+jCr+vITw8nA4dOgC3g0piYqKxv2rVqmRmZrJz584cH4VycXEBbk9Ez1K2bFlcXFyIi4ujdOnSwO1Hofbv38/w4cPzXGNmZuZd57GIiIiIiNjDocHiwoULPP300/Tp04dq1arh6enJgQMHmDVrVo5zBnISHBzM8uXL2bp1K4GBgbz33nvs37/f+Gt9lvT0dPr27cv48eNJTExk0qRJDBkyBCcnJzw9PYmIiGDEiBFkZmbSuHFjkpOTiYuLw8vLi169et2zhrVr1xIWFobJZGLChAnGiApAQEAAvXr1ok+fPsybN4/q1atz+vRpzp07R+fOnSldujQmk4mNGzfSpk0b3NzcsFgsDBw4kFGjRlGwYEFKlSrFrFmzuHbtGn379r1rPfPnz6dUqVJUqFABgC+//JJXX32VYcOG5eqeioiIiIjklUODhcVioX79+rz++uvGnAJ/f3/69+/PuHHjctXH888/z8GDB+nSpQsmk4lu3boxaNAgNm/ebNOuefPmBAcH06RJE9LS0ujWrRuTJ0829k+ZMgVfX1+mT5/OTz/9hI+PD7Vq1cpVHa+99hp9+vShYcOGFC5cmDFjxmR7q9KCBQsYN24cgwYN4sKFC5QqVcrou0SJEkRFRTF27Fh69+5Nz549iYmJYcaMGWRmZvLss89y5coV6tSpw9atWylQoMBd68nMzCQyMpJTp06RL18+ypYty8yZM3n++edzdU9FRERERPLK4W+F+juEh4dz+fLlXD9eJf97A4DeCiUiIiLieA/DW6Ec+j0WIiIiIiLyz6BgISIiIiIidnskHoWSvMvLsJeIiIiI/DPpUSgREREREflbKViIiIiIiIjdFCxERERERMRuChYiIiIiImI3BQsREREREbGbgoWIiIiIiNhNwUJEREREROymYCEiIiIiInZTsBAREREREbspWIiIiIiIiN0ULERERERExG4KFiIiIiIiYjcFCxERERERsZuChYiIiIiI2E3BQkRERERE7KZgISIiIiIidsvn6ALkwVZl0laczO6OLkNERETkoZI4o62jS/jbacRCRERERETspmAhIiIiIiJ2U7AQERERERG7PTDB4pdffmHo0KGUKVMGs9mMv78/YWFh7Nixw9Gl2S0gIIA33njD0WWIiIiIiPxlHojJ24mJiTRq1AgfHx9mz55N1apVuXnzJlu3bmXw4MEcP37c0SWKiIiIiMhdPBAjFoMGDcJkMrFv3z46depEuXLlqFy5MiNHjuSrr74C4MyZM7Rr1w6LxYKXlxedO3fm119/NfqYPHkyNWrUYMmSJZQqVQqLxcKgQYPIyMhg1qxZ+Pn5UaRIEaZOnWpzbpPJxIIFC2jdujVubm6UKVOGjz/+2KbNmDFjKFeuHO7u7pQpU4YJEyZw8+ZNmzaffvopdevWxdXVlcKFC9OhQwcAmjVrxunTpxkxYgQmkwmTyQRATEwMPj4+bN26lYoVK2KxWAgNDSUpKcmm38WLF1OxYkVcXV2pUKECb7/9trEvPT2dIUOGUKxYMVxdXSldujTTp08HwGq1MnnyZEqVKoXZbKZ48eIMGzbMnl+TiIiIiMgdOXzE4uLFi2zZsoWpU6fi4eGRbb+Pjw+ZmZlGqNi5cye3bt1i8ODBdOnShdjYWKNtQkICmzdvZsuWLSQkJPDUU0/x008/Ua5cOXbu3MmePXvo06cPLVq0oH79+sZxEyZMYMaMGcydO5f33nuPrl27cuTIESpWrAiAp6cnMTExFC9enCNHjtC/f388PT0ZPXo0AJs2baJDhw689NJLLF++nPT0dD777DMA1q5dS/Xq1Xnuuefo37+/zbVdu3aNV199lffeew8nJyd69OhBREQEH3zwAQAffPABEydO5K233qJmzZocPHiQ/v374+HhQa9evZg3bx4bNmxg9erVlCpVirNnz3L27FkA1qxZw+uvv86qVauoXLkyv/zyC4cPH77j7yEtLY20tDRjPSUlJS+/RhERERF5xDk8WJw8eRKr1UqFChXu2GbHjh0cOXKEU6dO4e/vD8Dy5cupXLky+/fvp27dugBkZmayZMkSPD09qVSpEiEhIZw4cYLPPvsMJycnypcvz8yZM/niiy9sgsXTTz9Nv379AJgyZQrbtm3jzTffNEYHxo8fb7QNCAggIiKCVatWGcFi6tSpdO3alaioKKNd9erVAShYsCDOzs54enri5+dnc103b95k4cKFlC1bFoAhQ4bw8ssvG/snTZrEnDlz6NixIwCBgYEcO3aMRYsW0atXL86cOUNwcDCNGzfGZDJRunRp49gzZ87g5+dHixYtyJ8/P6VKlaJevXp3vMfTp0+3qV9EREREJC8c/iiU1Wq9Z5v4+Hj8/f2NUAFQqVIlfHx8iI+PN7YFBATg6elprBctWpRKlSrh5ORks+3cuXM2/Tdo0CDb+u/7/fDDD2nUqBF+fn5YLBbGjx/PmTNnjP2HDh2iefPmubhaW+7u7kaoAChWrJhR29WrV0lISKBv375YLBZjeeWVV0hISAAgPDycQ4cOUb58eYYNG8bnn39u9PX0009z/fp1ypQpQ//+/fnkk0+4devWHWuJjIwkOTnZWLJGPkREREREcsPhwSI4OBiTyfSnTNDOnz+/zbrJZMpxW2ZmZq773Lt3L927d6dNmzZs3LiRgwcP8tJLL5Genm60cXNz+9PqzQpaqampALz77rscOnTIWL7//ntj3kmtWrU4deoUU6ZM4fr163Tu3JmnnnoKAH9/f06cOMHbb7+Nm5sbgwYNokmTJtnmhmQxm814eXnZLCIiIiIiueXwYFGwYEFatWrF/PnzuXr1arb9ly9fpmLFijbzBwCOHTvG5cuXqVSpkt01ZH1Q//161vyKPXv2ULp0aV566SXq1KlDcHAwp0+ftmlfrVq1u74W18XFhYyMjDzVVLRoUYoXL85PP/1EUFCQzRIYGGi08/LyokuXLrz77rt8+OGHrFmzhosXLwK3A09YWBjz5s0jNjaWvXv3cuTIkTzVISIiIiKSGw6fYwEwf/58GjVqRL169Xj55ZepVq0at27dYtu2bSxYsIBjx45RtWpVunfvzhtvvMGtW7cYNGgQTZs2pU6dOnaf/6OPPqJOnTo0btyYDz74gH379hEdHQ3cHlE5c+YMq1atom7dumzatIlPPvnE5vhJkybRvHlzypYtS9euXbl16xafffYZY8aMAW4/ovXll1/StWtXzGYzhQsXzlVdUVFRDBs2DG9vb0JDQ0lLS+PAgQNcunSJkSNH8tprr1GsWDFq1qyJk5MTH330EX5+fvj4+BATE0NGRgb169fH3d2d999/Hzc3N5t5GCIiIiIifxaHj1gAlClThm+//ZaQkBBefPFFqlSpQsuWLdmxYwcLFizAZDKxfv16ChQoQJMmTWjRogVlypThww8//FPOHxUVxapVq6hWrRrLly9n5cqVxkjIk08+yYgRIxgyZAg1atRgz549TJgwweb4Zs2a8dFHH7FhwwZq1KjBY489xr59+4z9L7/8MomJiZQtWxZfX99c19WvXz8WL17M0qVLqVq1Kk2bNiUmJsYYsfD09GTWrFnUqVOHunXrkpiYaExU9/Hx4d1336VRo0ZUq1aN7du38+mnn1KoUKE/4Y6JiIiIiNgyWXMze/ofzGQy8cknn9C+fXtHl/JASUlJwdvbG//hq3Eyuzu6HBEREZGHSuKMto4u4U+R9ZkwOTn5nnNwH4gRCxERERERebgpWIiIiIiIiN0eiMnbjvSIPwl2T99HtdKrZ0VERETknjRiISIiIiIidlOwEBERERERuylYiIiIiIiI3RQsRERERETEbgoWIiIiIiJiNwULERERERGxm4KFiIiIiIjYTcFCRERERETspmAhIiIiIiJ2U7AQERERERG7KViIiIiIiIjdFCxERERERMRuChYiIiIiImI3BQsREREREbGbgoWIiIiIiNhNwUJEREREROyWz9EFyIOtyqStOJndHV2GiIjIP1bijLaOLkHkT6ERCxERERERsZuChYiIiIiI2O2hDxYxMTH4+Pj8JX1PnjyZGjVq/CV9i4iIiIj8k/ylwSI8PByTyZRtCQ0N/dPO0aVLF3744Ydct09MTLSpxdPTk8qVKzN48GB+/PFHm7YRERHs2LHjT6vVHiaTiXXr1jm6DBERERGRHP3lk7dDQ0NZunSpzTaz2fyn9e/m5oabm1uej9u+fTuVK1fm2rVrHDlyhLlz51K9enU+/fRTmjdvDoDFYsFisfxptT4Ibt68Sf78+R1dhoiIiIj8w/zlj0KZzWb8/PxslgIFCgDw448/0qRJE1xdXalUqRLbtm2z+ct8bGwsJpOJy5cvG/0dOnQIk8lEYmIiYPso1A8//IDJZOL48eM2Nbz++uuULVvWZluhQoXw8/OjTJkytGvXju3bt1O/fn369u1LRkYGkP1RqP3799OyZUsKFy6Mt7c3TZs25dtvv7Xp12QysWjRIp544gnc3d2pWLEie/fu5eTJkzRr1gwPDw8aNmxIQkKCzXHr16+nVq1auLq6UqZMGaKiorh16xYAAQEBAHTo0AGTyWSs3+u4rHoWLFjAk08+iYeHB1OnTr37L0xERERE5D44bI5FZmYmHTt2xMXFha+//pqFCxcyZswYu/osV64cderU4YMPPrDZ/sEHH/DMM8/c9VgnJydeeOEFTp8+zTfffJNjmytXrtCrVy92797NV199RXBwMG3atOHKlSs27aZMmULPnj05dOgQFSpU4JlnnuH5558nMjKSAwcOYLVaGTJkiNF+165d9OzZkxdeeIFjx46xaNEiYmJijBCwf/9+AJYuXUpSUpKxfq/jskyePJkOHTpw5MgR+vTpk+O1paWlkZKSYrOIiIiIiOTWXx4sNm7caDxSlLVMmzaN7du3c/z4cZYvX0716tVp0qQJ06ZNs/t83bt3Z+XKlcb6Dz/8wDfffEP37t3veWyFChUAjNGQP3rsscfo0aMHFSpUoGLFirzzzjtcu3aNnTt32rTr3bs3nTt3ply5cowZM4bExES6d+9Oq1atqFixIi+88AKxsbFG+6ioKMaOHUuvXr0oU6YMLVu2ZMqUKSxatAgAX19fAHx8fPDz8zPW73VclmeeeYbevXtTpkwZSpUqleO1TZ8+HW9vb2Px9/e/5/0SEREREcnyl8+xCAkJYcGCBTbbChYsyHvvvYe/vz/Fixc3tjdo0MDu83Xt2pWIiAi++uor/vWvf/HBBx9Qq1YtIzTcjdVqBW4/PpSTX3/9lfHjxxMbG8u5c+fIyMjg2rVrnDlzxqZdtWrVjJ+LFi0KQNWqVW223bhxg5SUFLy8vDh8+DBxcXE2Iw0ZGRncuHGDa9eu4e6e8xfU5fa4OnXq3PPaIyMjGTlypLGekpKicCEiIiIiufaXBwsPDw+CgoLu61gnp9sDKlkf+OH25OO78fPz47HHHmPFihX861//YsWKFQwcODBX54uPjwcgMDAwx/29evXiwoULzJ07l9KlS2M2m2nQoAHp6ek27X4/OTorpOS0LTMzE4DU1FSioqLo2LFjtnO6urresd7cHufh4XHHPrKYzeY/dVK9iIiIiDxa/vJgcScVK1bk7NmzJCUlUaxYMQC++uormzZZj/wkJSUZE74PHTp0z767d+/O6NGj6datGz/99BNdu3a95zGZmZnMmzePwMBAatasmWObuLg43n77bdq0aQPA2bNnOX/+/D37vpdatWpx4sSJuwaw/PnzG5PK83KciIiIiMjf4S8PFmlpafzyyy+2J82XjxYtWlCuXDl69erF7NmzSUlJ4aWXXrJpFxQUhL+/P5MnT2bq1Kn88MMPzJkz557n7NixIwMHDmTgwIGEhITYPG6V5cKFC/zyyy9cu3aN77//njfeeIN9+/axadMmnJ2dc+w3ODiY9957jzp16pCSksKoUaPu61W3fzRx4kSeeOIJSpUqxVNPPYWTkxOHDx/m+++/55VXXgFuvxlqx44dNGrUCLPZTIECBXJ1nIiIiIjI3+Evn7y9ZcsWihUrZrM0btwYJycnPvnkE65fv069evXo169ftrcZ5c+fn5UrV3L8+HGqVavGzJkzc/WB2dPTk7CwMA4fPnzHSdstWrSgWLFiVK1albFjx1KxYkW+++47QkJC7thvdHQ0ly5dolatWjz77LMMGzaMIkWK5O2G5KBVq1Zs3LiRzz//nLp16/Kvf/2L119/ndKlSxtt5syZw7Zt2/D39zdGVHJznIiIiIjI38Fk/f0EhgeAyWTik08+oX379o4u5ZGWkpJy++1Qw1fjZM558riIiIjYL3FGW0eXIHJHWZ8Jk5OT8fLyumtbh32PhYiIiIiI/HMoWIiIiIiIiN0c9laoO3nAnsx65H0f1eqew14iIiIiIhqxEBERERERuylYiIiIiIiI3RQsRERERETEbgoWIiIiIiJiNwULERERERGxm4KFiIiIiIjYTcFCRERERETspmAhIiIiIiJ2U7AQERERERG7KViIiIiIiIjdFCxERERERMRuChYiIiIiImI3BQsREREREbGbgoWIiIiIiNhNwUJEREREROymYCEiIiIiInbL5+gC5MFWZdJWnMzuji5DROSRlDijraNLEBHJNY1YiIiIiIiI3RQsRERERETEbgoWIiIiIiJiNwULB9u7dy/Ozs60bavnaEVERETk4aVg4WDR0dEMHTqUL7/8kp9//vmO7axWK7du3fobKxMRERERyT0FCwdKTU3lww8/ZODAgbRt25aYmBhjX2xsLCaTic2bN1O7dm3MZjO7d+8mMzOT6dOnExgYiJubG9WrV+fjjz82jsvIyKBv377G/vLlyzN37lwHXJ2IiIiIPEr0ulkHWr16NRUqVKB8+fL06NGD4cOHExkZiclkMtqMHTuWV199lTJlylCgQAGmT5/O+++/z8KFCwkODubLL7+kR48e+Pr60rRpUzIzMylZsiQfffQRhQoVYs+ePTz33HMUK1aMzp0737GWtLQ00tLSjPWUlJS/9NpFRERE5J9FwcKBoqOj6dGjBwChoaEkJyezc+dOmjVrZrR5+eWXadmyJXD7w/+0adPYvn07DRo0AKBMmTLs3r2bRYsW0bRpU/Lnz09UVJRxfGBgIHv37mX16tV3DRbTp0+3OU5EREREJC/0KJSDnDhxgn379tGtWzcA8uXLR5cuXYiOjrZpV6dOHePnkydPcu3aNVq2bInFYjGW5cuXk5CQYLSbP38+tWvXxtfXF4vFwjvvvMOZM2fuWk9kZCTJycnGcvbs2T/xakVERETkn04jFg4SHR3NrVu3KF68uLHNarViNpt56623jG0eHh7Gz6mpqQBs2rSJEiVK2PRnNpsBWLVqFREREcyZM4cGDRrg6enJ7Nmz+frrr+9aj9lsNvoQEREREckrBQsHuHXrFsuXL2fOnDk8/vjjNvvat2/PypUrqVChQrbjKlWqhNls5syZMzRt2jTHvuPi4mjYsCGDBg0ytv1+NENERERE5K+gYOEAGzdu5NKlS/Tt2xdvb2+bfZ06dSI6OprZs2dnO87T05OIiAhGjBhBZmYmjRs3Jjk5mbi4OLy8vOjVqxfBwcEsX76crVu3EhgYyHvvvcf+/fsJDAz8uy5PRERERB5BmmPhANHR0bRo0SJbqIDbweLAgQN89913OR47ZcoUJkyYwPTp06lYsSKhoaFs2rTJCA7PP/88HTt2pEuXLtSvX58LFy7YjF6IiIiIiPwVTFar1eroIuTBk5KSgre3N/7DV+Nkdnd0OSIij6TEGW0dXYKIPOKyPhMmJyfj5eV117YasRAREREREbspWIiIiIiIiN00eVvu6vuoVvcc9hIRERER0YiFiIiIiIjYTcFCRERERETspmAhIiIiIiJ2U7AQERERERG7KViIiIiIiIjdFCxERERERMRuChYiIiIiImI3BQsREREREbGbgoWIiIiIiNhNwUJEREREROymYCEiIiIiInZTsBAREREREbspWIiIiIiIiN0ULERERERExG4KFiIiIiIiYjcFCxERERERsVs+RxcgD7Yqk7biZHZ3dBkiIv8oiTPaOroEEZE/nUYsRERERETEbgoWIiIiIiJiNwULERERERGx20MXLH755ReGDh1KmTJlMJvN+Pv7ExYWxo4dOxxd2n2ZPn06zs7OzJ4929GliIiIiIjct4cqWCQmJlK7dm3+85//MHv2bI4cOcKWLVsICQlh8ODBji7vvixZsoTRo0ezZMmSe7ZNT0//GyoSEREREcm7hypYDBo0CJPJxL59++jUqRPlypWjcuXKjBw5kq+++gqAM2fO0K5dOywWC15eXnTu3Jlff/3V6GPy5MnUqFGD9957j4CAALy9venatStXrlwB4J133qF48eJkZmbanLtdu3b06dPHWF+/fj21atXC1dWVMmXKEBUVxa1btwB4+eWXKV68OBcuXDDat23blpCQEJt+d+7cyfXr13n55ZdJSUlhz549NufMqnXx4sUEBgbi6uoKwOXLl+nXrx++vr54eXnx2GOPcfjwYeO4hIQE2rVrR9GiRbFYLNStW5ft27fbde9FRERERO7moQkWFy9eZMuWLQwePBgPD49s+318fMjMzKRdu3ZcvHiRnTt3sm3bNn766Se6dOli0zYhIYF169axceNGNm7cyM6dO5kxYwYATz/9NBcuXOCLL77Idu7u3bsDsGvXLnr27MkLL7zAsWPHWLRoETExMUydOhWAl156iYCAAPr16wfA/Pnz2bNnD8uWLcPJ6X+3PDo6mm7dupE/f366detGdHR0tus6efIka9asYe3atRw6dMio8dy5c2zevJlvvvmGWrVq0bx5cy5evAhAamoqbdq0YceOHRw8eJDQ0FDCwsI4c+bMHe9vWloaKSkpNouIiIiISG49NMHi5MmTWK1WKlSocMc2O3bs4MiRI6xYsYLatWtTv359li9fzs6dO9m/f7/RLjMzk5iYGKpUqcK///1vnn32WWOORoECBWjdujUrVqww2n/88ccULlyYkJAQAKKiohg7diy9evWiTJkytGzZkilTprBo0SIAnJ2def/999mxYwdjx45l1KhRzJ8/n1KlShl9pqSk8PHHH9OjRw8AevTowerVq0lNTbW5pvT0dJYvX07NmjWpVq0au3fvZt++fXz00UfUqVOH4OBgXn31VXx8fPj4448BqF69Os8//zxVqlQhODiYKVOmULZsWTZs2HDHezd9+nS8vb2Nxd/fP1e/FxEREREReIiChdVqvWeb+Ph4/P39bT4UV6pUCR8fH+Lj441tAQEBeHp6GuvFihXj3Llzxnr37t1Zs2YNaWlpAHzwwQd07drVGG04fPgwL7/8MhaLxVj69+9PUlIS165dA6BMmTK8+uqrzJw5kyeffJJnnnnGptaVK1dStmxZqlevDkCNGjUoXbo0H374oU270qVL4+vra6wfPnyY1NRUChUqZHP+U6dOkZCQANwesYiIiKBixYr4+PhgsViIj4+/64hFZGQkycnJxnL27Nl73m8RERERkSwPzTdvBwcHYzKZOH78uN195c+f32bdZDLZzH0ICwvDarWyadMm6taty65du3j99deN/ampqURFRdGxY8dsfWfNgwD48ssvcXZ2JjExkVu3bpEv3/9ud3R0NEePHrXZlpmZyZIlS+jbt6+x7Y+PfaWmplKsWDFiY2OzndvHxweAiIgItm3bxquvvkpQUBBubm489dRTd538bTabMZvNd9wvIiIiInI3D02wKFiwIK1atWL+/PkMGzYs2wfuy5cvU7FiRc6ePcvZs2eNUYtjx45x+fJlKlWqlOtzubq60rFjRz744ANOnjxJ+fLlqVWrlrG/Vq1anDhxgqCgoDv28eGHH7J27VpiY2Pp3LkzU6ZMISoqCoAjR45w4MABYmNjKViwoHHMxYsXadasGcePH7/jI1+1atXil19+IV++fAQEBOTYJi4ujvDwcDp06ADcDiOJiYm5vn4RERERkbx6aIIF3J4E3ahRI+rVq8fLL79MtWrVuHXrFtu2bWPBggUcO3aMqlWr0r17d9544w1u3brFoEGDaNq0KXXq1MnTubp3784TTzzB0aNHjXkQWSZOnMgTTzxBqVKleOqpp3BycuLw4cN8//33vPLKK/z3v/9l4MCBzJw5k8aNG7N06VKeeOIJWrduzb/+9S+io6OpV68eTZo0yXbeunXrEh0dfcfvtWjRogUNGjSgffv2zJo1i3LlyvHzzz+zadMmOnToYMy7WLt2LWFhYZhMJiZMmJDtLVciIiIiIn+mh2aOBdyet/Dtt98SEhLCiy++SJUqVWjZsiU7duxgwYIFmEwm1q9fT4ECBWjSpAktWrSgTJky2eYt5MZjjz1GwYIFOXHiRLb5Ea1atWLjxo18/vnn1K1bl3/961+8/vrrlC5dGqvVSnh4OPXq1WPIkCFG+4EDB9KjRw9SUlJ4//336dSpU47n7dSpE8uXL+fmzZs57jeZTHz22Wc0adKE3r17U65cObp27crp06cpWrQoAK+99hoFChSgYcOGhIWF0apVK5sRFxERERGRP5vJmptZ0fLISUlJuf12qOGrcTK7O7ocEZF/lMQZbR1dgohIrmR9JkxOTsbLy+uubR+qEQsREREREXkwKViIiIiIiIjdHqrJ2/L3+z6q1T2HvURERERENGIhIiIiIiJ2U7AQERERERG7KViIiIiIiIjdFCxERERERMRuChYiIiIiImI3BQsREREREbGbgoWIiIiIiNhNwUJEREREROymYCEiIiIiInZTsBAREREREbspWIiIiIiIiN0ULERERERExG4KFiIiIiIiYjcFCxERERERsZuChYiIiIiI2E3BQkRERERE7JbP0QXIg63KpK04md0dXYbIIytxRltHlyAiIpIrGrEQERERERG7KViIiIiIiIjd/rJg0axZM4YPH/5Xdf+nS0xMxGQycejQIUeXYjeTycS6descXYaIiIiIPELyFCzCw8MxmUwMGDAg277BgwdjMpkIDw8HYO3atUyZMuVPKTK3Vq5cibOzM4MHD87zsf7+/iQlJVGlSpVctX8QPrxPnjyZGjVqOLQGERERERG4jxELf39/Vq1axfXr141tN27cYMWKFZQqVcrYVrBgQTw9Pf+cKu8gPT3dZj06OprRo0ezcuVKbty4kae+nJ2d8fPzI18+zWcXEREREcmrPAeLWrVq4e/vz9q1a41ta9eupVSpUtSsWdPY9sdHoQICApg2bRp9+vTB09OTUqVK8c4779j0feTIER577DHc3NwoVKgQzz33HKmpqcb+8PBw2rdvz9SpUylevDjly5c39p06dYo9e/YwduxYypUrZ1MfQJ8+fahWrRppaWnA7VBSs2ZNevbsCWR/FOrSpUt0794dX19f3NzcCA4OZunSpbm+T4sXL6ZixYq4urpSoUIF3n77bWNf1rnWrl1LSEgI7u7uVK9enb1799r08e677+Lv74+7uzsdOnTgtddew8fHB4CYmBiioqI4fPgwJpMJk8lETEyMcez58+fp0KED7u7uBAcHs2HDhlzXLiIiIiKSV/c1x6JPnz42H7KXLFlC796973ncnDlzqFOnDgcPHmTQoEEMHDiQEydOAHD16lVatWpFgQIF2L9/Px999BHbt29nyJAhNn3s2LGDEydOsG3bNjZu3GhsX7p0KW3btsXb25sePXoQHR1tc9y8efO4evUqY8eOBeCll17i8uXLvPXWWznWOmHCBI4dO8bmzZuJj49nwYIFFC5cOFf354MPPmDixIlMnTqV+Ph4pk2bxoQJE1i2bJlNu5deeomIiAgOHTpEuXLl6NatG7du3QIgLi6OAQMG8MILL3Do0CFatmzJ1KlTjWO7dOnCiy++SOXKlUlKSiIpKYkuXboY+6OioujcuTPfffcdbdq0oXv37ly8ePGONaelpZGSkmKziIiIiIjk1n0999OjRw8iIyM5ffo0cPtD8KpVq4iNjb3rcW3atGHQoEEAjBkzhtdff50vvviC8uXLs2LFCm7cuMHy5cvx8PAA4K233iIsLIyZM2dStGhRADw8PFi8eDEuLi5Gv5mZmcTExPDmm28C0LVrV1588UVOnTpFYGAgABaLhffff5+mTZvi6enJG2+8wRdffIGXl1eOtZ45c4aaNWtSp04d4PaIS25NmjSJOXPm0LFjRwACAwM5duwYixYtolevXka7iIgI2ra9/Y76qKgoKleuzMmTJ6lQoQJvvvkmrVu3JiIiAoBy5cqxZ88eI0y5ublhsVjIly8ffn5+2WoIDw+nW7duAEybNo158+axb98+QkNDc6x5+vTpREVF5foaRURERER+775GLHx9fWnbti0xMTHGSEFu/ppfrVo142eTyYSfnx/nzp0DID4+nurVqxuhAqBRo0ZkZmYaoxoAVatWtQkVANu2bePq1au0adMGgMKFC9OyZUuWLFli065BgwZEREQwZcoUXnzxRRo3bnzHWgcOHMiqVauoUaMGo0ePZs+ePfe8Prg98pKQkEDfvn2xWCzG8sorr5CQkHDH+1GsWDEA436cOHGCevXq2bT/4/rd/L5vDw8PvLy8jL5zEhkZSXJysrGcPXs21+cSEREREbnvmcp9+vQxHlOaP39+ro7Jnz+/zbrJZCIzMzNP5/198MgSHR3NxYsXcXNzM7ZlZmby3XffERUVhZOTk7EtLi4OZ2dnTp48edfztG7dmtOnT/PZZ5+xbds2mjdvzuDBg3n11VfvelzWnJB3332X+vXr2+xzdna2Wf/9/TCZTEaNf4a83muz2YzZbP5Tzi0iIiIij577/h6L0NBQ0tPTuXnzJq1atbK7kIoVK3L48GGuXr1qbIuLi8PJyclmkvYfXbhwgfXr17Nq1SoOHTpkLAcPHuTSpUt8/vnnRtvZs2dz/Phxdu7cyZYtW+45GdvX15devXrx/vvv88Ybb2SbbJ6TokWLUrx4cX766SeCgoJslqzHsnKjfPny7N+/32bbH9ddXFzIyMjIdZ8iIiIiIn+V+x6xcHZ2Jj4+3vjZXt27d2fSpEn06tWLyZMn89tvvzF06FCeffZZY35FTt577z0KFSpE586djb/6Z2nTpg3R0dGEhoZy8OBBJk6cyMcff0yjRo147bXXeOGFF2jatCllypTJ1u/EiROpXbs2lStXJi0tjY0bN1KxYkWbNqdOncr2hXrBwcFERUUxbNgwvL29CQ0NJS0tjQMHDnDp0iVGjhyZq/sxdOhQmjRpwmuvvUZYWBj/+c9/2Lx5s801BgQEGDWULFkST09PjTqIiIiIiEPY9c3bXl5ed5z8nFfu7u5s3bqVixcvUrduXZ566imaN29+x7c2ZVmyZAkdOnTIFioAOnXqxIYNG/jvf/9Ljx49CA8PJywsDIDnnnuOkJAQnn322Rz/6u/i4kJkZCTVqlWjSZMmODs7s2rVKps2I0eOpGbNmjbLwYMH6devH4sXL2bp0qVUrVqVpk2bEhMTk6cRi0aNGrFw4UJee+01qlevzpYtWxgxYgSurq421xcaGkpISAi+vr6sXLky1/2LiIiIiPyZTFar1eroIiR3+vfvz/Hjx9m1a9dffq6UlBS8vb3xH74aJ7P7X34+EclZ4oy2ji5BREQeYVmfCZOTk+85oKCvmX6Avfrqq7Rs2RIPDw82b97MsmXLbL5oT0RERETkQaFg8QDbt28fs2bN4sqVK5QpU4Z58+bRr18/R5clIiIiIpKNHoWSHOVl2EtERERE/pny8pnQrsnbIiIiIiIioGAhIiIiIiJ/AgULERERERGxm4KFiIiIiIjYTcFCRERERETspmAhIiIiIiJ2U7AQERERERG7KViIiIiIiIjdFCxERERERMRuChYiIiIiImI3BQsREREREbGbgoWIiIiIiNhNwUJEREREROymYCEiIiIiInZTsBAREREREbspWIiIiIiIiN3yOboAebBVmbQVJ7O7o8sQASBxRltHlyAiIiJ3oBELERERERGxm4KFiIiIiIjY7YEPFiaTiXXr1jm6DBERERERuQuHB4vffvuNgQMHUqpUKcxmM35+frRq1Yq4uDhHl2YjMTERk8mUbenRo4fdfcfGxmIymbh8+bL9hQJJSUk888wzlCtXDicnJ4YPH/6n9CsiIiIicicOn7zdqVMn0tPTWbZsGWXKlOHXX39lx44dXLhwwdGl5Wj79u1UrlzZWHdzc3NgNbasVisZGRmkpaXh6+vL+PHjef311x1dloiIiIg8Ahw6YnH58mV27drFzJkzCQkJoXTp0tSrV4/IyEiefPJJo9358+fp0KED7u7uBAcHs2HDBmNfRkYGffv2JTAwEDc3N8qXL8/cuXNtzhMeHk779u2JiorC19cXLy8vBgwYQHp6utEmMzOT6dOnG/1Ur16djz/+OFvNhQoVws/Pz1i8vb1JSEigXbt2FC1aFIvFQt26ddm+fbvNcWlpaYwZMwZ/f3/MZjNBQUFER0eTmJhISEgIAAUKFMBkMhEeHm4cM2zYMIoUKYKrqyuNGzdm//79Rp9ZIx2bN2+mdu3amM1mdu/eTUBAAHPnzqVnz554e3vf/y9IRERERCSXHBosLBYLFouFdevWkZaWdsd2UVFRdO7cme+++442bdrQvXt3Ll68CNwOBCVLluSjjz7i2LFjTJw4kXHjxrF69WqbPnbs2EF8fDyxsbGsXLmStWvXEhUVZeyfPn06y5cvZ+HChRw9epQRI0bQo0cPdu7cec/rSE1NpU2bNuzYsYODBw8SGhpKWFgYZ86cMdr07NmTlStXMm/ePOLj41m0aBEWiwV/f3/WrFkDwIkTJ0hKSjKC0ejRo1mzZg3Lli3j22+/JSgoiFatWhnXnmXs2LHMmDGD+Ph4qlWrds96c5KWlkZKSorNIiIiIiKSWyar1Wp1ZAFr1qyhf//+XL9+nVq1atG0aVO6du1qfEA2mUyMHz+eKVOmAHD16lUsFgubN28mNDQ0xz6HDBnCL7/8Yow4hIeH8+mnn3L27Fnc3W9/J8PChQsZNWoUycnJ3Lx5k4IFC7J9+3YaNGhg9NOvXz+uXbvGihUrSExMNEYznJz+l8d27dpFzZo1s9VQpUoVBgwYwJAhQ/jhhx8oX74827Zto0WLFtnaxsbGEhISwqVLl/Dx8TGus0CBAsTExPDMM88AcPPmTQICAhg+fDijRo0yjlu3bh3t2rXL8V40a9aMGjVq8MYbb9zt18DkyZNtglYW/+Gr9T0W8sDQ91iIiIj8vVJSUvD29iY5ORkvL6+7tnX45O1OnTrx888/s2HDBkJDQ4mNjaVWrVrExMQYbX7/V3gPDw+8vLw4d+6csW3+/PnUrl0bX19fLBYL77zzjs1oAUD16tWNUAHQoEEDUlNTOXv2LCdPnuTatWu0bNnSGEWxWCwsX76chIQEm34+/PBDDh06ZCyVKlUiNTWViIgIKlasiI+PDxaLhfj4eKOGQ4cO4ezsTNOmTXN9XxISErh58yaNGjUytuXPn5969eoRHx9v07ZOnTq57vdOIiMjSU5ONpazZ8/a3aeIiIiIPDocPnkbwNXVlZYtW9KyZUsmTJhAv379mDRpkjHXIH/+/DbtTSYTmZmZAKxatYqIiAjmzJlDgwYN8PT0ZPbs2Xz99de5Pn9qaioAmzZtokSJEjb7zGazzbq/vz9BQUE221544QW2bdvGq6++SlBQEG5ubjz11FPGHI6/eoK3h4eH3X2YzeZs1yoiIiIiklsPRLD4o0qVKuX6uyvi4uJo2LAhgwYNMrb9cZQB4PDhw1y/ft34kP/VV18ZcxwKFiyI2WzmzJkzeRpV+H0N4eHhdOjQAbgdVBITE439VatWJTMzk507d+b4KJSLiwtweyJ6lrJly+Li4kJcXBylS5cGbj8KtX//fr0+VkREREQeOA4NFhcuXODpp5+mT58+VKtWDU9PTw4cOMCsWbPuOGfgj4KDg1m+fDlbt24lMDCQ9957j/379xMYGGjTLj09nb59+zJ+/HgSExOZNGkSQ4YMwcnJCU9PTyIiIhgxYgSZmZk0btyY5ORk4uLi8PLyolevXvesYe3atYSFhWEymZgwYYIxogIQEBBAr1696NOnD/PmzaN69eqcPn2ac+fO0blzZ0qXLo3JZGLjxo20adMGNzc3LBYLAwcOZNSoURQsWJBSpUoxa9Ysrl27Rt++fe95Xw4dOgTcDjm//fYbhw4dwsXFhUqVKuXqvoqIiIiI5IVDg4XFYqF+/fq8/vrrxpwCf39/+vfvz7hx43LVx/PPP8/Bgwfp0qULJpOJbt26MWjQIDZv3mzTrnnz5gQHB9OkSRPS0tLo1q0bkydPNvZPmTIFX19fpk+fzk8//YSPjw+1atXKVR2vvfYaffr0oWHDhhQuXJgxY8Zke6vSggULGDduHIMGDeLChQuUKlXK6LtEiRJERUUxduxYevfuTc+ePYmJiWHGjBlkZmby7LPPcuXKFerUqcPWrVspUKDAPWv6/YTyb775hhUrVlC6dGmbkRQRERERkT+Lw98K9XcIDw/n8uXLuX68Sv73BgC9FUoeJHorlIiIyN/roXorlIiIiIiIPPwULERERERExG6PxKNQknd5GfYSERERkX8mPQolIiIiIiJ/KwULERERERGxm4KFiIiIiIjYTcFCRERERETspmAhIiIiIiJ2U7AQERERERG7KViIiIiIiIjdFCxERERERMRuChYiIiIiImI3BQsREREREbGbgoWIiIiIiNhNwUJEREREROymYCEiIiIiInZTsBAREREREbspWIiIiIiIiN0ULERERERExG75HF2APNiqTNqKk9nd0WWIAJA4o62jSxAREZE70IiFiIiIiIjYTcFCRERERETs5tBgYTKZWLdunSNLMCQmJmIymTh06JCjS7Hbg3RfRUREROTRkKdgER4ejslkYsCAAdn2DR48GJPJRHh4eK77S0pKonXr1nkp4a5WrlyJs7MzgwcPzvOx/v7+JCUlUaVKlVy1fxA+vE+ePJkaNWo4tAYREREREbiPEQt/f39WrVrF9evXjW03btxgxYoVlCpVKk99+fn5YTab81qCIT093WY9Ojqa0aNHs3LlSm7cuJGnvpydnfHz8yNfPs1nFxERERHJqzwHi1q1auHv78/atWuNbWvXrqVUqVLUrFnT2LZlyxYaN26Mj48PhQoV4oknniAhIcGmrz/+1f/IkSM89thjuLm5UahQIZ577jlSU1ON/eHh4bRv356pU6dSvHhxypcvb+w7deoUe/bsYezYsZQrV86mPoA+ffpQrVo10tLSgNuhpGbNmvTs2RPI/ijUpUuX6N69O76+vri5uREcHMzSpUtzfZ8WL15MxYoVcXV1pUKFCrz99tvGvqxzrV27lpCQENzd3alevTp79+616ePdd9/F398fd3d3OnTowGuvvYaPjw8AMTExREVFcfjwYUwmEyaTiZiYGOPY8+fP06FDB9zd3QkODmbDhg25rl1EREREJK/ua45Fnz59bD5kL1myhN69e9u0uXr1KiNHjuTAgQPs2LEDJycnOnToQGZmZo59Xr16lVatWlGgQAH279/PRx99xPbt2xkyZIhNux07dnDixAm2bdvGxo0bje1Lly6lbdu2eHt706NHD6Kjo22OmzdvHlevXmXs2LEAvPTSS1y+fJm33norx3omTJjAsWPH2Lx5M/Hx8SxYsIDChQvn6v588MEHTJw4kalTpxIfH8+0adOYMGECy5Yts2n30ksvERERwaFDhyhXrhzdunXj1q1bAMTFxTFgwABeeOEFDh06RMuWLZk6dapxbJcuXXjxxRepXLkySUlJJCUl0aVLF2N/VFQUnTt35rvvvqNNmzZ0796dixcv5qp+EREREZG8uq/nfnr06EFkZCSnT58Gbn8IXrVqFbGxsUabTp062RyzZMkSfH19OXbsWI7zGFasWMGNGzdYvnw5Hh4eALz11luEhYUxc+ZMihYtCoCHhweLFy/GxcXFODYzM5OYmBjefPNNALp27cqLL77IqVOnCAwMBMBisfD+++/TtGlTPD09eeONN/jiiy/w8vLK8RrPnDlDzZo1qVOnDgABAQG5vj+TJk1izpw5dOzYEYDAwECOHTvGokWL6NWrl9EuIiKCtm1vv5c/KiqKypUrc/LkSSpUqMCbb75J69atiYiIAKBcuXLs2bPHCFNubm5YLBby5cuHn59fthrCw8Pp1q0bANOmTWPevHns27eP0NDQHGtOS0szRnMAUlJScn29IiIiIiL3NWLh6+tL27ZtiYmJMUYK/vjX/B9//JFu3bpRpkwZvLy8jA/mZ86cybHP+Ph4qlevboQKgEaNGpGZmcmJEyeMbVWrVrUJFQDbtm3j6tWrtGnTBoDChQvTsmVLlixZYtOuQYMGREREMGXKFF588UUaN258x2scOHAgq1atokaNGowePZo9e/bc+8Zwe+QlISGBvn37YrFYjOWVV17J9ihYtWrVjJ+LFSsGwLlz5wA4ceIE9erVs2n/x/W7+X3fHh4eeHl5GX3nZPr06Xh7exuLv79/rs8lIiIiInLfM5X79OljPKY0f/78bPvDwsIoXbo07777LsWLFyczM5MqVapkm3CdV78PHlmio6O5ePEibm5uxrbMzEy+++47oqKicHJyMrbFxcXh7OzMyZMn73qe1q1bc/r0aT777DO2bdtG8+bNGTx4MK+++updj8uaE/Luu+9Sv359m33Ozs426/nz5zd+NplMRo1/ht/3ndX/3fqOjIxk5MiRxnpKSorChYiIiIjk2n1/j0VoaCjp6encvHmTVq1a2ey7cOECJ06cYPz48TRv3pyKFSty6dKlu/ZXsWJFDh8+zNWrV41tcXFxODk52UzS/qMLFy6wfv16Vq1axaFDh4zl4MGDXLp0ic8//9xoO3v2bI4fP87OnTvZsmXLPSdj+/r60qtXL95//33eeOMN3nnnnbu2ByhatCjFixfnp59+IigoyGbJeiwrN8qXL8/+/ftttv1x3cXFhYyMjFz3eTdmsxkvLy+bRUREREQkt+57xMLZ2Zn4+Hjj598rUKAAhQoV4p133qFYsWKcOXPGmDR9J927d2fSpEn06tWLyZMn89tvvzF06FCeffZZY35FTt577z0KFSpE586djb/6Z2nTpg3R0dGEhoZy8OBBJk6cyMcff0yjRo147bXXeOGFF2jatCllypTJ1u/EiROpXbs2lStXJi0tjY0bN1KxYkWbNqdOncr2hXrBwcFERUUxbNgwvL29CQ0NJS0tjQMHDnDp0iWbUYG7GTp0KE2aNOG1114jLCyM//znP2zevNnmGgMCAowaSpYsiaenp12v7xURERERuV92ffP2nf6y7eTkxKpVq/jmm2+oUqUKI0aMYPbs2Xfty93dna1bt3Lx4kXq1q3LU089RfPmze/41qYsS5YsoUOHDtlCBdyeQL5hwwb++9//0qNHD8LDwwkLCwPgueeeIyQkhGeffTbHv/q7uLgQGRlJtWrVaNKkCc7OzqxatcqmzciRI6lZs6bNcvDgQfr168fixYtZunQpVatWpWnTpsTExORpxKJRo0YsXLiQ1157jerVq7NlyxZGjBiBq6urzfWFhoYSEhKCr68vK1euzHX/IiIiIiJ/JpPVarU64sRpaWm4urqybds2WrRo4YgSHjr9+/fn+PHj7Nq16y8/V0pKyu1J3MNX42R2/8vPJ5IbiTPaOroEERGRR0rWZ8Lk5OR7PirvkK+ZTklJYe3atTg5OVGhQgVHlPBQePXVV2nZsiUeHh5s3ryZZcuW2XzRnoiIiIjIg8IhwWLSpEmsWLGCmTNnUrJkSUeU8FDYt28fs2bN4sqVK5QpU4Z58+bRr18/R5clIiIiIpKNwx6FkgdbXoa9REREROSfKS+fCe2avC0iIiIiIgIKFiIiIiIi8idQsBAREREREbspWIiIiIiIiN0ULERERERExG4KFiIiIiIiYjcFCxERERERsZuChYiIiIiI2E3BQkRERERE7KZgISIiIiIidlOwEBERERERuylYiIiIiIiI3RQsRERERETEbgoWIiIiIiJiNwULERERERGxm4KFiIiIiIjYLZ+jC5AHW5VJW3Eyuzu6DLlPiTPaOroEEREReURoxEJEREREROymYCEiIiIiInZTsLBTeHg47du3d3QZIiIiIiIO9UgFi/DwcEwmEyaTCRcXF4KCgnj55Ze5devWffc5d+5cYmJi/rwi76BZs2YMHz78Lz+PiIiIiMj9eOQmb4eGhrJ06VLS0tL47LPPGDx4MPnz5ycyMjJP/WRkZGAymfD29v6LKv1rpKen4+Li4ugyREREROQf5pEasQAwm834+flRunRpBg4cSIsWLdiwYQNpaWlERERQokQJPDw8qF+/PrGxscZxMTEx+Pj4sGHDBipVqoTZbObMmTPZHoVq1qwZQ4cOZfjw4RQoUICiRYvy7rvvcvXqVXr37o2npydBQUFs3rzZpq7vv/+e1q1bY7FYKFq0KM8++yznz58Hbo+07Ny5k7lz5xojLomJifc8LqueIUOGMHz4cAoXLkyrVq3+snsrIiIiIo+uRy5Y/JGbmxvp6ekMGTKEvXv3smrVKr777juefvppQkND+fHHH422165dY+bMmSxevJijR49SpEiRHPtctmwZhQsXZt++fQwdOpSBAwfy9NNP07BhQ7799lsef/xxnn32Wa5duwbA5cuXeeyxx6hZsyYHDhxgy5Yt/Prrr3Tu3Bm4/bhVgwYN6N+/P0lJSSQlJeHv73/P435fj4uLC3FxcSxcuPAvupMiIiIi8ih75B6FymK1WtmxYwdbt26lW7duLF26lDNnzlC8eHEAIiIi2LJlC0uXLmXatGkA3Lx5k7fffpvq1avfte/q1aszfvx4ACIjI5kxYwaFCxemf//+AEycOJEFCxbw3Xff8a9//Yu33nqLmjVrGucBWLJkCf7+/vzwww+UK1cOFxcX3N3d8fPzM9rk5jiA4OBgZs2addea09LSSEtLM9ZTUlLueQ9FRERERLI8csFi48aNWCwWbt68SWZmJs888wxPPfUUMTExxgfxLGlpaRQqVMhYd3FxoVq1avc8x+/bODs7U6hQIapWrWpsK1q0KADnzp0D4PDhw3zxxRdYLJZsfSUkJGSrK0tuj6tdu/Y9a54+fTpRUVH3bCciIiIikpNHLliEhISwYMECXFxcKF68OPny5ePDDz/E2dmZb775BmdnZ5v2v//Q7ubmhslkuuc58ufPb7NuMplstmX1kZmZCUBqaiphYWHMnDkzW1/FihW743lye5yHh8c9a46MjGTkyJHGekpKCv7+/vc8TkREREQEHsFg4eHhQVBQkM22mjVrkpGRwblz5/j3v//9t9dUq1Yt1qxZQ0BAAPny5fwrcXFxISMjI8/H5ZbZbMZsNtvVh4iIiIg8uh75ydsA5cqVo3v37vTs2ZO1a9dy6tQp9u3bx/Tp09m0adNffv7Bgwdz8eJFunXrxv79+0lISGDr1q307t3bCBMBAQF8/fXXJCYmcv78eTIzM3N1nIiIiIjI30HB4v9bunQpPXv25MUXX6R8+fK0b9+e/fv3U6pUqb/83MWLFycuLo6MjAwef/xxqlatyvDhw/Hx8cHJ6favKCIiAmdnZypVqoSvr68x0fxex4mIiIiI/B1MVqvV6ugi5MGTkpKCt7c3/sNX42R2d3Q5cp8SZ7R1dAkiIiLyEMv6TJicnIyXl9dd2+rP2iIiIiIiYjcFCxERERERsdsj91YoyZvvo1rdc9hLREREREQjFiIiIiIiYjcFCxERERERsZuChYiIiIiI2E3BQkRERERE7KZgISIiIiIidlOwEBERERERuylYiIiIiIiI3RQsRERERETEbgoWIiIiIiJiNwULERERERGxm4KFiIiIiIjYTcFCRERERETspmAhIiIiIiJ2U7AQERERERG7KViIiIiIiIjdFCxERERERMRu+RxdgDzYqkzaipPZ3dFlPPASZ7R1dAkiIiIiDqURCxERERERsZuChYiIiIiI2E3B4m/UrFkzhg8f7ugyRERERET+dP+4YBEeHo7JZMJkMpE/f34CAwMZPXo0N27ccHRpIiIiIiL/WP/IyduhoaEsXbqUmzdv8s0339CrVy9MJhMzZ850dGkiIiIiIv9I/7gRCwCz2Yyfnx/+/v60b9+eFi1asG3bNgDS0tIYNmwYRYoUwdXVlcaNG7N//37j2JiYGHx8fGz6W7duHSaTyVifPHkyNWrU4L333iMgIABvb2+6du3KlStXjDZXr16lZ8+eWCwWihUrxpw5c7LVGRAQwLRp0+jTpw+enp6UKlWKd955x6bN2bNn6dy5Mz4+PhQsWJB27dqRmJho7I+NjaVevXp4eHjg4+NDo0aNOH36NACHDx8mJCQET09PvLy8qF27NgcOHLjv+yoiIiIicif/yGDxe99//z179uzBxcUFgNGjR7NmzRqWLVvGt99+S1BQEK1ateLixYt56jchIYF169axceNGNm7cyM6dO5kxY4axf9SoUezcuZP169fz+eefExsby7fffputnzlz5lCnTh0OHjzIoEGDGDhwICdOnADg5s2btGrVCk9PT3bt2kVcXBwWi4XQ0FDS09O5desW7du3p2nTpnz33Xfs3buX5557zghB3bt3p2TJkuzfv59vvvmGsWPHkj9//vu9lSIiIiIid/SPfBRq48aNWCwWbt26RVpaGk5OTrz11ltcvXqVBQsWEBMTQ+vWrQF499132bZtG9HR0YwaNSrX58jMzCQmJgZPT08Ann32WXbs2MHUqVNJTU0lOjqa999/n+bNmwOwbNkySpYsma2fNm3aMGjQIADGjBnD66+/zhdffEH58uX58MMPyczMZPHixUZYWLp0KT4+PsTGxlKnTh2Sk5N54oknKFu2LAAVK1Y0+j5z5gyjRo2iQoUKAAQHB9/xetLS0khLSzPWU1JScn0vRERERET+kSMWISEhHDp0iK+//ppevXrRu3dvOnXqREJCAjdv3qRRo0ZG2/z581OvXj3i4+PzdI6AgAAjVAAUK1aMc+fOAbdHM9LT06lfv76xv2DBgpQvXz5bP9WqVTN+NplM+Pn5Gf0cPnyYkydP4unpicViwWKxULBgQW7cuEFCQgIFCxYkPDycVq1aERYWxty5c0lKSjL6GzlyJP369aNFixbMmDGDhISEO17P9OnT8fb2NhZ/f/883Q8RERERebT9I4OFh4cHQUFBVK9enSVLlvD1118THR2dq2OdnJywWq02227evJmt3R8fKTKZTGRmZua51rv1k5qaSu3atTl06JDN8sMPP/DMM88At0cw9u7dS8OGDfnwww8pV64cX331FXB7LsjRo0dp27Yt//nPf6hUqRKffPJJjnVERkaSnJxsLGfPns3ztYiIiIjIo+sfGSx+z8nJiXHjxjF+/HjKli2Li4sLcXFxxv6bN2+yf/9+KlWqBICvry9Xrlzh6tWrRptDhw7l6Zxly5Ylf/78fP3118a2S5cu8cMPP+Spn1q1avHjjz9SpEgRgoKCbBZvb2+jXc2aNYmMjGTPnj1UqVKFFStWGPvKlSvHiBEj+Pzzz+nYsSNLly7N8VxmsxkvLy+bRUREREQkt/7xwQLg6aefxtnZmQULFjBw4EBGjRrFli1bOHbsGP379+fatWv07dsXgPr16+Pu7s64ceNISEhgxYoVxMTE5Ol8FouFvn37MmrUKP7zn//w/fffEx4ejpNT3m539+7dKVy4MO3atWPXrl2cOnWK2NhYhg0bxn//+19OnTpFZGQke/fu5fTp03z++ef8+OOPVKxYkevXrzNkyBBiY2M5ffo0cXFx7N+/32YOhoiIiIjIn+UfOXn7j/Lly8eQIUOYNWsWp06dIjMzk2effZYrV65Qp04dtm7dSoECBYDbcyHef/99Ro0axbvvvkvz5s2ZPHkyzz33XJ7OOXv2bFJTUwkLC8PT05MXX3yR5OTkPPXh7u7Ol19+yZgxY+jYsSNXrlyhRIkSNG/eHC8vL65fv87x48dZtmwZFy5coFixYgwePJjnn3+eW7duceHCBXr27Mmvv/5K4cKF6dixI1FRUXmqQUREREQkN0zWP04oEOH2W6G8vb3xH74aJ7O7o8t54CXOaOvoEkRERET+dFmfCZOTk+/5qPwj8SiUiIiIiIj8tRQsRERERETEbo/EHAu5f99HtdIbokRERETknjRiISIiIiIidlOwEBERERERuylYiIiIiIiI3RQsRERERETEbgoWIiIiIiJiNwULERERERGxm4KFiIiIiIjYTcFCRERERETspmAhIiIiIiJ2U7AQERERERG7KViIiIiIiIjdFCxERERERMRuChYiIiIiImI3BQsREREREbGbgoWIiIiIiNhNwUJEREREROyWz9EFyIOtyqStOJndHV3GAytxRltHlyAiIiLyQNCIhYiIiIiI2E3BQkRERERE7KZg8Q+QmJiIyWTi0KFDji5FRERERB5RD22w2Lt3L87OzrRt+2A9436nD/mTJ0/GZDJhMplwdnbG39+f5557josXL+ap//DwcNq3b2+zzd/fn6SkJKpUqWJn9SIiIiIi9+ehDRbR0dEMHTqUL7/8kp9//tnR5eRK5cqVSUpK4syZMyxdupQtW7YwcOBAu/t1dnbGz8+PfPk0F19EREREHOOhDBapqal8+OGHDBw4kLZt2xITE2Psu3TpEt27d8fX1xc3NzeCg4NZunQp8L/RhFWrVtGwYUNcXV2pUqUKO3futOn/+++/p3Xr1lgsFooWLcqzzz7L+fPnjf2ZmZnMmjWLoKAgzGYzpUqVYurUqQAEBgYCULNmTUwmE82aNTOOy5cvH35+fpQoUYIWLVrw9NNPs23bNmN/RkYGffv2JTAwEDc3N8qXL8/cuXON/ZMnT2bZsmWsX7/eGP2IjY3NcZRk586d1KtXD7PZTLFixRg7diy3bt2y+96LiIiIiOTkoQwWq1evpkKFCpQvX54ePXqwZMkSrFYrABMmTODYsWNs3ryZ+Ph4FixYQOHChW2OHzVqFC+++CIHDx6kQYMGhIWFceHCBQAuX77MY489Rs2aNTlw4ABbtmzh119/pXPnzsbxkZGRzJgxwzjXihUrKFq0KAD79u0DYPv27SQlJbF27docryExMZGtW7fi4uJibMvMzKRkyZJ89NFHHDt2jIkTJzJu3DhWr14NQEREBJ07dyY0NJSkpCSSkpJo2LBhtr7/7//+jzZt2lC3bl0OHz7MggULiI6O5pVXXrnfWy4iIiIiclcP5bMz0dHR9OjRA4DQ0FCSk5PZuXMnzZo148yZM9SsWZM6deoAEBAQkO34IUOG0KlTJwAWLFjAli1biI6OZvTo0bz11lvUrFmTadOmGe2XLFmCv78/P/zwA8WKFWPu3Lm89dZb9OrVC4CyZcvSuHFjAHx9fQEoVKgQfn5+Nuc9cuQIFouFjIwMbty4AcBrr71m7M+fPz9RUVHGemBgIHv37mX16tV07twZi8WCm5sbaWlp2fr+vbfffht/f3/eeustTCYTFSpU4Oeff2bMmDFMnDgRJ6fseTItLY20tDRjPSUl5Y79i4iIiIj80UMXLE6cOMG+ffv45JNPgNuPF3Xp0oXo6GiaNWvGwIED6dSpE99++y2PP/447du3z/ZX/QYNGhg/58uXjzp16hAfHw/A4cOH+eKLL7BYLNnOnZCQwOXLl0lLS6N58+Z5rr18+fJs2LCBGzdu8P7773Po0CGGDh1q02b+/PksWbKEM2fOcP36ddLT06lRo0aezhMfH0+DBg0wmUzGtkaNGpGamsp///tfSpUqle2Y6dOn24QaEREREZG8eOgehYqOjubWrVsUL16cfPnykS9fPhYsWMCaNWtITk6mdevWnD59mhEjRvDzzz/TvHlzIiIict1/amoqYWFhHDp0yGb58ccfadKkCW5ubvddu4uLC0FBQVSpUoUZM2bg7Oxs82F+1apVRERE0LdvXz7//HMOHTpE7969SU9Pv+9z5lZkZCTJycnGcvbs2b/8nCIiIiLyz/FQBYtbt26xfPly5syZY/Oh//DhwxQvXpyVK1cCtx9H6tWrF++//z5vvPEG77zzjk0/X331lU2f33zzDRUrVgSgVq1aHD16lICAAIKCgmwWDw8PgoODcXNzY8eOHTnWmDVnIiMj457XM378eF599VXjrVZxcXE0bNiQQYMGUbNmTYKCgkhISMjW/736rlixInv37jXmnWT17enpScmSJXM8xmw24+XlZbOIiIiIiOTWQxUsNm7cyKVLl+jbty9VqlSxWTp16kR0dDQTJ05k/fr1nDx5kqNHj7Jx40YjNGSZP38+n3zyCcePH2fw4MFcunSJPn36ADB48GAuXrxIt27d2L9/PwkJCWzdupXevXuTkZGBq6srY8aMYfTo0SxfvpyEhAS++uoroqOjAShSpAhubm7GpO/k5OQ7Xk+DBg2oVq2aMZ8jODiYAwcOsHXrVn744QcmTJjA/v37bY4JCAjgu+++48SJE5w/f56bN29m63fQoEGcPXuWoUOHcvz4cdavX8+kSZMYOXJkjvMrRERERETs9VB9yoyOjqZFixZ4e3tn29epUycOHDhAvnz5iIyMpFq1ajRp0gRnZ2dWrVpl03bGjBnMmDGD6tWrs3v3bjZs2GC8Oap48eLExcWRkZHB448/TtWqVRk+fDg+Pj7Gh/IJEybw4osvMnHiRCpWrEiXLl04d+4ccHvOxrx581i0aBHFixenXbt2d72mESNGsHjxYs6ePcvzzz9Px44d6dKlC/Xr1+fChQsMGjTIpn3//v0pX748derUwdfXl7i4uGx9lihRgs8++4x9+/ZRvXp1BgwYQN++fRk/fnzub7aIiIiISB6YrL9/XuYfLjExkcDAQA4ePJjnCdGPmpSUFLy9vfEfvhons7ujy3lgJc54sL75XUREROTPlPWZMDk5+Z6Pyj9UIxYiIiIiIvJgUrAQERERERG7PVKPQknu5WXYS0RERET+mfQolIiIiIiI/K0ULERERERExG4KFiIiIiIiYjcFCxERERERsZuChYiIiIiI2E3BQkRERERE7KZgISIiIiIidlOwEBERERERuylYiIiIiIiI3RQsRERERETEbgoWIiIiIiJiNwULERERERGxm4KFiIiIiIjYTcFCRERERETspmAhIiIiIiJ2U7AQERERERG75XN0AfJgqzJpK05md0eX4RCJM9o6ugQRERGRh4ZGLERERERExG4KFiIiIiIiYjcFCweLjY3FZDJx+fLlXLVv1qwZw4cP/0trEhERERHJq4cyWISHh2MymbItoaGhji4NgMmTJ1OjRo1ctW3YsCFJSUl4e3vnqv3atWuZMmWKsR4QEMAbb7xxH1WKiIiIiPx5HtrJ26GhoSxdutRmm9lsdlA19+fmzZu4uLjg5+eX62MKFiz4F1YkIiIiInJ/HsoRC7gdIvz8/GyWAgUKAHD58mWef/55ihYtiqurK1WqVGHjxo3GsXFxcTRr1gx3d3cKFChAq1atuHTpEgCZmZlMnz6dwMBA3NzcqF69Oh9//LFxbNajSzt27KBOnTq4u7vTsGFDTpw4AUBMTAxRUVEcPnzYGEmJiYkBwGQysWDBAp588kk8PDyYOnVqjo9C3a2+3z8K1axZM06fPs2IESOMc129ehUvLy+bmgHWrVuHh4cHV65c+VN/DyIiIiIi8BAHizvJzMykdevWxMXF8f7773Ps2DFmzJiBs7MzAIcOHaJ58+ZUqlSJvXv3snv3bsLCwsjIyABg+vTpLF++nIULF3L06FFGjBhBjx492Llzp815XnrpJebMmcOBAwfIly8fffr0AaBLly68+OKLVK5cmaSkJJKSkujSpYtx3OTJk+nQoQNHjhwxjvm9e9X3e2vXrqVkyZK8/PLLxrk8PDzo2rVrttGcpUuX8tRTT+Hp6WnfDRYRERERycFD+yjUxo0bsVgsNtvGjRtHnTp12LdvH/Hx8ZQrVw6AMmXKGG1mzZpFnTp1ePvtt41tlStXBiAtLY1p06axfft2GjRoYBy7e/duFi1aRNOmTY1jpk6daqyPHTuWtm3bcuPGDdzc3LBYLOTLly/HR5yeeeYZevfubaz/9NNPNvvvVt8fFSxYEGdnZzw9PW3O1a9fP2PuRrFixTh37hyfffYZ27dvz7GfrGtPS0sz1lNSUu7YVkRERETkjx7aEYuQkBAOHTpkswwYMIBDhw5RsmRJI1T8UdaIQE5OnjzJtWvXaNmyJRaLxViWL19OQkKCTdtq1aoZPxcrVgyAc+fO3bPuOnXq3HX/3erLrXr16lG5cmWWLVsGwPvvv0/p0qVp0qTJHY+ZPn063t7exuLv729XDSIiIiLyaHloRyw8PDwICgrKtt3Nze2ux91tf2pqKgCbNm2iRIkSNvv+ODE8f/78xs8mkwm4/RjWvXh4eNx3fXnRr18/5s+fz9ixY1m6dCm9e/c26sxJZGQkI0eONNZTUlIULkREREQk1x7aEYs7qVatGv/973/54Ycf7rh/x44dOe6rVKkSZrOZM2fOEBQUZLPk5UO2i4tLjnMiclv/nerLy7l69OjB6dOnmTdvHseOHaNXr1537cdsNuPl5WWziIiIiIjk1kM7YpGWlsYvv/xisy1fvnw0bdqUJk2a0KlTJ1577TWCgoI4fvy48T0XkZGRVK1alUGDBjFgwABcXFz44osvePrppylcuDARERGMGDGCzMxMGjduTHJyMnFxcXh5ed3zw3mWgIAATp06ZTyW5enpmetX4d6rvpzO9eWXX9K1a1fMZrPRpkCBAnTs2JFRo0bx+OOPU7JkyVydX0RERETkfjy0IxZbtmyhWLFiNkvjxo0BWLNmDXXr1qVbt25UqlSJ0aNHG3/VL1euHJ9//jmHDx+mXr16NGjQgPXr15Mv3+2MNWXKFCZMmMD06dOpWLEioaGhbNq0icDAwFzX1qlTJ0JDQwkJCcHX15eVK1fm+th71fdHL7/8MomJiZQtWxZfX1+bfX379iU9PT3Ht0+JiIiIiPyZTFar1eroIuSv8d577zFixAh+/vlnXFxc8nRsSkrK7Uncw1fjZHb/iyp8sCXOaOvoEkREREQcKuszYXJy8j0flX9oH4WSO7t27RpJSUnMmDGD559/Ps+hQkREREQkrx7aR6HkzmbNmkWFChXw8/MjMjLS0eWIiIiIyCNAj0JJjvIy7CUiIiIi/0x5+UyoEQsREREREbGbgoWIiIiIiNhNwUJEREREROymYCEiIiIiInZTsBAREREREbspWIiIiIiIiN0ULERERERExG4KFiIiIiIiYjcFCxERERERsZuChYiIiIiI2E3BQkRERERE7KZgISIiIiIidlOwEBERERERuylYiIiIiIiI3RQsRERERETEbgoWIiIiIiJit3yOLkAebFUmbcXJ7O7oMv4yiTPaOroEERERkX8EjViIiIiIiIjdFCxERERERMRuD3ywMJlMrFu3ztFliIiIiIjIXTg8WPz2228MHDiQUqVKYTab8fPzo1WrVsTFxTm6NBuJiYmYTKZsS48ePezuOzY2FpPJxOXLl+0vFFi7di0tW7bE19cXLy8vGjRowNatW/+UvkVEREREcuLwydudOnUiPT2dZcuWUaZMGX799Vd27NjBhQsXHF1ajrZv307lypWNdTc3NwdWY8tqtZKRkcGXX35Jy5YtmTZtGj4+PixdupSwsDC+/vpratas6egyRUREROQfyKEjFpcvX2bXrl3MnDmTkJAQSpcuTb169YiMjOTJJ5802p0/f54OHTrg7u5OcHAwGzZsMPZlZGTQt29fAgMDcXNzo3z58sydO9fmPOHh4bRv356oqCjjr/gDBgwgPT3daJOZmcn06dONfqpXr87HH3+creZChQrh5+dnLN7e3iQkJNCuXTuKFi2KxWKhbt26bN++3ea4tLQ0xowZg7+/P2azmaCgIKKjo0lMTCQkJASAAgUKYDKZCA8PN44ZNmwYRYoUwdXVlcaNG7N//36jz6yRjs2bN1O7dm3MZjO7d+/mjTfeYPTo0dStW5fg4GCmTZtGcHAwn3766f3/skRERERE7sKhwcJisWCxWFi3bh1paWl3bBcVFUXnzp357rvvaNOmDd27d+fixYvA7UBQsmRJPvroI44dO8bEiRMZN24cq1evtuljx44dxMfHExsby8qVK1m7di1RUVHG/unTp7N8+XIWLlzI0aNHGTFiBD169GDnzp33vI7U1FTatGnDjh07OHjwIKGhoYSFhXHmzBmjTc+ePVm5ciXz5s0jPj6eRYsWYbFY8Pf3Z82aNQCcOHGCpKQkIxiNHj2aNWvWsGzZMr799luCgoJo1aqVce1Zxo4dy4wZM4iPj6datWrZ6svMzOTKlSsULFjwntciIiIiInI/TFar1erIAtasWUP//v25fv06tWrVomnTpnTt2tX4gGwymRg/fjxTpkwB4OrVq1gsFjZv3kxoaGiOfQ4ZMoRffvnFGHEIDw/n008/5ezZs7i73/5OhoULFzJq1CiSk5O5efMmBQsWZPv27TRo0MDop1+/fly7do0VK1aQmJhojGY4Of0vj+3atSvHx4uqVKnCgAEDGDJkCD/88APly5dn27ZttGjRIlvb2NhYQkJCuHTpEj4+PsZ1FihQgJiYGJ555hkAbt68SUBAAMOHD2fUqFHGcevWraNdu3Z3vMezZs1ixowZHD9+nCJFiuTYJi0tzSbcpaSk4O/vj//w1foeCxEREZFHVEpKCt7e3iQnJ+Pl5XXXtg/EHIu2bduya9cuvvrqKzZv3sysWbNYvHix8UjQ7/8K7+HhgZeXF+fOnTO2zZ8/nyVLlnDmzBmuX79Oeno6NWrUsDlP9erVjVAB0KBBA1JTUzl79iypqalcu3aNli1b2hyTnp6eLTR8+OGHVKxY0Vj39/cnNTWVyZMns2nTJpKSkrh16xbXr183RiwOHTqEs7MzTZs2zfV9SUhI4ObNmzRq1MjYlj9/furVq0d8fLxN2zp16tyxnxUrVhAVFcX69evvGCrg9ojN70dwRERERETywuHBAsDV1ZWWLVvSsmVLJkyYQL9+/Zg0aZIRLPLnz2/T3mQykZmZCcCqVauIiIhgzpw5NGjQAE9PT2bPns3XX3+d6/OnpqYCsGnTJkqUKGGzz2w226z7+/sTFBRks+2FF15g27ZtvPrqqwQFBeHm5sZTTz1lzOH4qyd4e3h45Lh91apV9OvXj48++ijHkZLfi4yMZOTIkcZ61oiFiIiIiEhuPBDB4o8qVaqU6++uiIuLo2HDhgwaNMjYlpCQkK3d4cOHuX79uvEh/6uvvjLmOBQsWBCz2cyZM2fyNKrw+xrCw8Pp0KEDcDuoJCYmGvurVq1KZmYmO3fuzPEDvouLC3B7InqWsmXL4uLiQlxcHKVLlwZuPwq1f/9+hg8ffs+aVq5cSZ8+fVi1ahVt2977cR+z2ZwtRImIiIiI5JZDg8WFCxd4+umn6dOnD9WqVcPT05MDBw4wa9asu84Z+L3g4GCWL1/O1q1bCQwM5L333mP//v0EBgbatEtPT6dv376MHz+exMREJk2axJAhQ3BycsLT05OIiAhGjBhBZmYmjRs3Jjk5mbi4OLy8vOjVq9c9a1i7di1hYWGYTCYmTJhgjKgABAQE0KtXL/r06cO8efOoXr06p0+f5ty5c3Tu3JnSpUtjMpnYuHEjbdq0wc3NDYvFwsCBAxk1ahQFCxakVKlSzJo1i2vXrtG3b9+71rNixQp69erF3LlzqV+/Pr/88gtwe+TE29s7V/dVRERERCQvHBosLBYL9evX5/XXXzfmFPj7+9O/f3/GjRuXqz6ef/55Dh48SJcuXTCZTHTr1o1BgwaxefNmm3bNmzcnODiYJk2akJaWRrdu3Zg8ebKxf8qUKfj6+jJ9+nR++uknfHx8qFWrVq7qeO211+jTpw8NGzakcOHCjBkzhpSUFJs2CxYsYNy4cQwaNIgLFy5QqlQpo+8SJUoQFRXF2LFj6d27Nz179iQmJoYZM2aQmZnJs88+y5UrV6hTpw5bt26lQIECd63nnXfe4datWwwePJjBgwcb23v16kVMTMw9r0dEREREJK8c/laov0N4eDiXL1/O9eNV8r83AOitUCIiIiKPrry8Fcqh32MhIiIiIiL/DAoWIiIiIiJit0fiUSjJu7wMe4mIiIjIP5MehRIRERERkb+VgoWIiIiIiNhNwUJEREREROymYCEiIiIiInZTsBAREREREbspWIiIiIiIiN0ULERERERExG4KFiIiIiIiYjcFCxERERERsZuChYiIiIiI2E3BQkRERERE7KZgISIiIiIidlOwEBERERERuylYiIiIiIiI3RQsRERERETEbgoWIiIiIiJit3yOLkAebFUmbcXJ7O7oMrJJnNHW0SWIiIiIyO9oxEJEREREROymYCEiIiIiInZ74IOFyWRi3bp1ji5DRERERETuwuHB4rfffmPgwIGUKlUKs9mMn58frVq1Ii4uztGl2UhMTMRkMmVbevToYXffsbGxmEwmLl++bH+hfxAXF0e+fPmoUaPGn963iIiIiEgWh0/e7tSpE+np6SxbtowyZcrw66+/smPHDi5cuODo0nK0fft2KleubKy7ubk5sBpbVquVjIwM8uW7/Wu9fPkyPXv2pHnz5vz6668Ork5ERERE/skcOmJx+fJldu3axcyZMwkJCaF06dLUq1ePyMhInnzySaPd+fPn6dChA+7u7gQHB7NhwwZjX0ZGBn379iUwMBA3NzfKly/P3Llzbc4THh5O+/btiYqKwtfXFy8vLwYMGEB6errRJjMzk+nTpxv9VK9enY8//jhbzYUKFcLPz89YvL29SUhIoF27dhQtWhSLxULdunXZvn27zXFpaWmMGTMGf39/zGYzQUFBREdHk5iYSEhICAAFChTAZDIRHh5uHDNs2DCKFCmCq6srjRs3Zv/+/UafWSMdmzdvpnbt2pjNZnbv3m3sHzBgAM888wwNGjS4j9+OiIiIiEjuOTRYWCwWLBYL69atIy0t7Y7toqKi6Ny5M9999x1t2rShe/fuXLx4EbgdCEqWLMlHH33EsWPHmDhxIuPGjWP16tU2fezYsYP4+HhiY2NZuXIla9euJSoq6v+1d+dRVZXrH8C/B4QjAgdEVKCYVDQNMMAr4YQDJmqK5k1FE3DAUknRJNMl4XBvmENm1zIzBZqcroWVVw1BXISIoKCihEgi/oohmVEDgff3h8tdRxDBcw6T389aZ3n2u5/97nc/vLDO4x6OtD40NBRffPEFPv30U1y+fBlLly7Fa6+9hlOnTj32OCoqKjBu3DhER0cjJSUFnp6emDBhAnJycqQYHx8f7N27Fx999BHS09Oxc+dOGBgYwNLSEocOHQIAZGRkIDc3VyqM3n77bRw6dAgRERE4f/48evXqhTFjxkjH/sA777yDDRs2ID09HY6OjgCAsLAw/PrrrwgJCXns+ImIiIiIVCUTQoiWHMChQ4fg7++Pu3fvwtnZGe7u7pg+fbr0AVkmk2H16tVYv349AOD27dswMDDA0aNH4enpWW+fAQEByMvLk844+Pn54YcffsDNmzfRqdP972T49NNPERQUhNLSUty7dw8mJiY4ceKE0v/uz5s3D3fu3ME333yD7Oxs6WyGltZf9VhcXBycnJzqjMHe3h5vvPEGAgICcPXqVfTp0wdRUVHw8PCoExsbG4sRI0aguLgYxsbG0nF27twZ4eHhmDFjBgDg3r17sLGxQWBgIIKCgqTtIiMj4eXlJfWXmZmJIUOGIC4uDr1798aaNWsQGRmJ1NTUR/4cKisrlYq7srIyWFpawjLwAL/HgoiIiOgpVVZWBiMjI5SWlkKhUDQY2yrusRg/fjzi4uJw5swZHD16FBs3bsTnn38uXRL0oMgAAH19fSgUChQUFEhtH3/8Mfbs2YOcnBzcvXsXVVVVdW5W7t+/v1RUAICbmxsqKipw8+ZNVFRU4M6dOxg9erTSNlVVVXWKhv3796Nv377SsqWlJSoqKrBmzRocOXIEubm5qK6uxt27d6UzFqmpqdDW1oa7u3uj85KVlYV79+5h8ODBUpuOjg4GDhyI9PR0pdgBAwZI72tqajBjxgysXbsWvXv3bvT+QkNDlc7gEBERERE1RYsXFgDQsWNHjB49GqNHj0ZwcDDmzZuHkJAQqbDQ0dFRipfJZKitrQUA7Nu3D8uXL8eWLVvg5uYGQ0NDbNq0CYmJiY3ef0VFBQDgyJEjeOaZZ5TWyeVypWVLS0v06tVLqW3JkiWIiorC5s2b0atXL+jp6eGf//yndA+Hpm/w1tfXl96Xl5cjOTkZKSkpCAgIAHD/cjEhBDp06ICffvoJI0eOrNPHypUrsWzZMmn5wRkLIiIiIqLGaBWFxcP69evX6O+uiI+Px6BBg7Bw4UKpLSsrq07chQsXcPfuXelD/pkzZ6R7HExMTCCXy5GTk9Okswp/H4Ofnx8mT54M4H6hkp2dLa13cHBAbW0tTp06Ve+lULq6ugDun214oGfPntDV1UV8fDysra0B3L8UKikpCYGBgY8ci0KhwKVLl5TaPvnkE8TExOC///0vbG1t691OLpfXKaKIiIiIiBqrRQuLwsJCvPrqq5gzZw4cHR1haGiI5ORkbNy4UemegYbY2dnhiy++wPHjx2Fra4svv/wSSUlJdT5AV1VVYe7cuVi9ejWys7MREhKCgIAAaGlpwdDQEMuXL8fSpUtRW1uLIUOGoLS0FPHx8VAoFPD19X3sGL799ltMmDABMpkMwcHB0hkVALCxsYGvry/mzJmDjz76CP3798eNGzdQUFCAqVOnwtraGjKZDD/++CPGjRsHPT09GBgYYMGCBQgKCoKJiQmsrKywceNG3LlzB3Pnzn3kWLS0tGBvb6/U9uCpUg+3ExERERGpS4sWFgYGBnB1dcXWrVulewosLS3h7++PVatWNaqP119/HSkpKZg2bRpkMhm8vb2xcOFCHD16VClu1KhRsLOzw7Bhw1BZWQlvb2+sWbNGWr9+/Xp07doVoaGh+PXXX2FsbAxnZ+dGjeODDz7AnDlzMGjQIJiammLFihUoKytTitmxYwdWrVqFhQsXorCwEFZWVlLfzzzzDNauXYt33nkHs2fPho+PD8LDw7FhwwbU1tZi1qxZKC8vx4ABA3D8+HF07ty5UbkhIiIiImouLf5UqObg5+eHkpKSRl9eRX89AYBPhSIiIiJ6ejXlqVAt+j0WRERERETUPrCwICIiIiIilT0Vl0JR0zXltBcRERERtU+8FIqIiIiIiJoVCwsiIiIiIlIZCwsiIiIiIlIZCwsiIiIiIlIZCwsiIiIiIlIZCwsiIiIiIlIZCwsiIiIiIlIZCwsiIiIiIlIZCwsiIiIiIlIZCwsiIiIiIlIZCwsiIiIiIlIZCwsiIiIiIlIZCwsiIiIiIlIZCwsiIiIiIlIZCwsiIiIiIlIZCwsiIiIiIlJZh5YeALVu9iHHoSXv1CL7zt4wvkX2S0RERERNxzMWRERERESkMhYWRERERESkMhYWzWzNmjV44YUXpGU/Pz9MmjSpwW2GDx+OwMBAadnGxgYffvihRsZHRERERPQkWFg00R9//IEFCxbAysoKcrkcZmZmGDNmDOLj45+ov23btiE8PLxJ2yQlJWH+/PnSskwmQ2Rk5BPtn4iIiIhIHXjzdhNNmTIFVVVViIiIQI8ePZCfn4/o6GgUFhY+UX9GRkZN3qZr165PtC8iIiIiIk3hGYsmKCkpQVxcHN5//32MGDEC1tbWGDhwIFauXImJEycCAHJycuDl5QUDAwMoFApMnToV+fn5j+zz4Uuhbt++DR8fHxgYGMDc3Bxbtmyps83fL4WysbEBAEyePBkymQw2NjbIzs6GlpYWkpOTlbb78MMPYW1tjdraWtUSQURERET0EBYWTWBgYAADAwNERkaisrKyzvra2lp4eXmhqKgIp06dQlRUFH799VdMmzat0fsICgrCqVOncPjwYfz000+IjY3F+fPnHxmflJQEAAgLC0Nubi6SkpJgY2MDDw8PhIWFKcWGhYXBz88PWlr8sRMRERGRevETZhN06NAB4eHhiIiIgLGxMQYPHoxVq1bh4sWLAIDo6GhcunQJ33zzDVxcXODq6oovvvgCp06dkgqAhlRUVGD37t3YvHkzRo0aBQcHB0RERKC6uvqR2zy4LMrY2BhmZmbS8rx587B3716pADp//jwuXbqE2bNn19tPZWUlysrKlF5ERERERI3FwqKJpkyZgt9//x3ff/89PD09ERsbC2dnZ4SHhyM9PR2WlpawtLSU4vv16wdjY2Okp6c/tu+srCxUVVXB1dVVajMxMUGfPn2aPM5JkyZBW1sb3333HQAgPDwcI0aMkC6delhoaCiMjIyk19+PgYiIiIjocVhYPIGOHTti9OjRCA4OxunTp+Hn54eQkJCWHpYSXV1d+Pj4ICwsDFVVVfjmm28wZ86cR8avXLkSpaWl0uvmzZvNOFoiIiIiautYWKhBv379cPv2bfTt2xc3b95U+lB+5coVlJSUoF+/fo/tp2fPntDR0UFiYqLUVlxcjKtXrza4nY6ODmpqauq0z5s3DydOnMAnn3yC6upqvPLKK4/sQy6XQ6FQKL2IiIiIiBqLhUUTFBYWYuTIkfjqq69w8eJFXL9+HQcPHsTGjRvh5eUFDw8PODg4YObMmTh//jzOnj0LHx8fuLu7Y8CAAY/t38DAAHPnzkVQUBBiYmKQlpbWqJutbWxsEB0djby8PBQXF0vtffv2xYsvvogVK1bA29sbenp6KueAiIiIiKg+LCyawMDAAK6urti6dSuGDRsGe3t7BAcHw9/fH9u3b4dMJsPhw4fRuXNnDBs2DB4eHujRowf279/f6H1s2rQJQ4cOxYQJE+Dh4YEhQ4bAxcWlwW22bNmCqKgoWFpawsnJSWnd3LlzUVVV1eBlUEREREREqpIJIURLD4I0Z/369Th48KD05KrGKisru38Td+ABaMk7aWh0DcveML5F9ktERERE9z34TFhaWvrYS+V5xqKdqqioQFpaGrZv344333yzpYdDRERERO0cC4t2KiAgAC4uLhg+fDgvgyIiIiIijeOlUFSvppz2IiIiIqL2iZdCERERERFRs2JhQUREREREKmNhQUREREREKmNhQUREREREKmNhQUREREREKmNhQUREREREKmNhQUREREREKmNhQUREREREKmNhQUREREREKmNhQUREREREKmNhQUREREREKmNhQUREREREKmNhQUREREREKmNhQUREREREKmNhQUREREREKmNhQUREREREKuvQ0gOg1s0+5Di05J1U7id7w3g1jIaIiIiIWiuesSAiIiIiIpWxsCAiIiIiIpWxsCAiIiIiIpWxsFATPz8/yGSyOi9PT89GbT98+HAEBgZqZGwymQyRkZEa6ZuIiIiICODN22rl6emJsLAwpTa5XN5CoyEiIiIiaj48Y6FGcrkcZmZmSq/OnTsjNjYWurq6iIuLk2I3btyIbt26IT8/H35+fjh16hS2bdsmnenIzs4GAKSlpWHs2LEwMDBA9+7dMWvWLNy6dUvqZ/jw4Vi8eDHefvttmJiYwMzMDGvWrJHW29jYAAAmT54MmUwmLRMRERERqRMLi2bw4DKnWbNmobS0FCkpKQgODsbnn3+O7t27Y9u2bXBzc4O/vz9yc3ORm5sLS0tLlJSUYOTIkXByckJycjKOHTuG/Px8TJ06Van/iIgI6OvrIzExERs3bsS6desQFRUFAEhKSgIAhIWFITc3V1omIiIiIlInXgqlRj/++CMMDAyU2latWoVVq1bhX//6F6KiojB//nykpaXB19cXEydOBAAYGRlBV1cXnTp1gpmZmbTt9u3b4eTkhPfee09q27NnDywtLXH16lX07t0bAODo6IiQkBAAgJ2dHbZv347o6GiMHj0aXbt2BQAYGxsr9f2wyspKVFZWSstlZWUqZoOIiIiIniYsLNRoxIgR2LFjh1KbiYkJAEBXVxdff/01HB0dYW1tja1btz62vwsXLuDkyZN1ihUAyMrKUios/s7c3BwFBQVNGntoaCjWrl3bpG2IiIiIiB5gYaFG+vr66NWr1yPXnz59GgBQVFSEoqIi6OvrN9hfRUUFJkyYgPfff7/OOnNzc+m9jo6O0jqZTIba2tqmDB0rV67EsmXLpOWysjJYWlo2qQ8iIiIienqxsGgmWVlZWLp0KXbt2oX9+/fD19cXJ06cgJbW/dtcdHV1UVNTo7SNs7MzDh06BBsbG3To8OQ/Kh0dnTp9P0wul/MJVkRERET0xHjzthpVVlYiLy9P6XXr1i3U1NTgtddew5gxYzB79myEhYXh4sWL2LJli7StjY0NEhMTkZ2djVu3bqG2thaLFi1CUVERvL29kZSUhKysLBw/fhyzZ89+bKHwdzY2NoiOjkZeXh6Ki4s1cehERERE9JRjYaFGx44dg7m5udJryJAh+Pe//40bN25g586dAO5fxvTZZ59h9erVuHDhAgBg+fLl0NbWRr9+/dC1a1fk5OTAwsIC8fHxqKmpwUsvvQQHBwcEBgbC2NhYOtPRGFu2bEFUVBQsLS3h5OSkkWMnIiIioqebTAghWnoQ1PqUlZXByMgIloEHoCXvpHJ/2RvGq2FURERERNScHnwmLC0thUKhaDCWZyyIiIiIiEhlLCyIiIiIiEhlfCoUNSht7ZjHnvYiIiIiIuIZCyIiIiIiUhkLCyIiIiIiUhkLCyIiIiIiUhkLCyIiIiIiUhkLCyIiIiIiUhkLCyIiIiIiUhkLCyIiIiIiUhm/x4LqJYQAcP9r3ImIiIjo6fTgs+CDz4YNYWFB9SosLAQAWFpatvBIiIiIiKillZeXw8jIqMEYFhZULxMTEwBATk7OYycRNU5ZWRksLS1x8+ZNfpu5mjCnmsG8qh9zqn7Mqfoxp+rXHnIqhEB5eTksLCweG8vCguqlpXX/9hsjI6M2+4vQWikUCuZUzZhTzWBe1Y85VT/mVP2YU/Vr6zlt7H8y8+ZtIiIiIiJSGQsLIiIiIiJSGQsLqpdcLkdISAjkcnlLD6XdYE7VjznVDOZV/ZhT9WNO1Y85Vb+nLacy0ZhnRxERERERETWAZyyIiIiIiEhlLCyIiIiIiEhlLCyIiIiIiEhlLCzaqY8//hg2Njbo2LEjXF1dcfbs2QbjDx48iOeeew4dO3aEg4MD/ve//ymtF0Lg3Xffhbm5OfT09ODh4YHMzEylmKKiIsycORMKhQLGxsaYO3cuKioq1H5sLUmdeb137x5WrFgBBwcH6Ovrw8LCAj4+Pvj999+V+rCxsYFMJlN6bdiwQSPH1xLUPVf9/Pzq5MvT01Mppr3PVXXn9OF8Pnht2rRJiuE8/cvly5cxZcoUKScffvjhE/X5559/YtGiRejSpQsMDAwwZcoU5Ofnq/OwWpS6cxoaGop//OMfMDQ0RLdu3TBp0iRkZGQoxQwfPrzOPH3jjTfUfWgtRt05XbNmTZ18Pffcc0oxnKd/aUxO6/tbKZPJsGjRIimmTc9TQe3Ovn37hK6urtizZ4+4fPmy8Pf3F8bGxiI/P7/e+Pj4eKGtrS02btworly5IlavXi10dHTEpUuXpJgNGzYIIyMjERkZKS5cuCAmTpwobG1txd27d6UYT09P0b9/f3HmzBkRFxcnevXqJby9vTV+vM1F3XktKSkRHh4eYv/+/eKXX34RCQkJYuDAgcLFxUWpH2tra7Fu3TqRm5srvSoqKjR+vM1BE3PV19dXeHp6KuWrqKhIqZ/2PFc1kdO/5zI3N1fs2bNHyGQykZWVJcVwnv7l7NmzYvny5WLv3r3CzMxMbN269Yn6fOONN4SlpaWIjo4WycnJ4sUXXxSDBg3S1GE2K03kdMyYMSIsLEykpaWJ1NRUMW7cOGFlZaU0D93d3YW/v7/SPC0tLdXUYTYrTeQ0JCREPP/880r5+uOPP5RiOE//0picFhQUKOUzKipKABAnT56UYtryPGVh0Q4NHDhQLFq0SFquqakRFhYWIjQ0tN74qVOnivHjxyu1ubq6itdff10IIURtba0wMzMTmzZtktaXlJQIuVwu9u7dK4QQ4sqVKwKASEpKkmKOHj0qZDKZ+O2339R2bC1J3Xmtz9mzZwUAcePGDanN2tq63j9O7YEmcurr6yu8vLweuc/2PlebY556eXmJkSNHKrVxntbvUXl5XJ8lJSVCR0dHHDx4UIpJT08XAERCQoIKR9M6aCKnDysoKBAAxKlTp6Q2d3d3sWTJkicZcquniZyGhISI/v37P3I7ztNHa+w8XbJkiejZs6eora2V2tryPOWlUO1MVVUVzp07Bw8PD6lNS0sLHh4eSEhIqHebhIQEpXgAGDNmjBR//fp15OXlKcUYGRnB1dVViklISICxsTEGDBggxXh4eEBLSwuJiYlqO76Woom81qe0tBQymQzGxsZK7Rs2bECXLl3g5OSETZs2obq6+skPppXQZE5jY2PRrVs39OnTBwsWLEBhYaFSH+11rjbHPM3Pz8eRI0cwd+7cOus4T9XX57lz53Dv3j2lmOeeew5WVlZPvN/WQhM5rU9paSkAwMTERKn966+/hqmpKezt7bFy5UrcuXNHbftsKZrMaWZmJiwsLNCjRw/MnDkTOTk50jrOU9X38dVXX2HOnDmQyWRK69rqPO3Q0gMg9bp16xZqamrQvXt3pfbu3bvjl19+qXebvLy8euPz8vKk9Q/aGorp1q2b0voOHTrAxMREimnLNJHXh/35559YsWIFvL29oVAopPbFixfD2dkZJiYmOH36NFauXInc3Fx88MEHKh5Vy9JUTj09PfHKK6/A1tYWWVlZWLVqFcaOHYuEhARoa2u367naHPM0IiIChoaGeOWVV5TaOU/V22deXh50dXXr/CdDQz+btkITOX1YbW0tAgMDMXjwYNjb20vtM2bMgLW1NSwsLHDx4kWsWLECGRkZ+Pbbb9Wy35aiqZy6uroiPDwcffr0QW5uLtauXYuhQ4ciLS0NhoaGnKcqioyMRElJCfz8/JTa2/I8ZWFB1Arcu3cPU6dOhRACO3bsUFq3bNky6b2joyN0dXXx+uuvIzQ09Kn5Js+mmD59uvTewcEBjo6O6NmzJ2JjYzFq1KgWHFn7sGfPHsycORMdO3ZUauc8pdZk0aJFSEtLw88//6zUPn/+fOm9g4MDzM3NMWrUKGRlZaFnz57NPcxWb+zYsdJ7R0dHuLq6wtraGgcOHKj3rCU1ze7duzF27FhYWFgotbflecpLodoZU1NTaGtr13kiQ35+PszMzOrdxszMrMH4B/8+LqagoEBpfXV1NYqKih6537ZEE3l94EFRcePGDURFRSmdraiPq6srqqurkZ2d3fQDaUU0mdO/69GjB0xNTXHt2jWpj/Y6VzWd07i4OGRkZGDevHmPHcvTPE/V0aeZmRmqqqpQUlKitv22FprI6d8FBATgxx9/xMmTJ/Hss882GOvq6goA0t+HtkrTOX3A2NgYvXv3Vvp7ynn6ZG7cuIETJ040+u8p0DbmKQuLdkZXVxcuLi6Ijo6W2mpraxEdHQ03N7d6t3Fzc1OKB4CoqCgp3tbWFmZmZkoxZWVlSExMlGLc3NxQUlKCc+fOSTExMTGora2VfiHaMk3kFfirqMjMzMSJEyfQpUuXx44lNTUVWlpadS7naWs0ldOH/d///R8KCwthbm4u9dFe56qmc7p79264uLigf//+jx3L0zxP1dGni4sLdHR0lGIyMjKQk5PzxPttLTSRU+D+Y9EDAgLw3XffISYmBra2to/dJjU1FQCkvw9tlaZy+rCKigpkZWVJ+eI8fXJhYWHo1q0bxo8f/9jYNjVPW/rucVK/ffv2CblcLsLDw8WVK1fE/PnzhbGxscjLyxNCCDFr1izxzjvvSPHx8fGiQ4cOYvPmzSI9PV2EhITU+7hZY2NjcfjwYXHx4kXh5eVV7+NmnZycRGJiovj555+FnZ1du3mEpxDqz2tVVZWYOHGiePbZZ0VqaqrSY+UqKyuFEEKcPn1abN26VaSmpoqsrCzx1Vdfia5duwofH5/mT4AGqDun5eXlYvny5SIhIUFcv35dnDhxQjg7Ows7Ozvx559/Sv2057mqid9/IYQoLS0VnTp1Ejt27KizT85T5ZxWVlaKlJQUkZKSIszNzcXy5ctFSkqKyMzMbHSfQtx/jKeVlZWIiYkRycnJws3NTbi5uTXfgWuQJnK6YMECYWRkJGJjY5X+nt65c0cIIcS1a9fEunXrRHJysrh+/bo4fPiw6NGjhxg2bFjzHryGaCKnb731loiNjRXXr18X8fHxwsPDQ5iamoqCggIphvO0aTkV4v7TpaysrMSKFSvq7LOtz1MWFu3Uf/7zH2FlZSV0dXXFwIEDxZkzZ6R17u7uwtfXVyn+wIEDonfv3kJXV1c8//zz4siRI0rra2trRXBwsOjevbuQy+Vi1KhRIiMjQymmsLBQeHt7CwMDA6FQKMTs2bNFeXm5xo6xJagzr9evXxcA6n09eJ71uXPnhKurqzAyMhIdO3YUffv2Fe+9957Sh+S2Tp05vXPnjnjppZdE165dhY6OjrC2thb+/v5KH9aEaP9zVd2//0IIsXPnTqGnpydKSkrqrOM8Vc7po3633d3dG92nEELcvXtXLFy4UHTu3Fl06tRJTJ48WeTm5mryMJuVunP6qL+nYWFhQgghcnJyxLBhw4SJiYmQy+WiV69eIigoqM18P0BjqDun06ZNE+bm5kJXV1c888wzYtq0aeLatWtK++Q89ZWWG/u7f/z4cQGgzucoIdr+PJUJIYTGT4sQEREREVG7xnssiIiIiIhIZSwsiIiIiIhIZSwsiIiIiIhIZSwsiIiIiIhIZSwsiIiIiIhIZSwsiIiIiIhIZSwsiIiIiIhIZSwsiIiIiIhIZSwsiIiIWhk/Pz9MmjSppYdBRNQk/OZtIiJqMX5+figpKUFkZGRLD6WO7Oxs2NraIiUlBS+88EKz7ru0tBRCCBgbGzfrfomIVNGhpQdARETU2lRVVbXo/o2MjFp0/0RET4KXQhERUaswfPhwvPnmmwgMDETnzp3RvXt37Nq1C7dv38bs2bNhaGiIXr164ejRo9I2sbGxkMlkOHLkCBwdHdGxY0e8+OKLSEtLU+r70KFDeP755yGXy2FjY4MtW7YorbexscH69evh4+MDhUKB+fPnw9bWFgDg5OQEmUyG4cOHAwCSkpIwevRomJqawsjICO7u7jh//rxSfzKZDJ9//jkmT56MTp06wc7ODt9//71SzOXLl/Hyyy9DoVDA0NAQQ4cORVZWFoC6l0IdO3YMQ4YMgbGxMbp06YKXX35ZiiUiai1YWBARUasREREBU1NTnD17Fm+++SYWLFiAV199FYMGDcL58+fx0ksvYdasWbhz547SdkFBQdiyZQuSkpLQtWtXTJgwAffu3QMAnDt3DlOnTsX06dNx6dIlrFmzBsHBwQgPD1fqY/Pmzejfvz9SUlIQHByMs2fPAgBOnDiB3NxcfPvttwCA8vJy+Pr64ueff8aZM2dgZ2eHcePGoby8XKm/tWvXYurUqbh48SLGjRuHmTNnoqioCADw22+/YdiwYZDL5YiJicG5c+cwZ84cVFdX15uX27dvY9myZUhOTkZ0dDS0tLQwefJk1NbWqpxzIiK1EURERC3E19dXeHl5CSGEcHd3F0OGDJHWVVdXC319fTFr1iypLTc3VwAQCQkJQgghTp48KQCIffv2STGFhYVCT09P7N+/XwghxIwZM8To0aOV9hsUFCT69esnLVtbW4tJkyYpxVy/fl0AECkpKQ0eQ01NjTA0NBQ//PCD1AZArF69WlquqKgQAMTRo0eFEEKsXLlS2NraiqqqqsfmpT5//PGHACAuXbrU4NiIiJoTz1gQEVGr4ejoKL3X1tZGly5d4ODgILV1794dAFBQUKC0nZubm/TexMQEffr0QXp6OgAgPT0dgwcPVoofPHgwMjMzUVNTI7UNGDCgUWPMz8+Hv78/7OzsYGRkBIVCgYqKCuTk5DzyWPT19aFQKKRxp6amYujQodDR0WnUPjMzM+Ht7Y0ePXpAoVDAxsYGAOrsk4ioJfHmbSIiajUe/qAtk8mU2mQyGQBo5BIgfX39RsX5+vqisLAQ27Ztg7W1NeRyOdzc3Orc8F3fsTwYt56eXpPGNmHCBFhbW2PXrl2wsLBAbW0t7O3tW/wmcyKiv+MZCyIiavPOnDkjvS8uLsbVq1fRt29fAEDfvn0RHx+vFB8fH4/evXtDW1v7kX3q6uoCgNJZjQfbLl68GOPGjZNuCL9161aTxuvo6Ii4uDjpPpCGFBYWIiMjA6tXr8aoUaPQt29fFBcXN2l/RETNgYUFERG1eevWrUN0dDTS0tLg5+cHU1NT6alKb731FqKjo7F+/XpcvXoVERER2L59O5YvX95gn926dYOenh6OHTuG/Px8lJaWAgDs7Ozw5ZdfIj09HYmJiZg5c2aTz0AEBASgrKwM06dPR3JyMjIzM/Hll18iIyOjTmznzp3RpUsXfPbZZ7h27RpiYmKwbNmyJu2PiKg5sLAgIqI2b8OGDViyZAlcXFyQl5eHH374QTrj4OzsjAMHDmDfvn2wt7fHu+++i3Xr1sHPz6/BPjt06ICPPvoIO3fuhIWFBby8vAAAu3fvRnFxMZydnTFr1iwsXrwY3bp1a9J4u3TpgpiYGFRUVMDd3R0uLi7YtWtXvfdcaGlpYd++fTh37hzs7e2xdOlSbNq0qUn7IyJqDvzmbSIiarNiY2MxYsQIFBcX81uqiYhaGM9YEBERERGRylhYEBERERGRyngpFBERERERqYxnLIiIiIiISGUsLIiIiIiISGUsLIiIiIiISGUsLIiIiIiISGUsLIiIiIiISGUsLIiIiIiISGUsLIiIiIiISGUsLIiIiIiISGUsLIiIiIiISGX/D3rINFziEW6MAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "imp_rf = plot_importancia(mejor_rf, feature_names, 'Feature Importance — Random Forest')\n", + "imp_xgb = plot_importancia(mejor_xgb, feature_names, 'Feature Importance — XGBoost')" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "41d8c51d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " RF_rank XGB_rank delta\n", + "ShapeFactor3 1 1 0\n", + "Perimeter 2 9 7\n", + "Compactness 3 2 1\n", + "ShapeFactor1 4 7 3\n", + "MajorAxisLength 5 8 3\n", + "MinorAxisLength 6 6 0\n", + "ConvexArea 7 5 2\n", + "Eccentricity 8 12 4\n", + "EquivDiameter 9 3 6\n", + "Area 10 4 6\n", + "Roundness 11 10 1\n", + "AspectRatio 12 11 1\n", + "ShapeFactor2 13 13 0\n", + "ShapeFactor4 14 14 0\n", + "Solidity 15 15 0\n", + "Extent 16 16 0\n" + ] + } + ], + "source": [ + "# Comparación de rankings\n", + "comp = pd.DataFrame({\n", + " 'RF_rank': imp_rf.rank(ascending=False).astype(int),\n", + " 'XGB_rank': imp_xgb.rank(ascending=False).astype(int),\n", + "}).sort_values('RF_rank')\n", + "comp['delta'] = (comp['RF_rank'] - comp['XGB_rank']).abs()\n", + "print(comp)" + ] + }, + { + "cell_type": "markdown", + "id": "750d622b", + "metadata": {}, + "source": [ + "## 9. Ensamble — Majority Voting con Bootstrap" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "b9c3633f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ensamble F1 train: 0.9754 | F1 test: 0.9361\n" + ] + } + ], + "source": [ + "from scipy.stats import mode as scipy_mode\n", + "\n", + "# RF y XGB usan features originales; NN usa features escaladas\n", + "modelos_info = [\n", + " (mejor_rf, X_train, X_test),\n", + " (mejor_xgb, X_train, X_test),\n", + " (mejor_nn, X_train_scaled, X_test_scaled),\n", + "]\n", + "\n", + "np.random.seed(RANDOM_STATE)\n", + "preds_test = []\n", + "preds_train = []\n", + "\n", + "for m, X_tr, X_te in modelos_info:\n", + " idx = np.random.choice(len(X_tr), size=len(X_tr), replace=True)\n", + " m.fit(X_tr[idx], y_train[idx])\n", + " preds_test.append(m.predict(X_te))\n", + " preds_train.append(m.predict(X_tr))\n", + "\n", + "preds_test = np.vstack(preds_test)\n", + "preds_train = np.vstack(preds_train)\n", + "\n", + "y_ensamble_test = scipy_mode(preds_test, axis=0).mode.ravel()\n", + "y_ensamble_train = scipy_mode(preds_train, axis=0).mode.ravel()\n", + "\n", + "f1_ens_train = f1_score(y_train, y_ensamble_train, average='macro')\n", + "f1_ens_test = f1_score(y_test, y_ensamble_test, average='macro')\n", + "print(f'Ensamble F1 train: {f1_ens_train:.4f} | F1 test: {f1_ens_test:.4f}')\n", + "# Desempate (3 votos distintos): gana la predicción del modelo con mayor F1 individual (XGBoost)" + ] + }, + { + "cell_type": "markdown", + "id": "fa5b357e", + "metadata": {}, + "source": [ + "## 10. Tabla Comparativa Final + Diagnóstico" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "52d02a7d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 ModeloF1 trainF1 testΔDiagnóstico
0Random Forest0.97390.92800.0459Bien ajustado
1XGBoost0.97790.93270.0452Bien ajustado
2Red Neuronal0.95650.94040.0161Bien ajustado
3Ensamble0.97540.93610.0393Bien ajustado
\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tabla = []\n", + "for nombre, f1_tr, f1_te in [\n", + " ('Random Forest', *get_f1(mejor_rf, X_train, y_train, X_test, y_test)),\n", + " ('XGBoost', *get_f1(mejor_xgb, X_train, y_train, X_test, y_test)),\n", + " ('Red Neuronal', *get_f1(mejor_nn, X_train_scaled, y_train, X_test_scaled, y_test)),\n", + " ('Ensamble', f1_ens_train, f1_ens_test),\n", + "]:\n", + " tabla.append({\n", + " 'Modelo': nombre,\n", + " 'F1 train': round(f1_tr, 4),\n", + " 'F1 test': round(f1_te, 4),\n", + " 'Δ': round(abs(f1_tr - f1_te), 4),\n", + " 'Diagnóstico': diagnostico(f1_tr, f1_te),\n", + " })\n", + "\n", + "df_tabla = pd.DataFrame(tabla)\n", + "\n", + "(df_tabla.style\n", + " .format({'F1 train': '{:.4f}', 'F1 test': '{:.4f}', 'Δ': '{:.4f}'})\n", + " .highlight_max(subset=['F1 test'], color='#c6efce')\n", + " .highlight_min(subset=['Δ'], color='#c6efce')\n", + " .set_properties(**{'text-align': 'center'})\n", + " .set_table_styles([{'selector': 'th', 'props': [('text-align', 'center')]}])\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "a7ee6f68", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "╔══════════════════════════════════════════════════════════════╗\n", + "║ CONCLUSIONES ║\n", + "╚══════════════════════════════════════════════════════════════╝\n", + "\n", + "1. MEJOR MODELO INDIVIDUAL\n", + " Red Neuronal obtuvo el mayor F1 en test = 0.9404,\n", + " superando a las demás familias en generalización.\n", + "\n", + "2. ENSAMBLE\n", + " El ensamble majority voting con bootstrap obtuvo F1 test = 0.9361,\n", + " sin superar al mejor modelo individual\n", + " (Δ = 0.0043).\n", + "\n", + "3. DIAGNÓSTICO POR FAMILIA\n", + " · Random Forest : F1 train=0.9739 F1 test=0.9280 Δ=0.0459 → Bien ajustado\n", + " · XGBoost : F1 train=0.9779 F1 test=0.9327 Δ=0.0452 → Bien ajustado\n", + " · Red Neuronal : F1 train=0.9565 F1 test=0.9404 Δ=0.0161 → Bien ajustado\n", + " · Ensamble : F1 train=0.9754 F1 test=0.9361 Δ=0.0393 → Bien ajustado\n", + "\n", + "4. FEATURE IMPORTANCE\n", + " ShapeFactor3 fue la feature más importante para ambos modelos (RF y XGBoost).\n", + " ShapeFactor4, Solidity y Extent coincidieron como las menos relevantes.\n", + " La mayor discrepancia fue en Perimeter (RF rank 2 vs XGB rank 9), lo que\n", + " sugiere que XGBoost captura mejor las interacciones no lineales de esa feature.\n", + "\n", + "5. APRENDIZAJES\n", + " · La Red Neuronal (Keras + StandardScaler) compite con RF y XGBoost cuando\n", + " se escalan correctamente las features antes del entrenamiento.\n", + " · El dataset Dry Bean es limpio y bien estructurado: sin nulos, sin categorías,\n", + " lo que simplificó la preparación y permitió centrarse en los experimentos.\n", + " · El ensamble mejora la robustez pero no siempre supera al mejor modelo\n", + " individual; su valor está en reducir la varianza entre familias.\n", + "\n" + ] + } + ], + "source": [ + "mejor_ind = df_tabla[df_tabla['Modelo'] != 'Ensamble'].nlargest(1, 'F1 test').iloc[0]\n", + "ensamble = df_tabla[df_tabla['Modelo'] == 'Ensamble'].iloc[0]\n", + "mejoro = ensamble['F1 test'] > mejor_ind['F1 test']\n", + "\n", + "lineas_diag = '\\n'.join(\n", + " f\" · {r['Modelo']:15s}: F1 train={r['F1 train']:.4f} F1 test={r['F1 test']:.4f} Δ={r['Δ']:.4f} → {r['Diagnóstico']}\"\n", + " for _, r in df_tabla.iterrows()\n", + ")\n", + "\n", + "print(f\"\"\"\n", + "╔══════════════════════════════════════════════════════════════╗\n", + "║ CONCLUSIONES ║\n", + "╚══════════════════════════════════════════════════════════════╝\n", + "\n", + "1. MEJOR MODELO INDIVIDUAL\n", + " {mejor_ind['Modelo']} obtuvo el mayor F1 en test = {mejor_ind['F1 test']:.4f},\n", + " superando a las demás familias en generalización.\n", + "\n", + "2. ENSAMBLE\n", + " El ensamble majority voting con bootstrap obtuvo F1 test = {ensamble['F1 test']:.4f},\n", + " {\"mejorando\" if mejoro else \"sin superar\"} al mejor modelo individual\n", + " (Δ = {abs(ensamble['F1 test'] - mejor_ind['F1 test']):.4f}).\n", + "\n", + "3. DIAGNÓSTICO POR FAMILIA\n", + "{lineas_diag}\n", + "\n", + "4. FEATURE IMPORTANCE\n", + " ShapeFactor3 fue la feature más importante para ambos modelos (RF y XGBoost).\n", + " ShapeFactor4, Solidity y Extent coincidieron como las menos relevantes.\n", + " La mayor discrepancia fue en Perimeter (RF rank 2 vs XGB rank 9), lo que\n", + " sugiere que XGBoost captura mejor las interacciones no lineales de esa feature.\n", + "\n", + "5. APRENDIZAJES\n", + " · La Red Neuronal (Keras + StandardScaler) compite con RF y XGBoost cuando\n", + " se escalan correctamente las features antes del entrenamiento.\n", + " · El dataset Dry Bean es limpio y bien estructurado: sin nulos, sin categorías,\n", + " lo que simplificó la preparación y permitió centrarse en los experimentos.\n", + " · El ensamble mejora la robustez pero no siempre supera al mejor modelo\n", + " individual; su valor está en reducir la varianza entre familias.\n", + "\"\"\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/proyecto-final/outputs/bitacora_experimentos.csv b/proyecto-final/outputs/bitacora_experimentos.csv new file mode 100644 index 0000000..816cfe9 --- /dev/null +++ b/proyecto-final/outputs/bitacora_experimentos.csv @@ -0,0 +1,16 @@ +experimento_id,modelo,hiperparametros,arquitectura,precision_train,recall_train,f1_train,accuracy_train,precision_test,recall_test,f1_test,accuracy_test +RF_01,random_forest,"{'n_estimators': 100, 'max_depth': None, 'min_samples_leaf': 1, 'max_features': 'sqrt', 'criterion': 'gini'}",,1.0,1.0,1.0,1.0,0.9349176812697626,0.9308725039707921,0.9327724377144396,0.9203084832904884 +RF_02,random_forest,"{'n_estimators': 200, 'max_depth': 10, 'min_samples_leaf': 1, 'max_features': 'sqrt', 'criterion': 'gini'}",,0.9731775711190289,0.9686270125964206,0.9707547781581585,0.965191036002939,0.9347906630645412,0.9294541680440085,0.9319017166110111,0.9199412412780023 +RF_03,random_forest,"{'n_estimators': 200, 'max_depth': 20, 'min_samples_leaf': 2, 'max_features': 'sqrt', 'criterion': 'gini'}",,0.9903948234299282,0.9886133978226317,0.9894877918994095,0.9880602498163116,0.9334076449913921,0.9290154634490754,0.9310578989186767,0.9188395152405435 +RF_04,random_forest,"{'n_estimators': 500, 'max_depth': None, 'min_samples_leaf': 5, 'max_features': 'log2', 'criterion': 'gini'}",,0.9698886043179353,0.9669393350582488,0.9683599857843987,0.9636296840558413,0.9337158223094045,0.9298809359586047,0.931652433121954,0.9192067572530297 +RF_05,random_forest,"{'n_estimators': 300, 'max_depth': None, 'min_samples_leaf': 1, 'max_features': 'sqrt', 'criterion': 'entropy'}",,1.0,1.0,1.0,1.0,0.9334557081244913,0.9299161263046146,0.9315722997775326,0.9199412412780023 +XGB_01,xgboost,"{'n_estimators': 100, 'max_depth': 6, 'learning_rate': 0.3, 'subsample': 1.0, 'colsample_bytree': 1.0, 'reg_lambda': 1}",,0.9999496627403605,0.9999322630901578,0.9999409504488485,0.9999081557678178,0.9381833017622513,0.9345106923717922,0.9362721257358918,0.9232464193903782 +XGB_02,xgboost,"{'n_estimators': 200, 'max_depth': 6, 'learning_rate': 0.1, 'subsample': 0.8, 'colsample_bytree': 0.8, 'reg_lambda': 1}",,0.9995124631182911,0.9993828425668196,0.9994472778499259,0.9991734019103601,0.9400145643891352,0.9355998108933601,0.9377337700729521,0.9258171134777818 +XGB_03,xgboost,"{'n_estimators': 300, 'max_depth': 4, 'learning_rate': 0.05, 'subsample': 0.8, 'colsample_bytree': 0.8, 'reg_lambda': 2}",,0.9738431057592221,0.9714270969690408,0.972586594741007,0.964731814842028,0.9390495539072736,0.935051375447481,0.9369779245757606,0.9239809034153507 +XGB_04,xgboost,"{'n_estimators': 200, 'max_depth': 8, 'learning_rate': 0.1, 'subsample': 0.6, 'colsample_bytree': 0.6, 'reg_lambda': 5}",,0.9979483687785702,0.9974251802181292,0.9976852599170984,0.9971528288023512,0.9360823265498792,0.9320238330654388,0.9339747695658638,0.9206757253029747 +XGB_05,xgboost,"{'n_estimators': 500, 'max_depth': 6, 'learning_rate': 0.01, 'subsample': 0.8, 'colsample_bytree': 0.8, 'reg_lambda': 1}",,0.9711283975656463,0.968488525587758,0.9697589584183979,0.960966201322557,0.9388577890936005,0.9344234986407992,0.9365260895250824,0.9243481454278369 +NN_01,neural_network,"{'capas': (64,), 'activacion': 'relu', 'dropout': 0.0, 'lr': 0.001, 'batch_size': 32, 'epochs': 50}",[64]→softmax,0.9514075483337615,0.9497502280290414,0.9505399462571212,0.9393828067597355,0.9382200228163496,0.9367635261121906,0.9373738091629885,0.9265515975027543 +NN_02,neural_network,"{'capas': (128, 64), 'activacion': 'relu', 'dropout': 0.3, 'lr': 0.001, 'batch_size': 64, 'epochs': 100}","[128,64]+Dropout(0.3)→softmax",0.9544504646790793,0.951693687099693,0.95297564727531,0.942505510653931,0.942351208286615,0.9395367498811359,0.9408371424891058,0.9302240176276166 +NN_03,neural_network,"{'capas': (256, 128, 64), 'activacion': 'relu', 'dropout': 0.3, 'lr': 0.001, 'batch_size': 64, 'epochs': 100}","[256,128,64]+Dropout(0.3)→softmax",0.9596197331839835,0.9560282590407893,0.9576542667718927,0.9473732549595886,0.9403300598776779,0.9375579241769321,0.9387617954675829,0.9283878075651855 +NN_04,neural_network,"{'capas': (128, 64), 'activacion': 'relu', 'dropout': 0.2, 'lr': 0.0001, 'batch_size': 32, 'epochs': 150}","[128,64]+Dropout(0.2)→softmax(lr=0.0001)",0.9515492560718786,0.9492242953999462,0.950294386638384,0.9401175606171932,0.9396175891521139,0.9377347900370906,0.9386047132899191,0.9280205655526992 +NN_05,neural_network,"{'capas': (256, 128), 'activacion': 'relu', 'dropout': 0.4, 'lr': 0.001, 'batch_size': 128, 'epochs': 100}","[256,128]+Dropout(0.4)→softmax",0.9554800613552519,0.9537600530164673,0.9545517843251645,0.9441587068332109,0.9395108985072946,0.9372280998211393,0.9382606172667207,0.9272860815277267 diff --git a/proyecto-final/outputs/figures/.gitkeep b/proyecto-final/outputs/figures/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/proyecto-final/outputs/figures/feature_importance__random_forest.png b/proyecto-final/outputs/figures/feature_importance__random_forest.png new file mode 100644 index 0000000000000000000000000000000000000000..241f814f7b2f08da583630b0e2676bb799a2e8ec GIT binary patch literal 64011 zcmeFaXH=D0wl<1dY8k02BL*;liUKMiilj1u8&H%C5>%38C1;G7MK=f{3Mx5E63HqG zDj-UftRgu|+GM_GLig$K-qB}_zCZ4d@1E-zJq~5qVZCe3`J}nd^j>`SbWcdu+bCHY+Ss46GGIG$%I2(@rHz^K>2-Dn zR@TOr7D56$cL<2`tvh35bJlwA_U-2X^*018t&FyBk}lD}tIRulSi_o)ZN*>ozZph> z#dxn_d&a?i$_|e@Y8`C~Dkk%ORp@)({e9ot<#LyDRpmP0#@?<{F1*0)Dv8o^9Mc!etmoLNHBf+N49kmzo}3Ec=pWy_kRjV>*+b`C%@^+)vHE! zylm&)*=F*wu@(RM=b!7nK6pR9y7AhzYsU^AynI?uPbl4cv%roWcct9A^+x(zZ{QE) z<>d{1FV6KYH}XtRPoFt+W@-5Gjjp4eDQT{wc80$5#RNyXr4JrFXy`lgcHDnLduES* zs=nO}HnuUPpC7z7C(6ByTYtdgFmwO@{YzJ_e31HXUCEI^N$vKEIA8CPfLBr_wSf{9 zvDzhmLPj=C1spM&$+BLXjuc0#MEz`U_rJbu1HX=r&c}zlOdmFvh_Rx-)$_13>K|#3Go73mHy*4`vyB>Ib;sdjMIL*)pZ**lMkPdcnd`)Gv)$ye zU6vkZs$oahM!BkX>AcwKI%4Cm$GUO*c5;8FeLd58H10&o(L(>-YIPZojU63kiJQxk zO)G?5hR&+QXsU=>{k)5{p1*XP(RVCZa z)%@%8*Ts^eq8bgkx0SBUU-q-Jlb?%=D|4(jf21>|zT*zpk|lb{tjarU#Y)p`O&bgS z)i^mhx2i@z7#Zx08X6k1X%}}MjHdti_U)vjqvMDCe7V=JU$<4n1%7%gW|UHt8CMvu zm)GCqZy9;^`x`5Jd$p4%pET|g+|IQ|Q2$zCotS-gY@R1qMRTBgZ0_yV+qP_ZpU}}d z+#IOZU6*Ow`}2cv_j+#bw+X(Ur&c}`G`O)$lgJ z+A0&n0^BDY>5nuL4OM>qc(-i%^3d?`Eg`|dUprGyznhb&y2lRKd%)ICmI!*)Vw@rQXcIm>%+&3RdIB3id2t3-BuoRA}#O$ zYhp3K`t!fnuV4T1-o~p5`X8QIHGVYi_!@7VC199nSg1JAR(7BNgvjvFP&oeNp}1qh z!kqV?B?Poy9y{_-_;`T0sBSiP70}Ic(YQ2cks`iFBc9go-MfcJN2BEZ1lzs@T`iB*HZ>ky zHz_dVZ;zF1Z0n9(n#(T2&A~pR(1b00yQ4Dk#7J6N+A5q0pTOFhnp+$~hF?2PEjE65 z&*ZuJy}jMkwgYRwo1R@+m|C2UG(IMuITq_SKBzk9vTdqKNsmR$AFltfMLGP~!vQWS zw;I9nUk!ONpK5E}3m)wB_@FPy&4Eqt5fv5nCDqzUu39_Yj$^p5Ipr2@RsDRQ!rnyu zCCSl_#JNruh4Ytf)jyn&7NF7m=`nwE!DQ!;AE#~2SFBi}SD9dti%ovpW6^3&9p7}_ zFg}fhm11@s&pF&{(`_q)=}1_Bi$i8x&L} zo1VzrZQWF0yaz|)4xZrGn8vOwF4z8hU!paH@~zuDJIx2O)(W3F_Asuo=X*{}Z1eZ; zr+&V_m(%vOG2b_4L@V2^_DpSBa@nqo%uN1n8HV)zttz+Vd<8-rwPk$n6$KPYP1Y1Q zRp`1Wi(0yM`|EnG5w%(=ARyqQ*VWaPdvW%HjytZb?qfv(5{nofUS3{h&Z^8`*c6qW zflTIUo7UoYZT7Vl6&1Y?J+55Q&~DJd{t&EsVQ$*m{qv`OnJ)87thU%jUS8hXs=&A1 z?$QtPR*F0H%o}6 zror&6k9Ay+<1%`0?6j;CZ@}sF(W{8l-Mw5u>&(*aIyHColg@m3)0JG99D5=~pm2m! z?R+CvZjYGQ>hIsb`|RKr6|LOk)E|CorN=K;z5D7^>t<|U{u3{R?K-}m8rJK>L(9$M zayJ{+bNce^ka0QF=hkoPm5D~X#U&(e;~a6&yDiMwF)`G@9<=|;d=Ku8J9d0_K)<<7 zE8N#yw42Ff-tzWds)sT!jn`Pjkj6d>2YdhieQ=z}n zJkD(@k@}9~g+~L#jpxmz8lzVddc?9~xoSS5@LIXAu1d|~DnqKnFT zOKNhgWXG-29o?hd*(sOh%OX`0hvgkt1?I7G4fzCeC*pL_Tn`uC}%!Wikxp-OTre}+uP^p z3vz5e`slgnr0^`hKCZuwTdR_z)_*utpXK_{T>ADZgTsO!efa$i{gd>$UorIy9*LGT zjeQA{i7~wQ)n7Zwu2VCASSjqN#^ZFcSM%r3Pgva%t&>?*Y&bDCtlI3<-*Rf++^)r2 z3y(hDYvA{~G|@;Q%Gy3#1Wi^D1>TS~yz|zrx$3Qqqen$Pdh_ZX76jfX$-sWtySJ)o zjOrd>^a19t*04a$$LTh$%tp^%wDXNTJUj<>QQy9+|MS!1YLiWswNr0##M*w#pu#C)%LH>&+z%xJ-$}bbtH-BAfw&7KYMaKZhgoni%fgzVy}tuqTj7`ofEkVJpl-# zBzfd~u;F%@mM6^%$BFY1&^F;03BZ7$6}wtLW9_##b|YUOt~Y1-ZIv zQiZv2u6(@Hq>kIzBxz}B^-qj;hl!S(#$|3|XyVD@uXuf5)!UdKmSB+oamT{(-u&&J zb_YCP&*gGC$r{4K>~bD7V<-Yhm2_CTaRNAbH3cYmK0EpPqDg&LX5p`Ahi+1zW(E_y z!h;ksH>rr_#}j81*JV1FWJu!)H@3DKTW7e9k3_1*JmfaUoBA|(oH~PN#|-9_aC%=~ zUmt3T|0)ZTVfW8sIiY~u$5$0Dl3M)f(}Fw?I3XHj6iVi7vPqo?QA-p|g?Zv5WZ z7=mJDjE%qy{)m+^D1R#XM37S*;ef|8wOMO z%;$CKu5%ZzT*uDNp5FZI*)#7)kNEKOqLn*dS@?TOjvPie0nmQ2oKO8^N@2;+cy{31 zw{L|fYhStyCxp~uIc$5r?aR*;6%(tzHSlp;T+6!^y58J{enOiIO(i3W8i5$(n4cbr zdKv1nIWV=RD9{A&t%YWLGaUO28H%#9H&73Ug{%DzM7@1`P&>onIBNEbM{*3t7gUm6 z_FYAzI>Mi1*BfoEJTkz(C^RIYH*YLSA^4mgd+fHyc#xH6UF zPrnmBa1Z^trR7Udq;dqawhs&6+t*j3>ppHUaJ4D3p#C@C@>E^7;X{N8)`+={y=?Rx z9T{j3t4!HFm7GX1H2Z}iW+8_;Q{(cz3)u5YP=C#$|{%A(EQ$o z9UF>{6TtQaC|Jh3=rAnjp&_w4ygpZ|7< zg%)!hC4et3By$3gfC=PMI{}=64f{;Qvd(N^)HWsT*QmP`fSc;UgKu4{{kmVjdv^%% z{%E2$a9b`|y&UkM2_14WrfhlX!N3%=X{iWR9q9g}rMyFpY zlKGPD?tXja&Nsb@_yye9*wnO%A$$1nvD2qdr*)@Zb>sx5*~Zwa9R7J$nW>w*cBYdG z3Uj9A=v+t3WV6cN>jf6kIFmpOL&sbTFL<3=xfcur)g^MqtT`>{2x_gxAtjGGhX*Qj z+iUIXlUS}NI9H10W$*jmlgT+>s-2}ndy|wli}1JlhTi`*G}|;%DqHIm;x8W zb5g?h3(qB%V0QMVqmLduWtI20mI#RthRFFAYYU7$_jESml~{-mjq@1k%<2M>xF^5K zi;h7{%NhR{bJ;nS!KCgpna@zN&fp8DIrfEuMVJAJ-d@GS+b1R0GbH|@$Usd^4M$WV z-M+j0$-YaW4(+z&hze~Bmi)3>~oVockUeft^*%4 z>c8Nhl&0HTF5^@G+~n!f7k&S#L4e9hOO0oKj;&=mY0kP~?jyZ1qr>fS*DP5ARmxh{^dTvF#OiB;qtg1yQhL}zK?pDgu(k$rqn(OK*ZkB!P+V$%n&JK;O z^L+5&L7t}3;ltPV+O~1$?CAd_*8R03B<1AmnYF3bGH6Mqs5&YUiahzZ_9kwolNZ-I zZV_x>S2O9BA6(cR__I5&@}065lT#A_^-Q$zkXF;E8!$uIMMWcTPDXc zoM)z@?~~wxtHm$Os|A%UHM=JC96@J1g?)n3ol}i8n?a$^h^oFkd#dsMy#q{ui7MgI zSiGxZ8*`m={#>Cq8QxnmSvli%)*h$6KK|af=fUpOdJySZ<_payBu-?x3@?dj4?O+( z$v!JPyK*3LVZGdiQPxcrI6?`=0=z=md7QiZM#u3X_u6$ls1?B(D+8-5>C6W370&6$ zw~We6m}o6vJ$m#gdZ4``tn$;?Lx}Y~SR`uz}lJhE0Vw4Gj$?W=b#2G#C-?@_d>} z@0-SOG=+hRY~rk?h<#d4j*Rsc5y7{qmb%lZ;%5N*WM`BZb0Xza!am#T7v}tVM>csi zHlxH=KAznNglbwG%wPs%sU&R7IUJ>Gx+PeJyX#xfNL^Z16$6p4c64^$2F8XS^Pz|9 zrDfJ|D7P`exjpAjrT5C>==sMja#>rGo1#^vOZ>jC@>W#&uhFq`;_VB#S`LY zt&MZJ3(8YIm&c&@Rux&MFqnt%?$}R(QrV5B4OEs)3LozBk@B(Ys)?X#kh-tu(ojcY z(b7Nuc!J$eLeaf@_tNY-A2yC%S+HX1vSlI5`8CBA4|`Rj-v@pEd~EGro5PB23vbL` zusqzhy_^}0!XJe$qv|R-)^ot1C_vj+KwEKqWFSUlQGJGEB1E4!Y%A>OhODOsP6gdp z?{8BJP1VXD3mE;C$F<9*g9vAwsD(Wk4i>m{HT_>8B3YK7qwoMCm< z`t*UuRoqy%trT=Ss;~+yBSt_w?J(16up_--*OWm%lA6gqWFd`95fG9bit zsDwC;Xz*oLHDhUA_1U_p?@5>cyng-qLt$g4W{So5TOBn81qIi!UwO=6=pW(s-F0aW zzn%q``l(?{lo%FSzD9>>llA%rKyVuO@vIbVLWK1xU_%JS8;+#nZ$6fB_t|o6ch^HhKU@MmYY`*&(u7wkKt&GFXmLelW#xN6p|I~j zuA-Yhv;e}ZWaF!DR0t6F>4S9Offm@?R5AGl!RFUSr_Fa#fL=*c1@|@##npX)& zHK3g(mS#EpI-OHiR(4k(lHp2VQXgwyti-FGhd)4s20fq%-;qU{MrvR z=kPGDFmo}Nq?v<*gL=RyNj3EONiTW?v0}%Sx zjPZ3LplkuT2LCRtW?Up|`onvL?f^#7dlxub|EGeSk#zcc>(X1p#AD-dep|ps>F2 z*4W|@md081haj**)$CDxAfNWDSFVIO-=?>S%NmJ1GMTPhjRM92m62U#G-zzX=yGaq ze{PBqm;#iu1gAm(Gd?MttEwS%O0yA(+eMA(MSi;Mea$zA6ZHTwL@M%IuuslP6;Mx_ z7p{|;hDD0Lw^4@B-$#739}Nvq+M<~}a*?R@_y#_?w>b35;_#fR;`OfTxR2Y;{_VHJ zOmT7X(qP7tan#`vV#t{mkVKYoa73)yWwJ%ihi|WS)2*YA_MA%OumbQ+f?{#y$`xMw zt{Pbe;~roX9md*p`x8D1;*oeW6Tl2QVyi^Vwn#}y5wP<(6%Hb1QWAQ5lR`i=G(ahz zb^{OS6Rp0wZpWikV}5@BzCLG%GWsAC0_UnsXZwevYGtw7CjeVYox3x`@VZ-hcn;x( z^gl42CdXOCSIVL_`tF%HccnHH^deS-&sY5J<_e;|kN2E=BbZ)PRt9-DrWogF+0v!l zz&0EnPgm%=9AC2eXlZeX99MqI+R)}p?2?}YB%J$mS6k8tWd;Wab4##lticx_lVqjg zq2C0J7N$T8eP9QNmp7L4M~c~ZZCSs5A9#)`fXJLhtAaC~SzDpYDkM!5h@AcQHzQ)T zi@$GxY=TR!H?NX3aWL!VJF>n4F{g4oj3LFqk7!>K_2I(@2K2YgtjP&yK$b%R0Rgf{ zkE%l09Y9|@gR{^&Xm4#@f)bJhfRou@EcX!w0O~>LBT?(N5MQ0*H&+%A8wQM*jCX#& z5RLB(N%ir1GRw9c`x`~nH!Lg+?CBYFi*`~Q$Etgta}HWNqGi!DS57oMg1`AH;kP7G zwu?hPL;UN?(_h&UI+u;DXB_~%GAs#(nfyZhr|^zh3#L7=#kZjk zPW}4#KOL!on}c89K0mlHd+H~)tJ3HHv!9xnm9yC*WFP(Y`!9tir zjiAkt=_Lo_{VvQFe+K?po8>B&m_PM5)+ymXPN3{7=$jdyoZk(pt+R7DW9a+s?0>pG zgK@t1xio`?-Tz^P32v;?r&;cXum?~;!`VdcSg}z${%jMA2zQ-58;l$(Tmhd zO#srdZTY;O9|p#P<$TB9-Bb`tz{|5*i_r}J@g*r#z3KEWn&=lI!(-US_3&~E? zd9dR+NSjKK^dd(GhnCMz58SwMV`}f7dh^>r%a?|TvRPAa%vmF}_GD*GsuEtt%GS1Q zY`Cv1!_hjb&!{MXte*SmLy1BXeDX*V;>6d{Iwycn$X&~Y75@$Zpk;v)|L`b8bQ{+B}b9`R*ZwHNc^ zxFd{9Lg&w$_XTWdAb)$d{(gh0S6CMm(8|`1S6~KfrCLcSPg-V=s~UXtzK0`*S1LpC zdY6}1og@bRdc%ed%E=}waAxug3y+}iRghYcbCtb%ZMD82?~WbE&;e+1QBSr)uvx~d zco5{i7;o7*D0lQ|IRteTyZ``geo2WEX%i22>OtKZJH{G*&RWMgp39gsRzY<79#|B1Ug4;t)K@EDe!c5jCEIlN+6T6L9kOs$FpSV&J2ML;Odfeo))I zQCz%6Fc%;?8kA}a9+jYevkDJ^3(T27O3oE1d6=R2#p)-Nf9EH9*b*m@CGxpdvLAL-!vzV2fpRg-9KFA|;ljlaxW24DBeniuf`* zPOUsDk;<)E{v~nR>8fA8eCZt+aBX5qP3_`ufn9!ev!VbcX@Q{*hMazPBZAbK<3Sz( z3{M0NKEAK46fMlcN>ruW)4>&B+_-sD2}POIDV)Zmz}v}5=5-mVY4+W**mEat6P&W` ztWrU*QH63^xC?GX1bmFn>J$a2{`b81nnqjHrfH_z#So={w0EK^dvanFi1#s!p(yaE z4|#bqOwuON$Bl6y;Ys!$FqfTp!nz9%2<+VgkKe)C^ue zwaQYc{^|ZNWey!O#*?1^`|mLLZv{Aai86|DdI(OKS0yoMD?>CeA35qLcnH8y1$3?? zBOB++7<7RI2z04XI2P~miQuyht94wU=m@;^N+F3^QHSqsAUA*E<uZNe34GS+71$;G-|utdw=^z31!`1Jjsbx>(z7u{z&8qy7u((j)<}8micgbMew871*}v$zS`*)N~olIqaNfC?B-S5Hfr}=!36%bqMe* zT(s!O?hIxy4!0@3%ER530dTXP0)n=rcV{UDN#7RK(mQ+hd2JpDzM%NjLa;fUE$Uy$ z#~{)24yQyUjMp>R9#vVc={Pu~QIKE7U!o7apftzQ*eTreqw+hL7N{hjZnFwn0w;*S}ypmAyQt2R*B* z{}+o@VO=B<29Tn?+oI;VaS0^us75D4lz!)MXLYFc+!4UGt)KMsuT`g5ngZ-I6^#mO z$&My63KgZpDnhkow#xqf7a@lS|G80`jz2wIVaMK|GLc+Ul~!D% z$mKkERB`RILkp76eA&-j%Ec82yw#S&E>((ZIxtvmX$qZB)s>LB(4FDx4s3k`Tk*Yn zHBX&7<#VK=GZnZ7W8 za~7_Aa`*0C;ZgAx32+QqCg&L+6-`o+0SvLvkZ#Dg@PGB{@6O6Z8Tau4-@;U={f0xD zlsCY82*dQO&2Usw3Y9;O$65+qV05rH+daFs0ilS!Rs!pDc1?Z5^K<*q!@JPW?9l%X z%$PBQat74X5p3B8?Cm3R^eD#(ZNIyBpQ!1&s!&mc!nPE72KWRY&=NLzG4QA=00hlM z+}w{f6;|fo-)2<#hXg<1CcE%pN!nGJdv&25O_?t^m4WM%ZCVxiH4?ZFQ1%7C-mjVb z$d+G_@#iQ+E-bI*vXcg-C>*xGejK9KdB9^~yyzrS8KIRd@P5(>YBkgmlkw&z@-Q;V zaSDpv=a=UiIA4D17cY=_kp2DFxsFM2`lEy@1O$!(d)XPC@-uo;E0)-Cd}w%>p_rEV zY3kkoZgLLYeJ;EH*3%#vPgz;*(`Ob7ahBo<@l@(sIrO(2AIB4J9SoFm&nk?^4neV! z+o~9R4UJ|Suk8{$BO@bz-K?5~-DM5EJ6Ok%WMLFT>f%q#Db}m|DFGL`=@Ie=2D(w$ zHC2!5;b+obgw8_!ft9H$9iyAAQ{132XBrI#JTlt*Y6QAoS&F4@dgA4Yk@oGj-F4cE zZJWNa+-~Yf`|Y;Vh5Aw^AAqBmi9cp7^7mNCaoSItn*kBDtvUs`0Vu_%0q|W3?0VVi z)lp!2t&k%{^oZ@_tSU5e;#fvJd9sd*HY#DFaiaUATa@34CO>`hi%;Z;b!Tj3pw>Qb zvqzoI#4@0J;Rv}uX}n0B2xSW*mcDJxj)jGf#nd2A-Tk1ih`uExzG-S@9Yz9Lc`l;> ztP-<}mcFxw-c4e1tPdHZ&#*g^!Qu!P;{+3;;2c?n%A!oZg42M>?Afz5L}Wd$Unh14 z-WUo!^=s#e=O_2w2aUlFrfLKfxNPm(7%W3sgpv#dsst1Af64gRx>Z(cyx;5N{cT}5 z7F&1jJU(~vn$MsfAZ&?q>xx=Wb&;2Wl`w(CmNnKZ2aoUs9`AjK{0QBkPK6!1xjX{p zA4R(COHR%KY>)CR*HMU8r0n3QNQYlPsEOCP^c^`8Ag%!fstERepGR)_ySHy!P^3vk zlN|o(H8(8|ttY~~`o%v?m!I9;q))BgbN27}_;@QTt74eh%FvtVu39m*cH-KoxzS{s zp)kkN@etRv6vPhJ5^(y&?!c#0$$Km^I+Vp_ON?kRn1MqegfLz!!WHiuwuwYA6!jJ8{%Fd;# ztn7_Sv>BY4@J9B;NR$(+YkY^o^ddRjke4=eORmX&fQ|Qb|CMMT_8)<~d-kZyeB#;i zr22A!z!bIXS$J(N=fg@Kac{UOjEL&_5*F0Zrq-EltnW`a_4Mo2(|`RWQBuFZ<^5Nu zj>=xGfat18cI}`kf^A#IF*!iE5aJFq;h;T+-g+i8KR1}NDO??>WP9ekN?%hA|XE?x;zf7l}iujhS zE1&n-bk%4u$?yPBllR|kSq=bCu?KR8y`u8PFI>0)zw52iyxyrtd0ubBE2}?B!W2?Q z9MPMdh8um!{sm^*2iwu{bOp)mw&NqVDD&OdwWk^1w^Q+#KkwUh=JVgkATYW4buxyo z>qNoI-+KJnWt5u07Tc*8XXBhR!)KQB_bV&78DU2sC+y8aAxkzck#_8By6^Ar4;&B& z2+)cUmxvysC-3zIjX`w@FF})fhBo;Tzk`FzEUufCKTW})zpR4D51Dxr^x*q^8jA1` z5|eJ;xuc2?Ls3Y;hs?n$Q&NX(ouSSAx3tX6c*T+>8&RPkFR7dCl$tqf7MF>9B9H=B z7RnO@{0JB`9}%)cbu>ybocdCCQ`Pskyn>#yiGg5b${PP2r!LkxHm_yCIKEHP3@Pvs z6U)&3lHJCg@DYm*qk;5VpbsfSkOjdA2gW}EtdPH57pzw9Fd=m$onI1U9uOXqD1E@9*dftBf z2n_-(Q82x>^71lZwW=a0!QG12r7#C1kl+UoR-!rO36{f8jl-9qCP308>MwW599uv{ z%`}?`(j<}f2nYRth|Cq}f;Ykdi85bvZaK!m5`hY+J%90Hw`Qe(OR8Phh}rSw=uMx-xiaS)*Au;j|MK@eq`!GI;zk6^Q1FSE+J1p!6{`exy;4To+VCRO)AQz~_oJJe^wUGBi5cp4uEx(w#jSi%gMz_zQe0JVTDO#Zw>Uy%yH(k0yx#IE^GfU^kPE1kQY) z``x>DywFmah{F1GsRK!gPdE3&zyP%Y~pD5-yvw@AH0WR ziyGk^-gw@R*L`A)84RiX3{t|2#ir5MS@Dhw1MJ^_{CI|^hSY(`~M6(*uM`bZlo){TQFnZNQpPhC~C(* zE~HLVK)0j`(HJOc3451QY-O)a%V)jSOQt^bSmN``JzQift&(!fsB;@NC$L6X2~~p- z9MCCHC1njvDiH*-Y|J-H;u-P|5tB zGGwawW4;;XIk*1#uJXui`f2~xqp%!dg^kUBE&Xi1-_UpJDJp1n^n6CxfALlT6=o8S zOrE5O^S{9$|3V}2*Ts5Piu-Pk8cbZgh8Few=8GKvgT_AC*#7t776CtPwjRDcRs#Dj z%u?02;D z3Z)nRYg2E5;b+C z!Bfg?1XiUIHB}rb<>14ALd)3-UAMKIKV*(8)VAZGdqmSw(6&H{CSwx0mu*Blk3k{l zVbE|5%t-M!IXV1#05G%X%xOcxp}+>2X-HC%yEHz^sz62VC_hVIZ?%a0_Kcp335JD{ z#Io_69`4lhs2xP6@3Z?v9~ZbKFLVu>m4I$WVmZpd`^ZjEx+%K~0yuyNz>zP}N2r(W zXp6>@+o#rdU7tjs&~w#j_4N!g6ScGi-O|yVl~7fakRK!lMk5uFWDLOl!oxK7Q zpRh&E9=TC$iU{NYC|*XIEsgmQW`W836dq@|Nm(SlIQNte4zZe&Y!Iu%p>CzQji-@a ze|xQ%Dh?419(7NKPCXnpzaM_=&!IK)GoUVx%^Dc($ze~%W1*IVM}8czgPVbD%~gE= z804 zRCjsa63B)6nHWNV+$iVT^Lp;o-sI#2(z4U2YQlbqQj1f?G385q&E1N#MLIqe3mhKo zX3bBuU!}%+E>W1DlqA7?S!S$O>S@QtAUd(YnY?H+*czXqh?lrb&9r>3VPHTzgBY}1j4T4hF z$KsBP=wmO&#vmWJ!hc&OY871P+$|CHf>sMM8T#A7XrulTTJkzI#-r9BO<@IBLYx) zN)vCP%0v!TS8X~7)u#MZkfli2CaS=r%LKI4fl8DS^Y!6BVJI4a$AK82BC{XKON}dP zifsuWvDd0&+TF57+P29#7{orsxnl-HT-LmUK){J@YOz%JgiT7f$T{#Zpz?kJN8@1t z)hDgV#<&1CSu`RQ&{&?7^#$rwBmS)KFsSlhdU)wSG~q`^lCPXr!h0{pYm*glf6MVV zO)emV+zdQ3ReZ$4VT=k@t=Xm+{NA-FBzc9By845{ozO8z&}7=K)PI5R=Q`3FHd5q1 z5rja|7IASc+6COLc(6Wp$PpiNamfG-j6xBr&YZ|O3k-}RV|Him?AeTjtO{sV4B5xu z8-MDL`UrPlPsR*memoK>hh-o0rnn4SLHrde)GRPZxs3pXh0Qp*k`>3+t=f) zh6PUsUh(>qqPg4}{E6u&AWQ-Z1!19D0Fr!69{?j2g({%tcRLHj6c#Q(;Dz-vRnj^W z;lOM>hOL+ou;Ajgb>A-3mm*Lnq1Sq@hsE+m-nQ^upV^D_?p-1xs!Rw?uWWW#Ws3z< z34jt!gNm8GAGgu8A)ZJnRDJ-;GLt4XMC9nnqostS9wD4SL@E*quqzn(beQ*jVtlld zlYQ~x@_W|vI95#)ck!2a9vH@Zgw%3$z1wJEf=lPQm-g4|YC8%ye0-mp_Y@%O2B3EMh^0#8|seleWxjtUo@j)Ge5aY-1eE^3RytT_umL(N(Wl@Ywn z7-M-rmoME$S~p|)k1&ZsAleFZOoOy6_)k>yAz#v&2LC99Wx@Kk`yayY4SY-@xTpaG zRL$RB`;%j2(;LiIAf<7y+8PECTw5|(0Yf~Kb)1VMb6je);<))WlMW+sPDBwiTrpLX zn2Qt9TZ+cV6tv|E12vPA)!y&Wy{VnmM=b8j3LTn)jn&DFymsyP+nf@baOz%YTAdN} zQ-<-KpTa{m8oyVL^F=CPVW8CHuiEMHVu$E}VTtFfc3VV4EdvtKqyS&Bx${7qN+%+0 zNVwevaDc*SoUH3ziCx6QKtR*|hfpMU4PACd~v!ruj(!o~<$G$ZSL} zGDYHA^@4&XMT;ujwN?qAS;xD}#d&F6T^+GHq=i9Ad@ZUWRd3s{VL!90dRlGMkHy*n zPdya14n7Rc-WtSZK8vst#d|}RK&^VR&(}%_})e0=7h<;2VW5|@6$x`rXDFw+; zM6x^JqlDQ%M9H#vNSy6B|0D)ba!ZtR>C)hQ-|eR8C#sz?o}4jY>y@`UySidwx*eWk z(f*Y>YOz}JBX$Qt!r)3nnAJnq`n0j$pIaqXOM}`Tif0)#S1_)!P-x1|#9%bs?%cYS zv|60vx|rh@Oq6F5IbVy3#n4WiZ=Mg4{8QESta#DbU;BA&xuP-QL4Fi%H!5e8k)(nJ zZ8k|SZ!wILqrfOWJM_LjKUIYhUe!3A7?9&|==>B<0V<%5sgvo{dLPJb>%e5Q)Z}p} z8^XrL+(fz&&o0AR!q{dEr1%rb<4E8T_#rzMF@}%GZjws@G5G)`dBE<>b0?{pnpOxv z8B^c4Zy(vyR?VMc(8*gdaHRy~qKr{JMugDR?g0cOorzpNJZ<1qTQr=;r`_k83j7F7 zY?6QQ1g9_xMcAKaP-3Ii7l;W+#DF%mQpB14tv` zV3sFSnRYCMp8Li-!lR*NK0hkp@%>X zJA)=i&J-m=Ghw&;3{H-ByVGXGvp7QK2n%U5G3JOBRD~F%A|3z~DEw%j@-5pi?O&!9D65@v>+5qf-sHjjwI#CUezMrO6 zP<(t|VDqE4`l)v|Ec@#(Or3alHE7r&UqGFMG+XGd{H!&rSNm6nOaq98PEFZYdXT62 zf>0w517}Ye#HX>XEfP@^V-PpZ=O-^vtIMQF zt9cb^PzZ*RR)D+}X`pDr?a387CCF!Y-Z2;S!wnJS)Gy)`SBH;yAK8@~OL?DR7>v-h z-6-IgDX}@c09rZ;PXPMH5U3#SyM>Rse09DX3^~~Za}8Ue)@Ed6{8O$(&WX~n!KJS6 z;QDT0kmOr7aboArovICoq@`)fuy=4!72$p5P^s{aiK)qvQ?`hk!&zV-p&M)E<8WIvI)rj zCSRXFt#fMUUn}XNj(3?4=f#)Vp4rdDCh9M+JUT^oUS)p}%Dnvi|BU!l0#wdluZqep)g8dx9A>Yc zLT8V{KmqYl>`+5d)L=IVEr*%p#RC{ppQN;T`gLdctYkp|ijtTE1>K7qvgaY1(SxBv z!=31v#i8BE5DUXdLjxJS(7k%<%z(9^P{*U5VIE1gW|+s z)_&dwdjUM51oW23H-wbx;_@8}$cU5oHKq(OIB-PH?tqa+WX= z+(CayR3axN&ZkE7aEe6Cq08teYZYN;;xxN0JH~JBaRa>a*ZP@poEsf9ryPJ{TXd>3 zWhW35{Q_7@;x=%{yEYdrC0Fan)U$jQFVQ!{hnqwp6fKi4&#rLuV$1{xw+z$N;kdG( z9gw6PdV9Wc3|J%S*{sR_(|6LNxQEgA4oRF*^T-sfi6z#stgv&}wXzOUz= z>HBLC|EeW8r*-xK*=f8twt9Tq%xGsC43co_KlbRSInZweU4ql!?~OzO%{9TJ^1ofrV{3XzjoK81|i!K#kMVov@uliNW3vckqd`$oq$kbmhX1mascU$ zPjB|(k`Hc*Jr_?F{SNBsfyc>uWgFUzc*@u!PfxwcF!GC`Ov8@?uul?OkS{)~v(C?8 z>Un*uWXW6paLeX60KS44+1t-WMcq$h&kgq)Fa~|sz)@7r9v?iBHjW8dOKUTv_DFA| zMuZ^0tZeP&+R91|aGsQoBLgoHoGOje)ny9XwkhX#Jnw(7+fm`@(HEl4ZEYr%6(%U! zBF!wsVi0`Zf-MHZUE>-z-C_gyi)_vhKwpfqtk1GDnl}z;LA^4#^vJ93@#UGf1T8zV z&VJt?H6DcaIe_O^zuSyf#K7(z`EC*TXUt&YYj>LA%0M}zeF8Nn3|p`A7GZYikP`Qu z&%hzNc=2MAWxXWec~NK~I82P8g`W|VBwUL{-5Gs%xOq2hcoSKV1@1?qBI&%l?s4PA zsRbKbAWg9^}?;;QbH{cA;J6)_` z=FJIn9pn%6Odf(_d^P4hFA{~M1ZJF$1V|w?5zSw}egU}O0hKT)bHhbENcpLt#*%OV zqH`2ros_f1YxX=rst82N5PE0XlI*#dcElHr08AKxU`q28MEn3;P`yadM=&;+JW$zj zRT*Tp37}z@Dq(-qpe-hd;UGj|w>k9{?xt&@Nb10UssIfvU9u!-!3qJQBO^b(6gXS5 zxQVt+)#l-0guI!-cy;x``2dXmfcAs0^rjHm`LG65ya7mhyn=#?s8!yW9i)woFVTYB zw-b8&uG4RS$87!RJ(h}Qg8ub6i`RsM*0sVED24P$S06#0C*j|CP{>c7z#(EhF_h)R z=JUm{82t-yrT6dN?bYoE&GVF+2&Z{CoVmRYJx_3Fz!SXl7Lae+HPW|M{wnQyio8@+ zqLF8v`=l!o9Fq6Idubt9-If~5w}gCpMW2RJ+F)F*2)LG@vQV5_&L3626^?wxg6$bk zi0EM=_Tyu*lnGY$B=6q6BTomnq&p2nBByQWNEQZ@%4L2$wun^E%ju)nx|73ixXfzu zG+GAomI<1Y*W5!PnXJV`#d(V*f>YBWe@~}l*d`UxNSKN#%baQgTK{R?4K@D@ssHOI z=g{mcpYO#Fd`)aj71u}(%$({wYz`a#(~*q-bfD$`oWD0UdQ)_feAGQB4;lJ`gq(N3 z_fIyo>px{f&Rb{rke37#fN7WxFma*^0=#6eEvUNy0yDTgPKL96U#;tQ?96e!wPH}9 z@Nn_a-CO7~9(|ztB}@9gwpkrSM<#cVoxSLv?%n~XHlgQ8F5GWQ#rj_0f_V6 zrQ}$RX9R_Ur_FVRJf#KCA3c6d!xE$~BKITGyd9z5K(`SFFo3&Rg&Df;VovdJoXyer z+kSu2eH98)zRqoA?OS=n-X!L4+TQ72dVGxj78tHzM)P z|Jy5@oG*j*L)1a8&G6Hs2r}1Dy6i?*c|0XAoR3c)<&*?CtZ+YYn+fg?!GK$o>A3E&_53UsiW>Dw{6GQFMqwS z%?$3bK%=K5dsJMOi8Y2yk0Po}6XyV^e0e2Rvj|<~cq~%FQKna?Pj}|aGcxIFKlki= z5IBjV_7U_K($H3ogka3Y*uX9HA8e9%f%^iJF&9cY3~&Y+gVcNQ;Hxu_;(notzQD;X zXwsO9qmQ5K$+bOahuNU?f_d|fBlf|~An&Ehw6JdCB&DOtV`7q4z zj?qmCtN=X3AmA$Mo`CjBNa{eNwSkgFHX#<2E}!uT2z18fcj4gr4~2~GkU5JkOV5Lp zFGvFY@Qb%@+9Zud7IEDSaS${<0tbqmBa-|mV@#F{P(t*`TVMwA-4Vp1dmNLDm9%je z9VwOfHp-agLcxlM5}k~DVX&Rbx61S3nn0CmpfYNw$g+@j`Qyirq*FO_C_#-)O5!MI zTk3RLOrcI`(evO^4YHprpvuui4r65Uc5TTC$rdDP0FHSvA4J!+HPHFQGl`~lg~JJV zqukYW=s)%y1t3gdHdv8Nruagkm^W|UAf3a3xrs~0U!(L-cQJq9q)vO>|~jd2p-t~`H4ZLF4UOVCur*-uCYt}U%U zREwz#2I;B~0(>;1g_*FFR+@G;#|SyJ=lkA!`(g-+z(A(37FjgKcDR~}mL1`?NR$?h zuJ0&RN}!SExtth%QSghGl56^mtX6`{rmn|uuhRb8p&Yf;~^EY1prn zRfGSwpRUB?4iTLdqOaiQ$rOT}aRExmQXv47vAG}2M6{0>(7L%i( zrPUQEr1SFZJ|@Z36q$o2qk>G&=$%svAk)Ab>v2^dr6k~8MtrZvr~xIoG51-WnSvKm zrQTUn%7SnPLk5b%VL(xXy}b%TCkI84u>fy zoPP!({Iqio9v^+T$DxdWebikV;l)kUzILftiDa9V2u&m3+WFOy40&k$RkDEDD*2pO+Dl(A;0WW(bT&;zJlU0EzZ#K^di^Cg2 z=9uC7hBRD^MDM!9X(^xjj>7oD{JEXAax`{gRK!{MNK^@MFQwWY8)*K*g{82rNd0L= z(lMiZ`~ir%G1ipkk*Dqn1+AhIP60ElFX;289KG5?aUo-DPym3|7q=lt;Q+?mX#^b( zee76XJ)I1kp?G2D?2bE+>-qxz9Bexr<&)G=pIzVeYZ@T-^t_uEQf&-m&kq3UZv!?S z!55*aAd0TSHE~IEg_IY9#u^TNldh1$irzh689eWq=$!4B9_cEs`6_-p?Fqi=tCW_7ODu%yIfavVK+RKb-QsC`EfgV^}xaMtgylgJoE0b$b+ z8+Qb5cVTrVp82wYQ4H#8Hu!`(n~+N<*__1?M>+zs@r3ANfYw%CUETVHp1AwK3dW}# zle|B}^vjojBZmpCDP^zQ&-Z`kXQ|<%m7@&fLu_|t)!K8!?vs7|nl9XFd2C;I94EBt z)8iIa%sC+DQ_i5&Q(a%WI;2==_PYAPUdR4WF#;~oJin|ZE-_;Ona-&0xxzf=cbN_A% z@h}92q8SZzUNpolw8<#1frg8#OzwYQ)zyfef#eIuL6Aw7bqcrK5RI`@q$-jSrG^I5 z`qVTv5C`Br#!RRkqOh2M3L99Jo|?*#bzMBQS6(IZmduQXjIkBa2Tcb$#g(q=x{S)f z-SsYdwl0`RryV5ZqK#5T@l51usW#w4@i)`83;>bJin)eY{77^GS@MSeU6o|)Wta}$ zNAHZBN;#}0zC0;RU{LUpF3-f!rvOAJ`c7zf#4Gtn?Lv%D@acxU!rVT(F&FwQCP0d7 z=5Cds5HfDug`*UT(oyxebC9lWylln36`BFnUi9SwBuO|`5lBZwjwoc{GxAgu$;O!Wvg+=OdBRm0a~Bo$`X09S+Q04 z&9}j`hD=I02RDL_z;rLE^(P0LhJC?I4Tf_w!KlyB94T(!p}4%9NIw!fhx;nc& zK3JdRa?)jCAhgHy^@DMJZv@@MjJH)qC8NPZWLjtf+Q;&&i#j@R1%MP`Q8H<(WoIaO(JlqRDl_OzXjCxNOXpQ6J z)7%fdSh`;aC@Qp?RrhT(&F~;XOI8A84J5;rVH7H3CX2)eM63ocmKz$4t+U;%q>IPs78* zg}dpNWQz9J<{_WR9b$2Q0(V=R0xu90y~8CHi^4_oLjda-XzQNUU1s2kNietJ#uYRS zN6B|c9k{cJK^_C`IPU7(KP1G(lc31b3{i#cB-b$|;$#3=2BKQ8F7ivDfx-1hgWzsK=dHte9!ip%j-vW?a3#(y zzckbq6^F}bH$d)w4{4J;nhxgOeb~dkm~Egdo)Mc^E9IsIyi0kfI)tW4TuPMt2aBu} z;y8IoMuvu53CR++!-X-s66N;Kp#&NYWzkqK@GgEE!~125K)0oUT?GQuDK7nsMo#Q} z-;5oYrY=(pGZc1`{ht$2rvFMF|Ihe|Zh3!|_>CU)V)c8Kq^>)U6# zChNcdDZt@8svw^yV!6SU7BJF$?BJ}bHUr+__hFUy>fdyghgi;oE)E(E4~i9kXM9h< zO++wg5J+5nEWWHU91}bE`~SF-gRSRxqV(X|A&wU4K??EA&8CpdZ+Lq8(rAVb#EVZg z7XwZW&QzHCY&~X<&^b`s>5>;9bY7Z39V6yQQF<6McB7=R(gY{K#$>RZD<7_VMH~*| zJepJ5>)J~rVG`2=c5I$)5rwa)YJ)8GqmNfVLRk&4sLzT)JFDt!hvN%?84e9pA+12h z4yFcCK43q>0>P8)Nt{>Ri>;@RUe6x!WVR^W842KI=Q|%&R|(&WlEEE=M@;KC_vsvk zrAl}hN@pDOLz*oH_9#WRwK&=c1~b(Ly2lY>Ee^jaT@oAOZh!OIH4L5>Kb@6 zy_-g`>3(?Vs#LLX>woaDxPB?x+%g0^;g!Cxt<^@KIF3{wje3*}p3+@0ZIY6Ff$xuK zW(8b|SXd_85SM_ALFNG405 zK$PJYbqW$Z1O+I6lR5O`CfyxS>&8BkHU2EHR5ibe zSBI!9$Al+dijR{|cUOz(vDzyXK=zc;=?Tzlyh*@g*OcgN0b=YsHm2Hkfr zZdL(!3PQ(@f*J$I5{U--7o^hTmqB*Ga)TSu~1ZGaNg;;6r+>mvPo>G`Dh(hgzOz`Voz;q_I=chy&8#xa& zJy=!hg2?DcfNl^c*5?M?U!@-CI_OtsMylosq#G%+rt-2EHqka*sYR|0_NAF9z+)_O zAmF~5IU3D0PME)`3&lLoC{uSVe>}c@pnIJD#Sttg)XK<6<34?N7+^i z>_29B`+!?eqSpx!va?HW;CX@EIFeq*EEk{#9tPa&6j9c?xSPYn7LZE|_dv!ad+$J* zWjRI@(i>zWgzBcg&iMwX$QigXJGcu+kW%mlxy3!dERx5< zcSDb&=r;|L<00_4ySr0-4O&KGy3NiY?Ea~dyu_+4wPQQx9;LB8SFWG7JFgz5YmTd% zk7wI{(cuRLFT$?vltjFLGlL=9v9A*{hL{;MI7nnEOER{ktVKwejr$(^u@}Xth)P6MmWHuQ zqf(N>Alexcl75fpIn3Pm_kaJtbN_$WZ~y&W*L{zR<8;pF^ZvZwuh(;X)fi0m=^ofN zDU!q133rRFoACe+AxpGDUaNJ^%dP4I>M77*$%D}=QJlX4MQH>roro-$b+;w%#8!?c6uxIo{9#i}Im|O)1vGid;`*Qv` z(HfM1k??_r*N8kyqsJ0*;sQ1dIagf>vl<@-NKHOiGI+rWn=@!XIRQc?uID73bMFIC%8hoVqjsM-Fei#q!99kiWRcKL z3pD+$1LZnauiL&(8>spSXQ@ugwq zUdYpXX~SV27Ezn*v|UpljswtJYhao6BH$sa)?olV@yA0>&)muVr`R9e)>s95-!ztmKR<#g=I(tFG;R!uqe&jb{;_sDcdt14dLinF>FIAKr_OYbp}BO zsKS$87*;flZIZ-`u*n=^v+=m!2PO*R4$oM7VLeieTw1;h`T~OMEZJd?*~MWkn#!65 zjJ79N<87c)8YWKt5W1SgDJ=&rG!T1p02KfiEKxEbN(e=eJr6%yfs=ngjN6y&M;Az` z(3ly@4JS5Z>E5_4(m)80;3ypzz03*G3c1*ytZwZ(0w!gpEBw=g^TTpTv)nwbwY3!SvTrKJS$_|x{6Q`jg3Tk;S?kl#T z3DhIvkw*9yw%-whq<@2uIm$~VYhBtsb`dt#!leOt-y|UtLnna^YGw&(sEsw_Ks_8s z@6k|K2&JsaRok_l*GUs5^fKLZfiIkv(ok}@WsWerVatE9hCJBr{D8;46cmd7ecG2G(nIw9VqPtzPWu0MjJOfC9c5njZWF z>s?H%|07}jWYI4cBV|G_@aW*w)~kIl+l;N+A|a4Kvpleg!6#%Z;9MNQRtvcAwf~N0 zuQ6(BR>kRt-%sfS!J~XU;PY36T;&wUGp;jtWn*BZ;wjRA!M8N zJ%MW06b#O{0~4EC`oyPB=C{6jFH^&(y;Y)9e4IHqSqK_5V|T z=XI*!#rbYO<9~UhR#bg+!em0*X3tQG^*=rr7yP4R_FqY@Uv{oR!~jdHyPj_O|3HSA zQ?`RffIjPU`mizM*4|z&c_zIog8N)FBETf(JMyqn{e;u=HSj>`JxWKVW)YpCJRII3 zlvNz(;bH|=TEN#S|f`bbI^vA6kl;gu9VKI zQLU_i8g^@`XXIvOt8|+Y`_@>xK}neu!ek_!`s|G#&F_}b^_>?6e_Hvdxuho_`>QX% z98VeoyUp$i*C8y}J%r6@CP$+|dF#%8a{=aYAUPE>N0La}qmh$^et7EsT2%5~I%b7- z%MF1-W!O!EU+la+TPFT)!_2nu?Fm_Dx_bVd-oc*yG;b+R47*lOGrfAh(n)k9>0IDBOEN*6H&%XP!`O5+ogp>G4E@k?@J4qNKK zxFj2fXLBDhkHs^A zTu6ho>x#F*6}_2o;*9Nn6u!J^1EZ8B^sFt>s-1bn5w{&H=%@3Z9vF9a-Pf<*F}Op^ zNdvB1jao&XW0OJBcmOW$=4x`&Ldq$X?n9Az@LILNR6473Jl4PSr{$z`@+Um}pA8+g zaN)QauUk!VmDVa4wMbW`@vdG9^3coF@aS z#Hm`8U67|?&2^b|;L^4-BnmA{f9Mh?!kc-PLEQ=$h}KMpj8y{ej!ma)y%@T0J^H$M zbf9kV-pTrxB%LT2UM5&MkQDkZe%ULh&zY$R2I1N-HzQKgH3=BUXhP~|8rQNEopVgt zC#W13oG|Z$O!S5WS$HW^HeEVs?e`5{da)cI)6$#(T9;ZlmNKJFe%{ zb;AQT_ypT;%cE_=zr}I;KE=9Oor46wAZ-M>K*nTPyNIO=7c9sl3^N(k@<8w+h~Dnp zfPH%or?c1dh-+t}8XB^c6!KHFxiIhNS>go`a6BL2)3|xfp^h_YgYMF=&@r!racT9B zzYw59>7Y#v=CGFud)6o)OEB=&PizkDN;%w*(h`|?$1~>eAzZ1S`4TGCihWx8b%eGt z!;iKg9>v!0Z1jG!PWb?(o)Z5Rkf^GVLdf)Vo@;pgOX2iPjL+<88nkVU1J73CF6gES zlvUCjo6Qt8Yzz$6s4=*-Rs31v0qCxS!4?z(0zqW!M-=gRpR)wv8#QsU?QmZUSzS2E zX7ZZB%f~qk9Z)y1_iL6Ke&y%$S1;wc5i76xme%8|hL?RjFLRR}2}(il-{K_ZQ5u59 zUk9inll0sXgX)A~_WotBq#>95-FyY_v)}ge8Gg_ILOg)X`FGC=z|cgTP6Jd>DW^6# zbxC%yoMp%-)*iIV&kp&nH0=sQG|B4?8B&%No&A?g^Tih}+t`U7d~EEvDn_+QBaK+G zd2;>Auf4W>Rb188cJ!G2={KbC%Fi!5*&Z9w=lTw;0)2-w1v`9S>HyL7XM#=d4qwJg z*n|fAL(WB=6C7BBIi+Q!4VYS#ePsgI$bD%I1gsqYnH#5$a{ydd0IG&djjI6V!XRss zL?xhK5r(+4zg9P|`MURZRT}*1zhhI2mT!!)hIa2I!w2K0j9&AnG zZ{$=uXyS$%b{6lAyu4;jr*A32f2tzlS;O2kw_SDO^-JYcxBj z4p@y`aUD_ zxBln#kN;S&{lHa&zeudsY~0Xm6PiXO|1`Aa=Zy#SzwnLY1kcyM+S}`$0aezH_}sr{ z^6`EXmL7lGrr=7Qzzsnu2AkL17M14DI_DK|FnvT>eBaV7zsGt+;Aa^*;duksrv3BD z0PFrppX~F;%!ANB6x{>#OW zaMboes~4>1xA^*b!scIov$5YD8+Gdbdo^oLD7LY0Owz;$i@t(!^|{~x)z{*KMS#Oz zA+5}N>Yb5STYlg1S4z;z8t-+x%iwAAoLhWA$X$T#CpNx*<`-QpdVA!}1bTu(mm@D7 zBTWn?9MN+Jcg#KX^s$GEdBm)-1I>w3Rx{szd*rpi=Ilb$;Iq@qS2cHP_2G8&;civ6 z=7WT|s@fc>AmqqYe3@)F(n!#cvJrdxKL99Fwun$|Hb@bNNuBR4M%|XO=OBGyHnFm5 zdyqOe8@gwkvLm%y+Gl2#{-g{XsS?o%(3yvUu_;^)MN&)6Vj;AmnlaE(A?}C%SEK7wl#3(Z?CgQWM6s;P?)Y+ zJIa;7xsTn+m->PxLvMssOc6dp{UzFfcS%Xr>?`Wt z;kcUupv$KdPNABd3}Ojp%*is26zJ@itpU3o{lKGY4QMkd9@^aW2O_EGq9K9?T;8~4}@*J6a=WJkD69WWPCcybCUVOks{^>I;Z0+gk&Q zQMZl;H*sDz8NP4d8zfC%Ei7c%&-={y636r@UTjc(_Y@?r2iZ zWjeYo6bEPcsgP8r=xDFF>t_}NQ7_#PTR-VgP|oeyTrl6imq#r**xSnLM!m3EpA8&1 zFtRl9-6OU3`-NRP+*Pd4-Yoh9RePxPsLYJE*H(MyyLwKb+2VP?#Y6+QTc&P|WHo7- zIR6wAh&F0G)j`^wUUBW)YC-_c>b}vH9ZbC2R-p4EyjF3|eB|bOv{7K5I$!!b1Z?o@ zJBw}*(6Z|5>WIvO?fF4(z4eyuwLyKM!iT_(0XU`3t0;2~@KR|@#j1LIY|{fUAiYbO z?dFv}-EwFz-t~Q(N|a)&uf=9|sHxbNhDKQRL6on>7jF^gpkNt|WZ=wQpBBXgA)})f zid_W`tzISsL>qH9FdK`~#FR4=%&TG3EWg;@^*{OKlQR=nnoQx*yNXJFKgb#9!R@9` zSi_fhvpe_u=jN4YUHN6_j!Fq_v9}XMydmT4?$hBB1no}``)y-ztF`&imbivjd>zkH z-`a67Gbg<>Mb?_UdAmNvL4gGa8r}hr)oQe!b>p3Ctw(h3QF>-OHOd)yBvJZ$o{3J) zr5e3J@2lv%F|*Q~yAP;4U@dbh`8D77JFEN`pf2kh1!=S0t^T@GhYtJNotWf0XtoyRyRC6p9L+rgj7@XH) zJ1@Up!w_nu!VPFJfD{YjhT#W_^DGSN)$9fdaSO>O*d#>*JA$fQ zB#RTzu_NRn6O4M=88@BL9DE{c>mGXwb4uWdt_xB7L7}KFr(XpRI@PN)izyiP4nftJwQ+__&mBBpU*SX7Ux3;j(_J_yX8CN&XNXLyW_Mkr5&OJ0WEHB zlzUP_PWzxPE<6c?l>!6bqTnF5q?IgQ7K>Y9nZ`@-v?zSbk7+)lvMF5onj|55RI`(OyQ{Vk|kCz3F;ZFKW`E(mVhiPI`;|I`M( zHxC({?*Rg>`d?KgFPUAi>qOD^x%!?~Q|9S>2V1r2?8G_fG2a|rMI(I+SI${{(Qf!-Ghsx6>ca&Q}J%|)&9)(?UD5y?%lonPUZp2 zM;=L8I_>ii#~{LKO^Sp6?vv;H@!sB=aZzc~NE)syR+|6XI)@oa>K z^D7N}c3-SQk3Y|(|BK?@chie479BI?Hg4B0wbfqQtW%?QNs~m~OWe5s$6yqab1RGr zuiSRl-niKZ4<51zgXdp<@Y$gsqUelk1Oh9a_Y1#~-4u%ha*(D{j%aqB_;>!5sBH-? zWaa^{xfq-5tEou*3G8bC0Vm^&r z23)mCt~CljUY%|249KwR*r@ZIIDwN~(N8SjvSkYoG9Ig(g2fXM?9>#EA8g^;A1611W8e*)R1 z?uAN_(S+KvM%rOg>=ho5^obJO#NjNK8A9Uc(2aaNHY|Is1 zLoi5SDpe!U^%{-464r zAJ|m#9H5Z_oNy%ybp=aS?T7$sE45P|^y1!JH@Yr0Z-7;1(R*f$z2F+C2%VKmL{Vsw zxv!f(;HfY*9`&?k0Rh8w1%RdmQ)0f)e0;c|w%IE_|B)WY!rrHzmOsL25njkD4W+`& z4ci*%2y{0wvJUMVJGGZXehVt9z}b0C`8jfp+1`@!M_evdsYDV>A3Ic;3VFZEJ(F6d zdEL5o6Yrj|_U$8)o$7nIr4Zjj${1qvUGkG8*9ZNh*F>_RjD`HO4Oy*xnO-J@DV`}w zaK(+yMnI~w@pgf6i&MyAQYZ>XT-(|XlkR7reNsBgnbPOw^vauE%P2=#v>pGc7~_qNuIsdv)pr6-{m3dS|;6 zj-{L8Qeso*_c2XRDd9tpskwhFQ&+Mc%<{dsz8WxDu5~G)J1g4ewm$r_`O5hee^WWC zfZn#@utFAIB+sn}521+63p`VND@E4uXbqq|pEhve*VWV75KT2$kUp1QrC?beXXZM2;nzf!8`G4Tu+n?0V7r2>~*_Vq?Tvg?vOOIJ@o z`Y6^=@)dI4FYhX34Vb4;K)>tyP5;1oJEUoY6Vt~G%9}fyG@v1YpSvyVV%Z9K90K;c zT_CQksqryYdCG>~C?px>8hM!!21|ct}_Q#d97I0gp`zvzu1twpT72Uq=i%Jwn#(&aC>$ z2ksvCdvl)5N*s0KGB{m(dp+eKQ2&_tF>(cCG7s#uh-ZF+k+bTqeS5)z1>ki3X(CCf{LGE9MH3Xp^q&D(9&RzwQkd$9;oA z+rjJxU~qdHk&L(s`IQKx8_()dwS$;LoEp^iVBXv#=ETYY#Rp5JoZc+XMwwJPhZMU$ zYZgk25sttxo|n?e!iK5*708X$v`=LWFexcVgmA|^ODJ4t=N8?&?+o;PO$iYSisf4p z<1(&z+MW4YUn|-=-N+~%;H!}a*8O(XiP`1D>b~3_{>12L#&9-nEqxx|_}#MSQ+fXZ zq4urYVQNxK90NXcw$w9kQdR}Uo8O9>f7vl?V7;$)J!)qD!_t?Z5vKp=q2T|jqo`Hj zVzvCkS{=Q<>e3+XqK5L0eE0d)z0vd!7UM5b{mWh`s@5DEwSp27Ah__EY-?tMFzWzZ z!X-hJyyH*wGGF9`@BU`>W~ma1z+UPbHJ^>mo(0~j(=$1gwc%yw{ac~_$ua|JdPR*&&5qqQ(M~%tqaDVybmv$2Y8L3av0E9XOMRKT|qP8Z%EX@|- zsm7zGZuPF;;F>Xp+uVuyW-nA&JIsZooDL$G2^YyR0&$;r^HU%y({~pQ=2La(!kb?lc8yaO4rodd? zb>3X5+eIYoJqRJ7G7m|`1hy($zm0ajgEc)E6)gm%fmSEro#D~4Faf9 zHua}fNyWjDe^;h4_B9z5MQ4NGg~r-~Y9{XDL{uw+n%ezH^W3zL-fB*&C)MU{_D$P~ zqEv*_P;e>;66bgDu*p3SkloH?%<&uRSr*0Fg)E9+IML9;Q)V>*v=8t?OOi^t!7BZh z%^934q~ix4ebn5jQ;)N0`UziGU_+P?Q!p)XzVvQHb=i1AdIp7%<@Rz0L~4(7V=i|! zU-SK)cp@4*mhRW63e+&3=QM58r1)R>(LT_dwzoEJ+?aBIZCuBAjviJ9KVs{v+awsWnPVY(L zj`WNxY4kH~sax1mR_f;r2oXP00=*I1v4Z}3Oqj)DIBk6WRSGFcH7F8w2J;n_4P1K(0*6LST{e&+fHFyl`T|*l#-|Mpw|yk1bul z`K{#~qmSIeJ<_zw8ZktJ1)=e*pIcFS=JZ+k8F=`%!X$y4^)%v4kK~1r%DsdG+DrDO zvk7hCK!|RMtyDcr)y7B8|9j)W{qa9r5b3gSt=^1n*8a1&lmbMn6GcMP_V>w*-@jjz zOi&o!lPO5wi!>oA!P$Y@Bb-#0!lmr<=li3lG$*6tU-7FbFC|?*t@+LaKe4Io`0Se( zJJxDwzGnM_TD-b*S_Z zgUvsv=ym4Gn}3(^zYx#+uTHrCCM~LH9*tGuh}7*@JWH)w5A!UyVE4E0-?Uy251W{zWFNR_M%-;;`&Vw$gQgbi%+(i; zzI&uBn1K@#IvND#JZNdzzOKIT1(ImkE~5!$d_c}+PGTiviAH=z2CHS)2;HnhMSDt9 zVXP@BnaDfNtMi{Y6sW30?+7)XG$6dtZI)w_q5 zc4Zu&0v{Nw1BfX2ob;#ZuU=U$o(k2MIBL2OMWRS{#H#hqR4TkC1}mbNGn)2628z+g z7w>X+tG+-aDg3v*paS!Gno9Vlnmt`3&2nW6mZADFyO~L*vPrzVHE?z>_S0mf9wlen zCT*kGxI}z9#tZhUJt%{ zz6IGu6>Z_p_A<$d=k-MDNkz!AA#?6*mklQvADs(8N*a4oxMWZCr>9nbN`JGN&#LcZ znw0od7hj;1d~~2)yTV$+FKaXuGE<1BhNo)w$~wi4b{`p|2Z?N_*A@>ROdD;^d{WlF zGL|NOgrk_9b3412VnlS8h9ybu$*!sx5t{R6;QU5KE>X^zBb6hDrC-W!Q<;Jz>rpE)g#cq{JIR&G%)r_rtjPNw_1 zO;;1X@j2kYdzJ8Ih8=~cB1TMpP1&S5CihqeeL8)+tSrotNN9AxH0hPOihtI09gtz? zW#}mSQgKDUzB72(ndWHv5h#OCDprXVH}XAZ*Z}kd&iVaRr=<;62L-vt1+81Ru7!(* zt(>+1wsMzqi`~vGB)gZc3ti%HVWAowRcT>G(8CyHtX7WY&)7C8?+o0`bd1QCQ>8;8iuRfY&9 zQd*6XLKrB(1gLwkn^5ol3fUb2**%mnH6Gp}Z*@2Gs8&UlUJNfAgXloOntE&5*npW= z7}#r3FW2t0rf52vGN7R>!E_$KcMB;&VX(Ez`XoVHC^WHIaU5`m$YTFPWcwtFn3tam%cI z3qF=ukiJhmuEA`LgFpow(-0a>Ou6(FXlFL!(}qUqhTXY4;CxME?1GdeNnFgZ$kbum z`qi^5z3in*R23J7{$WXyMhDIL-57bfhj~s5hu3&T7b1l5zt>^Xn zt{9(SEwqhB(sCwj!*>0cYMS*^7s*muXpo3xuC71(jjn*|QbqV^Ak^;I_>!M1)iG!C zURzj4>3$;5K&{Pl;0SKNb;(bg2OUXse8;RemAaZ*7cs1ZT}kQy%_imnACvV=Rvf~~;=w@Cg zBj>&BTsnj!>^@DpQhy|RqTRZgiCuuhwE?H2npJkALHsc3DqsUz+IOX*y|jPo7U{A` zRS+eD%IQ~DKeX7v;X6vHM$UtFDW>66o63?Je@fkqs~(i$p5e02@#9I!=jJsCM0z%rhH1Mo^COkAc%mAxCsz#L)IUggqfG2SHetu(Nn@OxR9r`N1M~2+1kMKS+&; zU>jGo3=DW-f`=(^u}fJ&TWu*{{rLV0GCA>%DOL+MDa1DsCPtb@&C}qo`-3p(qv;3+ zRa;{~mp*iDg~m*e3)(R+DdzOwI3x_YVE(oz6vK|%iu$K7?7_6DQ-u%RPaWVe#BE=B zS^RogCz>{Cax!#{$_SqkMKkd+P-OJwXRhUQkmcZi?V#o2J&O9i%}2yOhJy~BqCZEz zkS1E7ap24^q*)boDKlZ_@e?O@&~z!3P`+?#y*`Nhv;hhG1R1mgld~=VXu)Qn_lXyy zK4(u`4Su5*P7wv1w&xX{!Xg@$2}0+BQvE!Q#Ql>EmMJ3`B|p`~T1wTQ_?J2uskbY< zP6I4TOa=Mu2-jSV#A8q?6Td1m?>#Y({K4e z;0inTYKE|J7W_m}G+bDnIsk>f945Qh{%x*MYi)Fh4kV#Pi4=Z|t#Fll6$&G5jo=yT zu5N?JXs=d;9_`C`yr)BIS_-SEsw^vK#zEmVBTuE1-R~zG&~E%V`&Na{g@qzgZbtLD{BM7gS=aI2ZR$WT3_#f_9}4qc(_%se{-_Q95uuw-M*{V>vg> zdSjwGO75P578S2h;(sg9x35J1mt&(*8BKi8N)Z%LN-GRY@P)DimcNT;(l8fMZ-sw2!SKNay_S$A(?*{9NK6?5jBcVVc&}z`17s4%TSCBIl3b? z2D)>VK{B|s>pZfIriqqjPSG;RRZXHfIqS}_jFp;G@(_)}UM`@Lo3UJv_0Q-HGJ%3_ zT-u?GUFGEhHJ46p$Fh*jcZxdEU>&M_M$^V;0wN9^y@4tTJ4*BGdq^Q=LDBG!Q3>Gg?1TVp_= zcq1}jYg{b~1&y*X+|PBTX2f*0{8@X|?(+ubyV!=3y@d#8JmdTXScWlPk=zp@(?oNO ztP&+NCpH?9Zqo16s#QxV+S)hNY_A`?di%_~ztwnEk&kkuOVG~c7}lY6&~sq<5)`h2 zPNcsv$-!LkR>e|A%WtD3LY$nRD^Vf8*T{+6>6dpM78VZT%8K}vX-J?JomwY7Yk>z>(t z))5(|i-S{1LQvIv0V9hf8suYN;4oGP#Af8g&b|r`f_vGQ>UR0p)l2u}49rceWx;@Q zzL>xI6>L(73{HmioYfyEj67z*^#wx{`f3=|@NZttU6-2pF*FvBRFhVm~is8HdfhPv+q zn2>>2Msn_3@`gG@0#BdU+$aqOB7;UovFs)L>Fc?)TR5CWQDZDHrpTQ}MBb$GM_R{x zF-3cP=sKrAQnJ17b-IWM{#jA<4dSN=djyF zYJxdp+Jc9bjm6cljenqVEi{um=zW^tc4o72;$7)zMsFOn3YYve3Bc$8-p5%+5%3JX zvepGU_4k^kN!IElWJ&5_R zoxIv25z6T{fA!x}t#0>?-su<;GlWk*o58^V9WLZsXhYx|mmq`FEF-}iio_3z&88CP z!P4kVxjgFFl@geZNjOU^#5u3#6FzUx<5RF+1J=g-yVOG>bJtV7z|*`S{NJw45xYJ%O*?|xz4 z->v>aD*WG#f%zY5E3D-Eq1BC7dYl`+BI$4K#mL;T`teymZq>%_-(R->v>N=A|YIN2!_Sy zkV*!ZG_5njVbu6FrjbJ>XU%H*y1K9yf2ve^igtXfGS})wi)6Zxj^;ZpqhPr>Tt6eJ}_7@Z54~m_uc1)5Iv*O;E8f zUAk2Jb>O_Gv&eD&Bh zuy0MV3Kx?uLqPdHuD0i6sb&=TKy9FeP71)(N_FNeFDiWp|7qcMN^KqF*kT%?GA}y3 zH51HtXwV`S*VyX;=I?J+It&dY-V~+~G6$XACVF}yKe9dG=QAI=>FeqmNCCiybiqDT z5quJ+Q9(ie*=dX8xL3-*`Ux~_TYamdXG5HcmP3L~2?|g`Y*VKyF(U#A`!af=9U$tG z>?j8w*g@4R#c~?@W&LC52G1q;CLMpfcI}q)=FKxl1#r|$NG4Ad*S_&Pd>XSn zT5}Eg3~Nig$_@=z`AF%w6I?Nmxu63UpBm>b>(Pasu3cH<*`docCYjRVJfab%I3I6U`U%}WptCo+$VZPK zQ-XVhvw9UlD+Y^{-(i_mIZpW+j--#=2RGeDwQUL}(ogWL#5za~FC3m%;W^JKqjonI zT%g~BAyQ=0;HCj2-$b@ySBF99=mU&+7FR;fhN5TWjPHKb}% z#UB81E7y%}BSkU0+%B2s8DJmP%BxJ?sf+^~&m|@%)~rkqcPtcu{HBcpMWUJz0o|bb`*}Z@_NUrk0vU-S=$b`JvEu7Gr zS*@IT#Z@EIB2inqqg}5vh?6J4{V~?%PNJZ$B zIQ_q_XN5-x%ZTfJlQp|;%g0YZc1*$ii0rA2h7H!#8qhc(6#ue)T+Qtex>C&Y_t5ks zy}D49oGDf9Dsv!1FqB+Nr53m2l37-eaB%G{oMO|wy;B7q3Q|mtC|@S(TN4L_BPd~l z^CojRh4cD$42=qHb*^ncUnMm-_tQ>+>o(1D3dhCg%XJ^^k;9TD?Mxi z^Q*vQe=k7BGs%ARWRkQgVw!yrBjL1|yv0BM*sFBEMG#|(IAp$=pQYKo|3cbfRBnCP z)Yj6zv3$3JpXKsj9Qb=a=O62VW`msO)pSZ@})YMSG_=1}xA(SPni>#~whIL!SCrR2c>N zn=3~-hD`b;kVc8UDZr}v4q;K8AbkYajWLh84Dn<;F(|BDLpHbxwhS-e^wWlZK#j)*>5WN6<8vsW*#NcjFVzX(>5Dd&mu z&9Q!=uL64Pn&O*vu1)2VqO4(TcqSlFp0SnJY`(H=J$+HJn`4ylW_r6>CVmpxNMkzx zmUs8QdB=+=7xraz)wGg|M@jQ+ssxxjET*NgU8fVfY%tOb?y)XqUR+QYzxU}4(VIxa z?f&?gY^?Z9^?x?X&h)nh5VUQ(&(S>avq@IX5wmVqGb+6$aXL3cBtHiyGLW?)H^1HY z5p9X`RXMRHP;~KBI>$s>>VAI44rRx~y)eGPLxIagP)vIQAI>y8I-luD7ZK(6SN zx%7@21d1+0v?B`?p+{ettiatuxy##mGnA*Xw?-KV?)Bj()wN)|RjFzmym*lg!>3y?rjj+Eas z=J?)eH+%VML!Q)fR-Y=bR!n66kxGe}$Cmb^)PbT!>7|1BmHC4mWG^SJ3-}a>|9MP; zlHs|N#_w}5*pml;HY)V{L|WwmpbUg2zCgIEqI71X=5Kr8+_RPu9|6_x7{BXCHC~dM zpKkGKK2Fs0n4q_za#Sjf&|Q=|EfFNqVC9o(E1a`9v%1_;oToCF={UyUT~`?zTu%%R z3#Jd*SFGZ3ji3t(Bd?pV~V9XG8iqCuDB$*XKKS?e^}9+eCD3PSZ;yN-)}rrwZ-n`u6}`U3 zVy3tHzf<2=(Bzr4*vjf;^uMd`tNPV^oRy6Tf;fp0Q;h@wv^W!B0*Qsrv)e{Ilc%#v z6w-tvH1_(fucyI>X*b|DzxCFEqvl&MztZP{6;(9Mx2D}}P)daZup4MrgTma|?b0d1 zG-?OLL0(z2Rg@8YndL{198v0~@O{L7dxzC#S3V>+YkZbPo;${sXH06}sHirYZY~iD zOP`=`UYUl1Zy<5|@u@ytpRpAWS{;ofaYfpJ+dq6b;#W4!=Mw*uKXpF%{S<^x;Ng1C zB~(J!E&UtYV0OiCQ(O@d3z7rxOu_H|+{F8tEsn{2nmd!h$EUQGO9lEy)hO_C5{9#< zZr#6sf4f42VB7ha;sc>zC`SeY*W9Pn$)}aceK2vCv-CPdT&f3FHW%Yg!I(n9!8=evyB-}u!8VbRj+hrD+>w}e8e3Wh>tD3kC%C~_S z2;@nUE{4N!AVDW>56s~IRh0AS)i-0v@GzTT0%U?vf4Fzz|90(~L8qV8S))D z?vWemkyMY1lj#(r_(n=i@oUlL7Mj|sOic^GzoHE#rln?4LZIfi(0B~PxTr3D`ufbn z;FRa+vrNQ5w6Cs=ar?~q^XIqwd6~CI>~NS58K~KFw)zI~qHXNyGRDZOl+c504$SQmJl~*!aWc4n`Ssd`}Oq*E-sa@du_UxpxQ)?mUfem}@0 zC4M`A|qsb9NyebB>r3kMg$2Ihhy?397~569<{&a={`8ENGlm$=P&+ z>#b&uYaVWBN;RzLQ#tv#MH)+##?Cr1lHiX%{&Qh|TNouVP1NX*?dVC;?60TD`kUj7 zY9PYzX#jyLT3%G8Qsz-ku4X}8hC#Nm4iAPzA#>nN&P9!mtzLcIwe}gckFqKZO@~E? z+e~BrflMl_G9)h}<0is{YX|@YYV$-TzaZz(2V2?LArGXVjDr-H^cqrIPGu$3?&x(h zvdmIF=lV8zF?=4O)9bKtv_|r+J0LS8|E0#9FmYvT*R;V-s;@bN(qNoGEt&{Bp=#2B za%@z8I(6pU{nqZI!){J_IR$crRXN|*logdTcgeL$mk%{9I~-E9w`4MHx~5sdCvFAA z2* zK+2xK|M=tX^|7lzU0J|i<)+;^-F#E&i<~}He9W)M&-Vc99SNOBcPjKP=` zs6z16*DfD4$@2e3ou$|}Fink|7Q;sMHY{@vrPpK32+Fim{4pMry~=`8Ruyk@_Pq62 z^K!WQv)ji7k0!(}T!)dBeJ}C%&pWUCXJuy8mWx$0FUE_)Oo-&K3|W^3H`%8%#{3Re zGw=K>qH5OTmfw#%o;KR@njzihzjEW-ULkKZ{jtgh^L5|f*!c^~7XE){Dv{6oWnX{f zyViVpIv)8?smgzh9G%_M^Dp?doAG&9kZ+ziaU#dr(=(g`0x~N4g3}*yozH_aPL{nE zW&I+E+aQU@<~*8K4Pr_47VEMVOH@>vroqqz6}pUDO6(B`U=#9?q}JuveBWPw&VJ=; zww?esn}IZGk_~GJP2!`&6;Fp@fbWO4VOn|ih!G=j@2%Of!z1$khmg|%H#d5@n&0K> z&xCZJ(9c@%wPJD6S(wey>}18K4!-$*6Cq1EL+8b2d}x0C%qgf4m!Z7hV8Fg$H!NLM zv9?(jFHy?_QD$p8Lj}|HqA#D=_#i6z=#8ki5;M*Y5@R`=KICC*?bpWhE+JVWGhi`J*8_PCKZ zrxN_I90{lFHc)2Gh?PRw7V@<8a0T|dj`qGs+oZw)NePS2!wFfCJeuemq&Y;!)*r+W ziYd2N`h7+YY4nX0?8te<*6W5LK24*9!lrbtMM(;R2zAcM5p6t*2+wiIn?^QHS#J|N z`Rbg<=rPRmd10u?u8*y?%u?iB9`>^HtPOw3uDreldeEDTEAUC$99DJ7aFq8Hi8~R; zjYkyOF)|lT&uT>?XS8^|#gN?!oLhH&Zb}MseMLS}V8}k>dCm_6(-h2z;Cj9NZ~&T% z=TjH_EyqF27sD5RM$?2BxWB$6Sh*AWnVVOyZUU?JdywHK13k(RgAq7*wM2;>vqI)5 zTGT$iK>6Y4qR_(h_P-~gDFvlhs?Tf*(P-=PXo6uS_gQy^`IAQpIiAKvr59PQ#DIu&KPd0FxMYSr2uQ*Aim5pf!YePe>9WlH#fpR3bLnoudaji9J2 zMJeV^-`Be7oPM;M-5fgK)tE`0!)AmV-aeIk-pR@G*=@SbFImoHyuX{hn-n;Ndap9b zu9x)yJD|xxtWK@0o#bDLU4hS6W8j@xtLxm(J^Zd1^IC+9h*h43fLiK^)9L9Q(u-d) zKlIZ+d||M)TlM3$lj_jX;I3Lg0WuqHXG0^vzI|!SAJ}V_8$99*#LRQ1wtf~u<7z?d z*WG+tt2R!3e))Kk&Cz&ulm1_@Z1+y8A9Nux({kti-r~CD{)SPD!V5<%sg%Y7NBz={?$F3@2gBmtC@2W0TcAR6k(84T zO2Tk-OZz2KV0z4b+;>VE(z=xYg0#wxpL{Z&J**kL(^3y9DwQoupJt}7FYO7V$kNae zh*=D|36DdMoP}80#*-==wuA~i7EO`+L*Wc2J=s1JHMi0%!Mn)++I=qDvJK`OuN>aF z2oze=y_877wql;5iQsB(Sz!msyyZetI%V|ML2PXInevb)G>tE(DoLmwJ5D;Ukj5iE zQZT%dy7(oTz8XWcU+Huv$VOL19AdkbH_I&Qro0h7TF!snFR36_zJkGavUx#XePPtc zHkpRkPd1Q9LK1bJefrcdBTMorR2#TOo{TQu8k^R5O6y;qgUMDWkE*^g!hghOcW4`R z=hvCQ>;@w%bN9yP=2c>q!C0)5DN=&VNU0JW<*J=U_6JnJTW5jaERPS>~X z0VXh*zOCKp7Qa2XFB<1Edg?sB*oRQq}t|M=F3^t>ctip*Wp-Gc(Q&){gWze+6`p5(CYoQ zNpI-Hu1>tPazI3fBuCiAu(Yw9?@fio?~o5deG{w>8#U%n#!+#r*Je zqPh%gR}wzr;84y+sjI{}^W-{oeRAhJF?onGh8Cxj4p$CL4d*@({7kbDJnHOAx2PY_ zerNS&$KUAmc_6k!56r%~+DT3n&C8bZ;ZRvoCt5-W^i^pO*qk+F0x3HN+P`^snCi-R zQeG5wls3DxDcIUL>J_A`dX6~|rgrJP>ma7Ys01}1L+pS3q4>I#-yfg^Clitn)dx+X z(ACbp=VQL7)>bX*eZM4gZEAVhJyOXs_DH%+8D{{(*ugMW1y7*j5wVBN>*UY%d>`HZ zBVsS{Y!i!;l+jcwoY3#i@%LbK*f>x;?V+=o!_m-)LgLim+BJxUHK$jvY+i1z)aKv+ z_@y^(C%L}ya55cnZ!b?6zQ?!}pNT4E9eMoQqSi2{H$AgTIsSEJ5vAeiEopZPnbtpt zM? zhLn{Na~<9K!S~)A|G_hzQvAA@Z)+(?4pLG1^SUu|VJZ1diX-l|`=w53t9O>|BdKK@ zE(Fc_VbJt7-=U=&^USx`3fb)swLXFiRUQFgvLf{W$j*!Np=r@*Y((9w?0p4O?ORhL zl*vWe5Y^LK%`D81C#1K?v*~zcvn<^AkHjKGd=ZAx>=N4e%Cy zeeAk(DK({D!aA-v0iF>ZUZWye`7EXEz1`1(l|Rq<^DutU>gMJT{_KjY{zKAP;`3RQ zf3fu+ANJZe!~2=T&HipFtV&;Q8)aDr|08B{_#bOi`Dpf6R#kVirOQpsEsOGLYW@Hh z?fdju46L|`TI*S8leG;4WIpWJ#`;T4WTr14{#fa)q*m4gJIBxLcemiT&yPj>R*0%( z*E!JG@4b;P_(*f0B%3CkoL(FwFSsGlrSr_0GwyEsE#ugCKe~NbwOL@+fgkMtzkcO$ zA2Zj&=N-$1`mFoE%l`iBnJLyo`Bpk)CHSD{K7(vW+CXOTk)kMMUEzd6sR`qyZGW|@ zH9DaEm3JCx)dBPdZs}e{dLt}mplXA?z3;m$eq+|ggMpb)1#-8j9^;s5Mf=R_Zo?8Q zR*+6Cc6jyLzuWj$toMzF996YTM?Y=Kl#>t2?@synXtXcuUk9jYGtNB?r9|`Tf<{I; zRMS4OxiS60+!<97aAHh7L(aSiZL&DohPT2VsKN62m>0#C6fnwn2mvhpsqB#2wpw(o zJ`6&io!3j-z1MdBLbW}?o3#Zv}G#rz9+VIFNQHDjS`o=AIj20M>GeHr=&?P?V62zeo`>`}Dm0ItHgxafzW@IF>Qu0{biUU>{|hedZQfzwqRvMG zlL{d>su+16ARi1L-<`*-a1;^Z@-f73RtJdjom92PtnUw2oGssn9`K_N79CqY=0;Lb z#iRubI-jeYRD^Tj>s6>YXS?9eTEgR6lZ#<%sKF@2lM&bISKU<_9Zyqn^umP;%g1zP zoJV)GY>T-TAA!m*Fl?df=*|u`>8%>GzMRx0p1o%G)AIHu*9!~%PIx@DOC)FOPCrr2 z^-hgPVe?L%I+N|XF#0rq-oWVXoUgnEGDh2qdUL4=DjQX#B@b`wk=BB%hvDNo{CteH zD?LTMQ)sN~SM={u^TC`+9Xv0N^yVTa&f9bSx8D|{b8*gpF?n=xSFg#XpvpD4b;of& z_MHDipNz5$0{+`j!i?g3UwKG{lCq)el&kZnf)0BwdA({S->&h>qp5f5;nnY|dM>S? zWnKU(QSa2cwr+i6PW*77b%&rVG(R;2K4@fV4SIwjZ$v%&cE85LC-rAFbu-rd2V=Tw(R5&zJ>n zK2ILr`4_4Vox6B<|I!RomLdyUw}$gLqw(S36*+ zI##b@-Dup*8E%RG4UH-cr+r$v^Y?s(57_?j3_SH12Tf!%@w3#8 z=|o=lb@8nSeHF97v;xge;|?Sxx1Tw4-OUVPRc0?<*YbAvetIFJBBPuF2XF1oPp4c> zXqQyPQjgH&4V0F%LrYH_J(ismY4F1*Cukc2ZjDQ(r!a;nH?TE!eM8eOU7iNsUmd`^9?edg*j>nBE(P*x1Fb@r zlm{~(uDh0j$~QzpWb~_d-h6NO+3ciAd1upDvxBHHW5Ibk{KG3( zs`?HW+e9T>O`Q@=5xe{zr4$PEly>xuH%$0r(_YoZp69T;w0uQJtoWZTB^jhUpg}*9 zkaTQdB+Q66)LnvV-0U2I%hGrDUHj6QArx@3^ciW0Qov+%PYJ=%XejB=47rqQ``p%l z7NIH;pENV?~;_YPJ&3 z`G*^M<^L(j4J|!(^i+0I(R1QgIOWQf1Jd3+(Je{WtG!GR#qH9AturwI;03pdc%f=l zt`O>A1 z@6kt&{>*nMtSGpCePxb+>S)dx_y*>gc3B>d%eEHXdo}oUqFd>tqNHN?M&qoiuIJ`g$5_|iP@|&k zN=5R9os3VZcj_XrR;VAzOs7whm3R%VjwN_JXE+z}8gI{e(ls#_6H@B(G2t9e_CaKM zu?y1)X4L%fciXm|_pt`Mv&C>kqwk%H1U$aRyVmcr*|n{I>Lg=;*IfGT+UNyt`w*rs zFkIJ>m2!*fk=O6sIr+h>3p%q#iuj?Nj5JG2#7_HxKdt51oy_xeehrrGm%g3;IE{2x#@+CO4sxug%XNnU>KHeWheZ{(U z+6y1pjAlImZt_wL!p8y22?!vCRh7>2F@4sxxmHx^$Id4LlZxmTDzlSvY{H?` zWJRTUQLw}_XUDy#jhKT@-+dKm3Simou4z7{-WhpqGsyAuEg+J-J@Sn1U@s9}IbS}a zhPExFp4fQJwN=u_PHxckKl91?f3mq2^(O=?zs?-OT6=ogqhPp;3Z|xMF|hha?8NOL z$*L?mHi|m5I^@y;r*0=+I!kSZJA$IjP=nRomQ#>WtWQ6EJYw!EGe65HOS-(6=__ry zlRcKy9NW_d&)O0`a}9w1b`Z9nJ#E-lRu@(NFo7G$<<|ReY*_u>cSpTUV#jw8B*ee> zVqF)`VN57zwh?O5|L|PDEgWauM~a2n;e5&CRH73jua&m*YQP4ak5>OU!Q-R#t)_T; zx5FW}n9#uM#B#Y`%FeCY{b-xTPyy9N-1R5#K<~rA>+p}MygIeog&f@mHJ&G$p&C3V z-8objqur<}#IxNOH@d(vS^ndVR5ngj+v%_rex+k$epNwbMct;QF{RI`M>FS!ZZ z(6!%w8}+cP>?6>EdR7Uwx%XMH24tT3@~We#tJ^S*Z`8{#zg!*fN!^*pYTrzY4w&64 zexA?G(suXM06yb?+ceGg{hv3WW)}DzS{V{9Pku?4PJIooRv=rcB}sdJr4j5v{4rpy z*=@SNl0{wI=@GS}LK~4_Ulu1ia>82=%##pjI?Eow1{9;%%yri04%GTxHf!1u#Ux4j z0PYtC8L3DX_$7(eJTe8*bI%o)L!%dhb|RPJ-u?0YyLb7BD=@Ahq@7~g2tNp$;UMyBdEgYU1}7O%oPR|^SqMnY zEZ2}j3DR*qiN)Yo+Kd{7-$+tcrB0XON{Q#+Qadu*Y6qEWw<(-zWPeDs@##^liQ@V+ zq08ePJ4`uTzH>I0Oi9xcGcpB0bMR*8g>ChI`ec?$8KlE}@e8QTG$CAB?-I*{DtV*A zQgjYdV=CQui*SY-xsHOZ_kPpCRiFwG~Q8Al>a& z#ijUt%eTdKS$e%|mL}t`fA|2E;rxzZm@CD?fJH^yqfjpuiqTF zJ+fhwYNNiYv^aRrYe!Bd|G4S=fw!CO{o)Iolc}BCImZPqTD!hO-d&tP&=le3mY|Tc&w)lDw?~U z8aHTgw5JVSR9m3Fk_)Z}XWxv+)8zBw2)6G_si~>=9~~S!c5HW31|rGBr8fY$LwD>r zv-3eozEd=cng*wa$9bQceAd^&u>S1XJ}D_F*FQRQ?wqaZEXPIpxv+?c_A}zMUanLr zfFttpl9C4x{Q23^R*P1OeGFPLXvipeUehD$-#KvLdBWWnr7q zB2`0Gkhb7dJ`7sZq%43!nZWpwArr*8im*uliwJ4CZLt*QSm#PXz#(F_xbymhPx}Lw z@Cj~vFK^!aKF@QWbI#+b=p3md;>f6v@#WIaE!neuLBYXK=&Y=)+X#aBevQ~7QrQ}c zlD+5c3sl_wi?j_TP)ZXP*uFzV$|9HVkw{u}dcErW`7zIL;YAMarXR~{wKDGC?&|8p zJ17~(@rwNMB4+!5bJaaE6{Xx98VY|*W=RjEV#yF1&fX#9IqZ19nqIf{m(aup7Tt~mp`l4iZgTR<$?GVP5CeB@Fw35c?{sw$dO_({Sv~Tbec`yuTd|X9 zCJ}p_e<3y30gu2)3Wq`{Kv9kz{AWVrK-%ULlWIcr2K8Ka{tYT;>s#zWV5O1nc{j^Z z<~nHntJrLhz#-qFXlLngCaq@qY?Uq!+0W-LPUPfu$Bd^1i9vJHoJhIltk(mzS3l_PIkG+}=I##OWmnG^d|rCg>wNpC1}>na(wh&wSF8 z$m0=>J!#UC%)`ghXTP&8%WJ3AqXg^J_PR-8`Br9Dp zXLP07$}ph-uj4jDU*BZ+FOLf{hkEDaBBAhep|B2x+|p&sg468iY+!H`lNm!yA^>QD zuN=V20@1WVupf30$_mhW-Lm8m3f5>eNgsX}O+0$>8t(<##Q)o*@|4G}>`;GCEt>cBJ?dkN+0z*l|XVx>qf9 zY7rp5x@s09%0NZ$C|Hro<@4`~e10l3W&vSreX2K^s&U-7nfVNA_CjB~7g^S3Feu5e zD%1m{i<6mot+=?Dly;~zXT3^Ps!Gs?>YAFk*x*LYKJ3R{2E|4@GSy{0x;8ji9AP{j zvJx4b(mZYeXPbN!gxXuS3@v`FM{PKpv^_mEL~dkEVMj+~c;>_HMMXsj2<;7nd1RQ7 zS{;E{j;AdqDs{jOSFT*Csj7)zq&^77n`e_$-OY+2}Q;QYXAXuBckl?5Qh z^O%R#4~)Ht>d>E{vIOlP-GE Oy=Cp-Y_I<`<`J}nLed^?~MGMw0U}Ixj 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

h+B6};kU5*gH8a=PtJg&^ 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 Bl}i8s literal 0 HcmV?d00001 diff --git a/proyecto-final/requirements.txt b/proyecto-final/requirements.txt new file mode 100644 index 0000000..76f7ed4 --- /dev/null +++ b/proyecto-final/requirements.txt @@ -0,0 +1,9 @@ +pandas +numpy +scikit-learn +xgboost +matplotlib +seaborn +ucimlrepo +tensorflow +jupyter diff --git a/proyecto-final/src/utils.py b/proyecto-final/src/utils.py new file mode 100644 index 0000000..ffe56ed --- /dev/null +++ b/proyecto-final/src/utils.py @@ -0,0 +1,57 @@ +import os +import pandas as pd +import matplotlib.pyplot as plt +from sklearn.metrics import precision_score, recall_score, f1_score, accuracy_score + +BITACORA = os.path.join(os.path.dirname(__file__), '..', 'outputs', 'bitacora_experimentos.csv') +FIGURES_PATH = os.path.join(os.path.dirname(__file__), '..', 'outputs', 'figures') + + +def metricas(y_true, y_pred, sufijo): + """Calcula precision, recall, f1 y accuracy (macro) para un split.""" + return { + f'precision_{sufijo}': precision_score(y_true, y_pred, average='macro', zero_division=0), + f'recall_{sufijo}': recall_score(y_true, y_pred, average='macro', zero_division=0), + f'f1_{sufijo}': f1_score(y_true, y_pred, average='macro', zero_division=0), + f'accuracy_{sufijo}': accuracy_score(y_true, y_pred), + } + + +def registrar(exp_id, modelo, hiperparams, arquitectura, model, X_train, y_train, X_test, y_test): + """Append de una fila de experimento a la bitácora CSV.""" + fila = { + 'experimento_id': exp_id, + 'modelo': modelo, + 'hiperparametros': str(hiperparams), + 'arquitectura': arquitectura, + } + fila.update(metricas(y_train, model.predict(X_train), 'train')) + fila.update(metricas(y_test, model.predict(X_test), 'test')) + + path = os.path.abspath(BITACORA) + os.makedirs(os.path.dirname(path), exist_ok=True) + write_header = not os.path.exists(path) + pd.DataFrame([fila]).to_csv(path, mode='a', header=write_header, index=False) + print(f"[bitacora] {modelo} | {exp_id} | F1 test={fila['f1_test']:.4f}") + + +def plot_importancia(model, feature_names, titulo, top_n=16, save=True): + """Barplot horizontal de feature importances ordenado descendentemente.""" + importancias = pd.Series(model.feature_importances_, index=feature_names) + importancias = importancias.nlargest(top_n).sort_values() + + fig, ax = plt.subplots(figsize=(8, max(4, top_n * 0.4))) + importancias.plot(kind='barh', ax=ax) + ax.set_title(titulo) + ax.set_xlabel('Importancia') + plt.tight_layout() + + if save: + os.makedirs(os.path.abspath(FIGURES_PATH), exist_ok=True) + filename = titulo.lower().replace(' ', '_').replace('—', '').replace('/', '_').strip('_') + '.png' + path = os.path.join(os.path.abspath(FIGURES_PATH), filename) + fig.savefig(path, dpi=150) + print(f"[figura] guardada en {path}") + + plt.show() + return importancias