diff --git a/M2/Machine Learning/TP_4/2025_M2_ISF_TP_4.ipynb b/M2/Machine Learning/TP_4/2025_M2_ISF_TP_4.ipynb
index 4fcd6a1..783c0a8 100644
--- a/M2/Machine Learning/TP_4/2025_M2_ISF_TP_4.ipynb	
+++ b/M2/Machine Learning/TP_4/2025_M2_ISF_TP_4.ipynb	
@@ -45,7 +45,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 102,
+   "execution_count": null,
    "id": "97d58527",
    "metadata": {},
    "outputs": [],
@@ -70,7 +70,6 @@
     "from sklearn.ensemble import GradientBoostingClassifier\n",
     "from sklearn.model_selection import (\n",
     "  GridSearchCV,\n",
-    "  KFold,\n",
     "  StratifiedKFold,\n",
     "  cross_val_score,\n",
     "  train_test_split,\n",
@@ -17781,7 +17780,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 121,
+   "execution_count": null,
    "id": "cb60fe19",
    "metadata": {},
    "outputs": [],
@@ -17793,10 +17792,7 @@
     "}\n",
     "\n",
     "# Nombre de folds pour la validation croisée\n",
-    "num_folds = 5\n",
-    "\n",
-    "# Initialisation du modèle GradientBoostingClassifier\n",
-    "gb = GradientBoostingClassifier(random_state=42)"
+    "num_folds = 5"
    ]
   },
   {
diff --git a/M2/Machine Learning/TP_5/2025_M2_ISF_TP_5.ipynb b/M2/Machine Learning/TP_5/2025_M2_ISF_TP_5.ipynb
new file mode 100644
index 0000000..9075d5a
--- /dev/null
+++ b/M2/Machine Learning/TP_5/2025_M2_ISF_TP_5.ipynb	
@@ -0,0 +1,4855 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "d1317e8c",
+   "metadata": {},
+   "source": [
+    "# Cours 5 : Machine Learning - Algorithme CATBOOST"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0bb8268a",
+   "metadata": {},
+   "source": [
+    "# Préambule"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9ffe2699",
+   "metadata": {},
+   "source": [
+    "Objectifs du cours :\n",
+    "1. Comprendre les spécificités de CatBoost vs XGBoost et Random Forest\n",
+    "2. Maîtriser le traitement des variables catégorielles\n",
+    "3. Optimiser les hyperparamètres\n",
+    "4. Appliquer CatBoost à un problème de classification financière"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "666d94aa",
+   "metadata": {},
+   "source": [
+    "# Partie 1 : Introduction théorique"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e05ef8b4",
+   "metadata": {},
+   "source": [
+    "## 1.1 CatBoost : Categorical Boosting\n",
+    "\n",
+    "### Rappel : Gradient Boosting\n",
+    "- Vous avez vu XGBoost : optimisation de la fonction de cout en corrigeant de manière récurrente \n",
+    "- CatBoost est aussi un algorithme de gradient boosting, mais avec des innovations :\n",
+    "\n",
+    "### Trois innovations majeures de CatBoost :\n",
+    "1. **Ordered Boosting**\n",
+    "   - XGBoost/LightGBM : peuvent souffrir de \"prediction shift\" (overfitting sur train)\n",
+    "   - CatBoost utilise un ordre aléatoire différent pour chaque arbre\n",
+    "   - Réduit le risque d'overfitting naturellement   \n",
+    "2. **Gestion native des variables catégorielles**\n",
+    "   - Pas besoin de One-Hot Encoding ou Label Encoding manuel\n",
+    "   - Utilise \"Ordered Target Statistics\" pour encoder les catégories\n",
+    "   - Évite le target leakage grâce à l'ordered boosting\n",
+    "3. **Arbres symétriques (Oblivious Trees)**\n",
+    "   - Même condition de split à chaque niveau\n",
+    "   - Plus rapide en prédiction\n",
+    "   - Régularisation naturelle\n",
+    "\n",
+    "### Quand utiliser CatBoost ?\n",
+    "* Nombreuses variables catégorielles  \n",
+    "* Dataset de taille moyenne à grande  \n",
+    "* Besoin de robustesse sans trop de tuning  \n",
+    "* Problèmes de classification ou régression  \n",
+    "\n",
+    "### CatBoost vs XGBoost vs Random Forest\n",
+    "| Critère | CatBoost | XGBoost | Random Forest |\n",
+    "|---------|----------|---------|---------------|\n",
+    "| Variables catégorielles |  Natif |  Preprocessing |  Preprocessing |\n",
+    "| Vitesse d'entraînement | Moyen | Rapide | Très rapide |\n",
+    "| Overfitting | Faible | Moyen | Faible |\n",
+    "| Tuning requis | Minimal | Important | Minimal |\n",
+    "| Interprétabilité | Bonne | Bonne | Moyenne |\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7def124e",
+   "metadata": {},
+   "source": [
+    "# Partie 2 : Mise en pratique - Prédiction de défaut de crédit"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9ce8ff5c",
+   "metadata": {},
+   "source": [
+    "## Préparation du workspace"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8188cb04",
+   "metadata": {},
+   "source": [
+    "### Import de librairies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "id": "e3d8e095",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import warnings\n",
+    "from io import StringIO\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import requests\n",
+    "import seaborn as sns\n",
+    "from catboost import CatBoostClassifier, Pool\n",
+    "from sklearn.metrics import (\n",
+    "    classification_report,\n",
+    "    confusion_matrix,\n",
+    "    roc_auc_score,\n",
+    "    roc_curve,\n",
+    ")\n",
+    "from sklearn.model_selection import GridSearchCV, KFold, train_test_split\n",
+    "\n",
+    "warnings.filterwarnings('ignore')\n",
+    "\n",
+    "# Configuration des graphiques\n",
+    "plt.style.use('seaborn-v0_8-darkgrid')\n",
+    "sns.set_palette(\"husl\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1919e0ae",
+   "metadata": {},
+   "source": [
+    "### Import des données"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "id": "1bbb653c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "=== Chargement du dataset Adult Income ===\n",
+      "\n",
+      "Dataset classique de Kaggle/UCI qui illustre parfaitement les forces de CatBoost\n",
+      "Objectif : Prédire si le revenu annuel > 50K$ basé sur des caractéristiques socio-démographiques\n",
+      "\n",
+      "Dataset chargé depuis UCI repository\n"
+     ]
+    }
+   ],
+   "source": [
+    "## Chargement du dataset Adult Income (Census)\n",
+    "\n",
+    "print(\"=== Chargement du dataset Adult Income ===\\n\")\n",
+    "print(\"Dataset classique de Kaggle/UCI qui illustre parfaitement les forces de CatBoost\")\n",
+    "print(\"Objectif : Prédire si le revenu annuel > 50K$ basé sur des caractéristiques socio-démographiques\\n\")\n",
+    "\n",
+    "# Chargement depuis UCI\n",
+    "url = \"https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data\"\n",
+    "\n",
+    "column_names = [\n",
+    "    'age', 'workclass', 'fnlwgt', 'education', 'education_num',\n",
+    "    'marital_status', 'occupation', 'relationship', 'race', 'sex',\n",
+    "    'capital_gain', 'capital_loss', 'hours_per_week', 'native_country', 'income'\n",
+    "]\n",
+    "\n",
+    "try:\n",
+    "    df = pd.read_csv(url, names=column_names, sep=r',\\s*', engine='python', na_values='?')\n",
+    "    print(\"Dataset chargé depuis UCI repository\")\n",
+    "except:  # noqa: E722\n",
+    "    print(\"Impossible de charger depuis UCI, création d'un dataset simulé similaire...\")\n",
+    "    # Fallback : créer un dataset similaire\n",
+    "    np.random.seed(42)\n",
+    "    n_samples = 32561\n",
+    "\n",
+    "    df = pd.DataFrame({\n",
+    "        'age': np.random.randint(17, 90, n_samples),\n",
+    "        'workclass': np.random.choice(['Private', 'Self-emp-not-inc', 'Local-gov', 'State-gov', 'Self-emp-inc',\n",
+    "                                       'Federal-gov', 'Without-pay'], n_samples, p=[0.73, 0.08, 0.06, 0.04, 0.03, 0.03, 0.03]),\n",
+    "        'fnlwgt': np.random.randint(12285, 1484705, n_samples),\n",
+    "        'education': np.random.choice(\n",
+    "            ['HS-grad', 'Some-college', 'Bachelors', 'Masters', 'Assoc-voc',\n",
+    "                                       'Doctorate', '11th', '9th', '7th-8th'], n_samples,\n",
+    "                                      p=[0.32, 0.22, 0.16, 0.05, 0.04, 0.01, 0.04, 0.03, 0.13]),\n",
+    "        'education_num': np.random.randint(1, 16, n_samples),\n",
+    "        'marital_status': np.random.choice(['Married-civ-spouse', 'Never-married', 'Divorced', 'Separated',\n",
+    "                                            'Widowed'], n_samples, p=[0.46, 0.33, 0.14, 0.03, 0.04]),\n",
+    "        'occupation': np.random.choice(['Prof-specialty', 'Craft-repair', 'Exec-managerial', 'Adm-clerical',\n",
+    "                                        'Sales', 'Other-service', 'Machine-op-inspct', 'Tech-support'], n_samples,\n",
+    "                                       p=[0.13, 0.13, 0.13, 0.12, 0.11, 0.10, 0.06, 0.22]),\n",
+    "        'relationship': np.random.choice(['Husband', 'Not-in-family', 'Own-child', 'Unmarried', 'Wife', 'Other-relative'],\n",
+    "                                         n_samples, p=[0.40, 0.26, 0.16, 0.10, 0.05, 0.03]),\n",
+    "        'race': np.random.choice(['White', 'Black', 'Asian-Pac-Islander', 'Amer-Indian-Eskimo', 'Other'],\n",
+    "                                 n_samples, p=[0.85, 0.10, 0.03, 0.01, 0.01]),\n",
+    "        'sex': np.random.choice(['Male', 'Female'], n_samples, p=[0.67, 0.33]),\n",
+    "        'capital_gain': np.where(np.random.random(n_samples) < 0.92, 0, np.random.randint(1, 99999, n_samples)),\n",
+    "        'capital_loss': np.where(np.random.random(n_samples) < 0.95, 0, np.random.randint(1, 4356, n_samples)),\n",
+    "        'hours_per_week': np.random.randint(1, 99, n_samples),\n",
+    "        'native_country': np.random.choice(['United-States', 'Mexico', 'Philippines', 'Germany', 'Canada',\n",
+    "                                            'India', 'Other'], n_samples, p=[0.90, 0.02, 0.01, 0.01, 0.01, 0.01, 0.04])\n",
+    "    })\n",
+    "\n",
+    "    # Création de la cible avec logique réaliste\n",
+    "    income_score = (\n",
+    "        (df['age'] > 35).astype(int) * 20 +\n",
+    "        (df['education_num'] > 12).astype(int) * 30 +\n",
+    "        (df['hours_per_week'] > 40).astype(int) * 15 +\n",
+    "        (df['capital_gain'] > 0).astype(int) * 25 +\n",
+    "        (df['marital_status'] == 'Married-civ-spouse').astype(int) * 20 +\n",
+    "        (df['occupation'].isin(['Exec-managerial', 'Prof-specialty'])).astype(int) * 15 +\n",
+    "        np.random.normal(0, 15, n_samples)\n",
+    "    )\n",
+    "    df['income'] = (income_score > 60).map({True: '>50K', False: '<=50K'})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a68d80f3",
+   "metadata": {},
+   "source": [
+    "### Première visualisation des données"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "id": "bc254063",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      " Shape du dataset : (32561, 15)\n",
+      " Nombre de features : 14\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"\\n Shape du dataset : {df.shape}\")\n",
+    "print(f\" Nombre de features : {df.shape[1] - 1}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "id": "94727394",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      " Valeurs manquantes :\n",
+      "workclass         1836\n",
+      "occupation        1843\n",
+      "native_country     583\n",
+      "dtype: int64\n",
+      " Dataset nettoyé : (30162, 15)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Nettoyage des valeurs manquantes\n",
+    "print(\"\\n Valeurs manquantes :\")\n",
+    "print(df.isnull().sum()[df.isnull().sum() > 0])\n",
+    "\n",
+    "# Suppression des lignes avec valeurs manquantes (peu nombreuses)\n",
+    "df = df.dropna()\n",
+    "print(f\" Dataset nettoyé : {df.shape}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "id": "e7685461",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      " Distribution de la cible (income) :\n",
+      "income\n",
+      "<=50K    22654\n",
+      ">50K      7508\n",
+      "Name: count, dtype: int64\n",
+      "income\n",
+      "<=50K    0.751078\n",
+      ">50K     0.248922\n",
+      "Name: proportion, dtype: float64\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"\\n Distribution de la cible (income) :\")\n",
+    "print(df[\"income\"].value_counts())\n",
+    "print(df[\"income\"].value_counts(normalize=True))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "id": "647df2e7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      " Premières lignes :\n",
+      "   age         workclass  fnlwgt  education  education_num  \\\n",
+      "0   39         State-gov   77516  Bachelors             13   \n",
+      "1   50  Self-emp-not-inc   83311  Bachelors             13   \n",
+      "2   38           Private  215646    HS-grad              9   \n",
+      "3   53           Private  234721       11th              7   \n",
+      "4   28           Private  338409  Bachelors             13   \n",
+      "\n",
+      "       marital_status         occupation   relationship   race     sex  \\\n",
+      "0       Never-married       Adm-clerical  Not-in-family  White    Male   \n",
+      "1  Married-civ-spouse    Exec-managerial        Husband  White    Male   \n",
+      "2            Divorced  Handlers-cleaners  Not-in-family  White    Male   \n",
+      "3  Married-civ-spouse  Handlers-cleaners        Husband  Black    Male   \n",
+      "4  Married-civ-spouse     Prof-specialty           Wife  Black  Female   \n",
+      "\n",
+      "   capital_gain  capital_loss  hours_per_week native_country income  \n",
+      "0          2174             0              40  United-States  <=50K  \n",
+      "1             0             0              13  United-States  <=50K  \n",
+      "2             0             0              40  United-States  <=50K  \n",
+      "3             0             0              40  United-States  <=50K  \n",
+      "4             0             0              40           Cuba  <=50K  \n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"\\n Premières lignes :\\n{df.head()}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "id": "8f65e4b1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Encodage de la cible en 0/1\n",
+    "df['income'] = (df['income'] == '>50K').astype(int)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "id": "04bbcd27",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      " Types de données :\n",
+      "age                int64\n",
+      "workclass         object\n",
+      "fnlwgt             int64\n",
+      "education         object\n",
+      "education_num      int64\n",
+      "marital_status    object\n",
+      "occupation        object\n",
+      "relationship      object\n",
+      "race              object\n",
+      "sex               object\n",
+      "capital_gain       int64\n",
+      "capital_loss       int64\n",
+      "hours_per_week     int64\n",
+      "native_country    object\n",
+      "income             int64\n",
+      "dtype: object\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"\\n Types de données :\\n{df.dtypes}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "267aa325",
+   "metadata": {},
+   "source": [
+    "### Exploration rapide"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "id": "908f7dce",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Statistiques des variables numériques :\n",
+      "                age        fnlwgt  education_num  capital_gain  capital_loss  \\\n",
+      "count  30162.000000  3.016200e+04   30162.000000  30162.000000  30162.000000   \n",
+      "mean      38.437902  1.897938e+05      10.121312   1092.007858     88.372489   \n",
+      "std       13.134665  1.056530e+05       2.549995   7406.346497    404.298370   \n",
+      "min       17.000000  1.376900e+04       1.000000      0.000000      0.000000   \n",
+      "25%       28.000000  1.176272e+05       9.000000      0.000000      0.000000   \n",
+      "50%       37.000000  1.784250e+05      10.000000      0.000000      0.000000   \n",
+      "75%       47.000000  2.376285e+05      13.000000      0.000000      0.000000   \n",
+      "max       90.000000  1.484705e+06      16.000000  99999.000000   4356.000000   \n",
+      "\n",
+      "       hours_per_week  \n",
+      "count    30162.000000  \n",
+      "mean        40.931238  \n",
+      "std         11.979984  \n",
+      "min          1.000000  \n",
+      "25%         40.000000  \n",
+      "50%         40.000000  \n",
+      "75%         45.000000  \n",
+      "max         99.000000  \n"
+     ]
+    }
+   ],
+   "source": [
+    "# Statistiques descriptives\n",
+    "print(\"Statistiques des variables numériques :\")\n",
+    "numeric_features = [\n",
+    "    \"age\",\n",
+    "    \"fnlwgt\",\n",
+    "    \"education_num\",\n",
+    "    \"capital_gain\",\n",
+    "    \"capital_loss\",\n",
+    "    \"hours_per_week\",\n",
+    "]\n",
+    "print(df[numeric_features].describe())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "id": "bfe561fb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Variables catégorielles\n",
+    "cat_features = [\n",
+    "    \"workclass\",\n",
+    "    \"education\",\n",
+    "    \"marital_status\",\n",
+    "    \"occupation\",\n",
+    "    \"relationship\",\n",
+    "    \"race\",\n",
+    "    \"sex\",\n",
+    "    \"native_country\",\n",
+    "]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "id": "b52186fa",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      " Cardinalité des variables catégorielles :\n",
+      "   workclass: 7 catégories uniques\n",
+      "   education: 16 catégories uniques\n",
+      "   marital_status: 7 catégories uniques\n",
+      "   occupation: 14 catégories uniques\n",
+      "   relationship: 6 catégories uniques\n",
+      "   race: 5 catégories uniques\n",
+      "   sex: 2 catégories uniques\n",
+      "   native_country: 41 catégories uniques\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"\\n Cardinalité des variables catégorielles :\")\n",
+    "for col in cat_features:\n",
+    "    print(f\"   {col}: {df[col].nunique()} catégories uniques\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "id": "b4fca22b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      " Corrélations avec le revenu >50K :\n",
+      "education_num     0.335286\n",
+      "age               0.241998\n",
+      "hours_per_week    0.229480\n",
+      "capital_gain      0.221196\n",
+      "capital_loss      0.150053\n",
+      "fnlwgt           -0.008957\n",
+      "dtype: float64\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Corrélation avec la cible\n",
+    "print(\"\\n Corrélations avec le revenu >50K :\")\n",
+    "correlations = df[numeric_features].corrwith(df[\"income\"]).sort_values(ascending=False)\n",
+    "print(correlations)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "id": "f617c5aa",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1600x1000 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Visualisation\n",
+    "fig, axes = plt.subplots(2, 3, figsize=(16, 10))\n",
+    "\n",
+    "# Taux de revenu >50K par catégorie\n",
+    "df.groupby(\"education\")[\"income\"].mean().sort_values(ascending=False).plot(\n",
+    "    kind=\"barh\", ax=axes[0, 0], color=\"skyblue\"\n",
+    ")\n",
+    "axes[0, 0].set_title(\"Taux de revenu >50K par niveau d'éducation\")\n",
+    "axes[0, 0].set_xlabel(\"Taux\")\n",
+    "\n",
+    "df.groupby(\"occupation\")[\"income\"].mean().sort_values(ascending=False).plot(\n",
+    "    kind=\"barh\", ax=axes[0, 1], color=\"lightcoral\"\n",
+    ")\n",
+    "axes[0, 1].set_title(\"Taux de revenu >50K par occupation\")\n",
+    "axes[0, 1].set_xlabel(\"Taux\")\n",
+    "\n",
+    "df.groupby(\"marital_status\")[\"income\"].mean().sort_values(ascending=False).plot(\n",
+    "    kind=\"barh\", ax=axes[0, 2], color=\"lightgreen\"\n",
+    ")\n",
+    "axes[0, 2].set_title(\"Taux de revenu >50K par statut marital\")\n",
+    "axes[0, 2].set_xlabel(\"Taux\")\n",
+    "\n",
+    "# Distribution des variables numériques par revenu\n",
+    "df.boxplot(column=\"age\", by=\"income\", ax=axes[1, 0])\n",
+    "axes[1, 0].set_title(\"Âge par niveau de revenu\")\n",
+    "axes[1, 0].set_xlabel(\"Revenu >50K\")\n",
+    "\n",
+    "df.boxplot(column=\"hours_per_week\", by=\"income\", ax=axes[1, 1])\n",
+    "axes[1, 1].set_title(\"Heures travaillées par niveau de revenu\")\n",
+    "axes[1, 1].set_xlabel(\"Revenu >50K\")\n",
+    "\n",
+    "df.boxplot(column=\"education_num\", by=\"income\", ax=axes[1, 2])\n",
+    "axes[1, 2].set_title(\"Années d'éducation par niveau de revenu\")\n",
+    "axes[1, 2].set_xlabel(\"Revenu >50K\")\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dbd53154",
+   "metadata": {},
+   "source": [
+    "**Observations clés :**\n",
+    "* L'éducation a un fort impact sur le revenu\n",
+    "* Les personnes mariées ont des revenus plus élevés\n",
+    "* Certaines occupations (Exec-managerial, Prof-specialty) sont associées à des revenus >50K\n",
+    "* L'âge et les heures travaillées sont positivement corrélés au revenu"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b07b569d",
+   "metadata": {},
+   "source": [
+    "## Modélisation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8c37658c",
+   "metadata": {},
+   "source": [
+    "### Sampling"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "id": "96b98795",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "=== Préparation pour CatBoost ===\n",
+      "\n",
+      "Variables catégorielles : ['workclass', 'education', 'marital_status', 'occupation', 'relationship', 'race', 'sex', 'native_country']\n",
+      "Variables numériques : ['age', 'fnlwgt', 'education_num', 'capital_gain', 'capital_loss', 'hours_per_week']\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Identification des variables catégorielles\n",
+    "cat_features = [\n",
+    "    \"workclass\",\n",
+    "    \"education\",\n",
+    "    \"marital_status\",\n",
+    "    \"occupation\",\n",
+    "    \"relationship\",\n",
+    "    \"race\",\n",
+    "    \"sex\",\n",
+    "    \"native_country\",\n",
+    "]\n",
+    "\n",
+    "print(\"\\n=== Préparation pour CatBoost ===\\n\")\n",
+    "print(f\"Variables catégorielles : {cat_features}\")\n",
+    "print(f\"Variables numériques : {numeric_features}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "id": "344d3cab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Séparation features / target\n",
+    "X = df.drop(\"income\", axis=1)\n",
+    "y = df[\"income\"]\n",
+    "\n",
+    "# Split train/test stratifié\n",
+    "X_train, X_test, y_train, y_test = train_test_split(\n",
+    "    X, y, test_size=0.2, random_state=42, stratify=y\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "id": "9266362a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Taille train : (24129, 14) (6006 positifs)\n",
+      "Taille test : (6033, 14) (1502 positifs)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"\\nTaille train : {X_train.shape} ({len(y_train[y_train == 1])} positifs)\")\n",
+    "print(f\"Taille test : {X_test.shape} ({len(y_test[y_test == 1])} positifs)\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "id": "15ae5c81",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Création des Pools CatBoost (structure optimisée)\n",
+    "train_pool = Pool(X_train, y_train, cat_features=cat_features)\n",
+    "test_pool = Pool(X_test, y_test, cat_features=cat_features)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0cda3c3c",
+   "metadata": {},
+   "source": [
+    "### Algorithme supervisé : CatBoost  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 79,
+   "id": "4a9aa383",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Premier modèle CatBoost avec paramètres par défaut\n",
+    "# Initialisation\n",
+    "model_baseline = CatBoostClassifier(\n",
+    "    iterations=500,\n",
+    "    learning_rate=0.1,\n",
+    "    depth=6,\n",
+    "    loss_function=\"Logloss\",\n",
+    "    eval_metric=\"AUC\",\n",
+    "    random_seed=42,\n",
+    "    verbose=100,\n",
+    "    early_stopping_rounds=50,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 80,
+   "id": "ed755501",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0:\ttest: 0.8746563\tbest: 0.8746563 (0)\ttotal: 28.1ms\tremaining: 14s\n",
+      "100:\ttest: 0.9207882\tbest: 0.9207893 (99)\ttotal: 1.89s\tremaining: 7.48s\n",
+      "200:\ttest: 0.9248347\tbest: 0.9248575 (199)\ttotal: 3.28s\tremaining: 4.88s\n",
+      "Stopped by overfitting detector  (50 iterations wait)\n",
+      "\n",
+      "bestTest = 0.9249125201\n",
+      "bestIteration = 227\n",
+      "\n",
+      "Shrink model to first 228 iterations.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<catboost.core.CatBoostClassifier at 0x11abed130>"
+      ]
+     },
+     "execution_count": 80,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Entrainement\n",
+    "model_baseline.fit(train_pool, eval_set=test_pool, plot=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 81,
+   "id": "b62bc10b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Prédictions\n",
+    "y_pred_baseline = model_baseline.predict(X_test)\n",
+    "y_pred_proba_baseline = model_baseline.predict_proba(X_test)[:, 1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 82,
+   "id": "dbc909b3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "=== Performance du modèle baseline ===\n",
+      "\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.89      0.94      0.91      4531\n",
+      "           1       0.78      0.65      0.71      1502\n",
+      "\n",
+      "    accuracy                           0.87      6033\n",
+      "   macro avg       0.83      0.79      0.81      6033\n",
+      "weighted avg       0.86      0.87      0.86      6033\n",
+      "\n",
+      "\n",
+      "AUC-ROC : 0.9249\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Évaluation\n",
+    "print(\"\\n=== Performance du modèle baseline ===\\n\")\n",
+    "print(classification_report(y_test, y_pred_baseline))\n",
+    "print(f\"\\nAUC-ROC : {roc_auc_score(y_test, y_pred_proba_baseline):.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 83,
+   "id": "9a92a89d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoQAAAIcCAYAAABvgr9hAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAS1FJREFUeJzt3Qd4VVW6xvEvAVMAaSGUAIoU6SXSRaRIFwUEHUERBASEiAVQAyhdBhALRgQE6QOIiIOogOgMitIEIVSl9xI6CCSE5D7fcs65SXbQRHNykqz/7z7nSfZee++snHjH12+V4xMfHx8vAAAAsJavtzsAAAAA7yIQAgAAWI5ACAAAYDkCIQAAgOUIhAAAAJYjEAIAAFiOQAgAAGA5AiEAAIDlCIRAFsNe8wCA1CIQAumsc+fOUrZsWXn88cdvec2LL75ornn11VdT9exNmzZJz549//S69957zzzfG44ePWp+9qeffiqZRWxsrPlbhIaGyj333CPr1q1Lk+d68+8AAAllT3QEIF34+vrKli1b5OTJk1K4cOFEbVevXpX//Oc/f+m5ixYtkn379v3pdY8++qjUr1//L/0MG33//feyZMkS6dOnj9x7771SoUKFNHkufwcAGQUVQsALNFD4+/vL8uXLHW0aBgMDA6VQoUIe+/kaQqtVq+ax52c1Fy5cMF8feeQRqVmzpuTMmTNNnsvfAUBGQSAEvCBHjhzSoEGDZAPhl19+Kc2bN5fs2RMX8M+dOyfDhw+XRo0aSaVKlaRWrVrSt29fMwSrdEhTq1jHjh1zD8m6hmdnzJghLVq0kKpVq8rixYuTHar87LPPpF27duaahg0byoQJEyQmJsbd/uuvv0qvXr3MkKm+9GcfOXLkT3/XlStXysMPPyxVqlQxz9+9e3eygev111831bfKlSvLY489JmvXrv3TZ+/fv1/CwsLMe6FBTfuXsEJ6+fJlGTNmjDRp0sQ8t3Xr1vLJJ58kekbjxo1l4sSJMnbsWPPztZ/du3eXgwcPut9X19C9PkeH/G817K3X6fNcDh8+LL1795batWub9/Uf//iHrF692t2e3N9B//4aPHV4ul69euZ9uXjxYqJ7mjZtKv/973/loYceMv8s6D8v+vcDgL+KQAh4SatWrdzDxi5XrlyR7777zgSXpAtFNOz88MMPMmDAAJk+fboJQhqahg4daq7R4UwNmcHBwbJw4UIT6hKGiGeeeUbGjRtnQkZS8+bNk1deeUUqVqwoERERZh7inDlzZNSoUab9wIEDZs7j2bNnTXAaPXq0CYMdO3Y0527l22+/lX79+pnQ8/7770vLli1l4MCBia6Jjo6WLl26yDfffGPmTurP18pZjx49/jAUnjp1ygQsDW7Dhg2T8ePHy5kzZ8yzNGBev35dOnXqJJ9//rl51qRJk6R69eoyePBgmTx5cqJnzZ4924RLDY/6O2/fvt28H6739dlnnzXfa99c7/efiYuLM3+za9eumfddf37evHnNsw4dOpTsPXrNSy+9ZKqGGlI1dK9YscKEUP19XKKiomTEiBHy1FNPydSpU6VYsWKmvymZLgAAyWEOIeAlGth0aFirhF27djXnvv76awkKCjLBJaHTp0+ba/Vf+jVq1DDntOqkFSgNf+qOO+6Q/Pnzi5+fn3sYUucjKg1i7du3v2Vw0bCm1S9XAFQaZL744gu5ceOGCUL682fOnCm5cuUy7XXr1jX3TJs2zR2ektLnasVNw5pyzZfT6qPLv//9b1M1/Pjjj00VTd1///0mBL355pumopkc7YtWMLX6qSFYlStXzoTUrVu3mkqpVjUXLFhgqm2un68LRDR4acDVgKZy585tzmXLls0c6/uqIfr8+fPmfdWXKl++vAlfrqrsH9GgrCHTFdSVvhf6XiasvLpoFfCDDz4w1VGtCrrcfffd8sQTT5j3Qb+6/jYayvVvoEqUKGEqx1p9LFWq1J/2DQCSokIIeElAQIAZXkw4bKwBTMObj49Pomt1PqFWsTQoahjRSqFW8DZv3pxsuEhKg8ytaPVPw4sOQyakw6Y6JHrbbbeZVbU6LKt91kClLw2GGk5//PHHZJ+rFa0dO3aYoJKQ/n4JaRVQA51WJ13PvnnzprlPK3UJh0uTrqjW4OsKg0orizoHUwPYhg0bpGjRou4w6KLD11qV1NDoosPJrjDoeo4reP1VBQoUkNKlS8trr71mArNWKjV8h4eHS5kyZRzXa7VY/5ZJq8P6Huvvob9PQgnnHrr66/oPAABILSqEgBdpONKhXx021kUmGo5eeOGFZK9dunSpvPXWW3LixAlT2dKQpwEtpXMW/2zBhFYm/+gandumr6S0KpkcDXI61J0vX75E5wsWLOh4tg6BaiBMjrblyZMn2T5pte5W9OcnDIsJg5q6dOmS+5xWP5OuAlca4P4qDfUfffSRqfpp5Vfn+Gm41qqqzgVN+ju5gq+rf0n7rPMhE0rYZ1d/2YMSwF9FIAS8SIdGdcWqVgk1tGnA0UUCSf3000+myqTDqFq5c61A1rlpWin7O3S41LVoJSEdLt25c6epsN1+++1mwcXTTz/tuD/p4hcXDa0aVHReX3IB1EWfrUOeOjycnFuFPr0vaZ+Vhmq9RwNXcnP1NGCqpEE1NVwVXK1kJpS0Qqd/J53fqPMOdVhc/84ffvih+dlJ5yK6AqK+XyVLlnT0uXjx4n+5vwDwZxgyBrxI5/tpxUgXDnz11Vfy4IMPJnvdzz//bKpVzz33nDsMahhxDde6KlmuSlFqaPjQgJJ070Od26eLS3QOoQ4X792711QldXhVXxpcdR6fVr+SoxVPDZO6yjhh5UoXmiSkz9aqp1YoXc/Wlw6L6/zEhEO5SYdSddg3YSjUoW9dQKJz6XTVsc4j1PcuaaVVK3U6n++vcs2j1IUtLvo+RUZGuo/152qI1nMaIPW900UzOifw+PHjjmfq/En952HZsmWO/xjQ63VlNwB4ChVCIAOsNtbVqBrmhgwZkuw1rvCiK0t1cYgOL+rKYNcWLlqZ0pCi1T6tMGkg+qN5gwlp4NKgqc/WUKbzGnVeoa5y1UUMWrnShRG6CEP7qYs2NOzpYpZVq1aZ625FV8zqql8dFtcVwfrcpCt8dYuVuXPnmuqjbtFSpEgRE3S1kvbkk0+a8JYcXYijw7AaALVfep0Oz+p8Ot2ORcPVv/71L7NSV1c6a9VQw6guztD+uCqjf4W+Jxp2dR7nnXfeaY51jqfOm3QNz+tekzqk//LLL5v3V4d99ffatWuXWR2cXEVVA7guxNHfRedQ6nzRd99918xF1C17AMBTCISAl2kVScOJBqFbrRDVFcW68lRX1Oqwo4YLPacrVjXw6LCxLqTQcKVh0BWCNGymhAY/DTK6nY0GPQ1Vuk2NvlyrdzWAvv322ybgaMVPK10aXh544IFbPlereBrsdO6jhjANZW+88YYJfi76c/XZuvJYVyPrXDldRNG/f3/p1q3bLZ+t75cGPr1H9//TAKjvifbRNfyqgU2fq6FKt/TRaqiuzu3QoYP8Xf/85z9l5MiRJsRrGNdn6qIf/bQYpaFZ5xDqz9efqXMWdWhcg7f+nZLjCo4akPXvoCFR94/UeaV/NA8UAP4un3hmIQMAAFiNOYQAAACWIxACAABYjkAIAABgOQIhAACA5QiEAAAAliMQAgAAWI5ACAAAYLlMvzF1YGiYt7sAwEPOb4zwdhcAeEhA9qybHa79nPn+tyvTB0IAAIBU8WGANCneEQAAAMtRIQQAAHbx8fF2DzIcKoQAAACWo0IIAADswhxCB94RAAAAy1EhBAAAdmEOoQMVQgAAAMtRIQQAAHZhDqEDgRAAANiFIWMHIjIAAIDlqBACAAC7MGTswDsCAABgOSqEAADALswhdKBCCAAAYDkqhAAAwC7MIXTgHQEAALAcFUIAAGAX5hA6EAgBAIBdGDJ24B0BAACwHBVCAABgF4aMHagQAgAAWI4KIQAAsAtzCB14RwAAANJZz5495dVXX3Uf79y5Ux599FGpWrWqtG/fXrZv357o+mXLlkmTJk1Me9++feXcuXPutvj4eHnzzTelTp06UqtWLRk3bpzExcWlqj8EQgAAYF+F0JOvP/HFF1/I6tWr3cdXr141AbFGjRry6aefSmhoqPTq1cucV5GRkTJ48GAJCwuThQsXyqVLlyQ8PNx9/4wZM0xgjIiIkIkTJ8rnn39uzqUGgRAAACCdXLhwwVTwKleu7D735Zdfir+/v7z88stSqlQpE/5y5swpy5cvN+1z586Vli1bStu2baVcuXLmfg2UR44cMe2zZ8+Wfv36mUCpVcIBAwbIvHnzUtUvAiEAALCLr49nX39g7Nix0qZNGyldurT73NatW6V69eri87/Vz/r1nnvukS1btrjbNey5FClSREJCQsz5U6dOyYkTJ6RmzZrudn3WsWPH5PTp05JSBEIAAGAXLw0Zr127Vn766Sfp06dPovNRUVFSsGDBROeCgoLk5MmT5nsNdrdq13tVwvYCBQqYr677U4JACAAA4GHR0dEydOhQef311yUgICBR27Vr18TPzy/ROT2OiYkx31+/fv2W7drmOk7Yplz3pwTbzgAAALt4YWPqiIgIqVSpktSvX9/RpvMHk4Y3PXYFx1u1BwYGJgp/ep3re6XtKUUgBAAA8DBdWXzmzBmzgjhhaFuxYoW0bt3atCWkx65h4EKFCiXbHhwcbNqUDh0XK1bM/b3S9pQiEAIAALt4YWPqOXPmSGxsrPtY9w1UuiJ448aN8uGHH5r9BHVBiX7dvHmz9O7d21yjew9u2rRJHnnkEXOsi0j0pec1EOoCE213BUL9Xs8lnXf4RwiEAAAAHla0aNFEx7qtjLrzzjvNApEJEybI6NGj5fHHH5cFCxaYeYW61Yzq2LGjdO7cWapVq2a2q9HrGjZsKMWLF3e3a8AsXLiwOdZndevWLVX9IxACAAC7eGEO4R/JlSuXTJkyxSw6+fjjj6Vs2bIydepUyZEjh2nXYeYRI0aYTacvXrwo9erVk5EjR7rv7969u5w9e9ZsXJ0tWzbp0KGDdO3aVVLDJ17rkplYYGiYt7sAwEPOb4zwdhcAeEiAF0tSgU3HevT5175+RTIbKoQAAMAuXphDmNERCAEAgF0y2JBxRkBEBgAAsBwVQgAAYBeGjB14RwAAACxHhRAAANiFOYQOVAgBAAAsR4UQAADYhTmEDrwjAAAAlqNCCAAA7MIcQgcqhAAAAJajQggAAOzCHEIHAiEAALALgdCBdwQAAMByVAgBAIBdWFTiQIUQAADAclQIAQCAXZhD6MA7AgAAYDkqhAAAwC7MIXSgQggAAGA5KoQAAMAuzCF0IBACAAC7MGTsQEQGAACwHBVCAABgFR8qhA5UCAEAACxHhRAAAFiFCqETFUIAAADLUSEEAAB2oUDoQIUQAADAclQIAQCAVZhD6EQgBAAAViEQOjFkDAAAYDkqhAAAwCpUCJ2oEAIAAFiOCiEAALAKFUInKoQAAACWo0IIAADsQoHQgQohAACA5agQAgAAqzCH0IlACAAArEIgdGLIGAAAwHJUCAEAgFWoEDpRIQQAALAcFUIAAGAVKoROVAgBAAAsR4UQAADYhQKhAxVCAACAdHDo0CHp3r27hIaGSsOGDWXatGnutlGjRknZsmUTvebOnetuX7ZsmTRp0kSqVq0qffv2lXPnzrnb4uPj5c0335Q6depIrVq1ZNy4cRIXF5eqvlEhBAAAVvHGHMK4uDjp2bOnVK5cWZYsWWLC4UsvvSSFChWShx56SPbt2yf9+/eXdu3aue/JlSuX+RoZGSmDBw+W4cOHS7ly5WT06NESHh4uU6ZMMe0zZswwgTEiIkJiY2Nl4MCBEhQUZMJnSlEhBAAA1gVCT76Sc+bMGSlfvrwMGzZMSpQoIQ0aNJC6devKpk2bTLsGwgoVKkhwcLD7FRgYaNq0UtiyZUtp27atCYRaAVy9erUcOXLEtM+ePVv69esnNWrUMFXCAQMGyLx58yQ1CIQAAAAeVrBgQXnnnXdM1U+HeDUIbty40QzxXrlyRU6dOmWCYnK2bt1qwp5LkSJFJCQkxJzX+06cOCE1a9Z0t1evXl2OHTsmp0+fTnH/GDIGAABW8fa2M40bN5bjx49Lo0aNpHnz5rJ9+3bTp8mTJ8t3330nefPmlaeffto9fKzBTgNlQjokfPLkSYmKijLHCdsLFChgvmp70vtuhUAIAACQjiZOnGiGkHX4eMyYMVKxYkUTCEuWLClPPvmkqRy+9tprpprYtGlTuX79uvj5+SV6hh7HxMSYNtdxwjal7SlFIAQAAHbx8rYzlStXNl+jo6PNfL/NmzebaqFWBpXOEzx48KDMnz/fBEJ/f39HuNNjnWOYMPzpda7vlWsOYkowhxAAAMDDtCK4atWqROdKly4tN27cMHMIXWHQRauFOj9Q6UpkvT/p83ThibYp19Bxwu+1PaUIhAAAwCreWGV89OhRCQsLc4c8pXMH8+fPL3PmzJGuXbsmun737t0mFCrde9C1GlnpIhJ96XkNhLrAJGG7fq/nUjp/UDFkDAAAkA7DxDpXcNCgQWYPQV0FPH78eOndu7fZqHrq1Kkyffp0M0S8Zs0a+eyzz8x2Mqpjx47SuXNnqVatmnmO7kOoG1sXL17c3a4bUxcuXNgcT5gwQbp165aq/vnE69rnTCwwNMzbXQDgIec3Rni7CwA8JMCLJanCz3zi0eef/LBDsue1Ojhy5EhZu3atmd+nC0h69eplqoo6nKyLTXTuYNGiReXFF1+UZs2aue/99NNPTfvFixelXr165jn58uUzbTdv3jR7E+o12bJlkw4dOphNrlOzmppACCDDIhACWZc3A2GRnos9+vwTU9tLZsMcQgAAAMsxhxAAAFjF2xtTZ0RUCAEAACxHhRAAANiFAqEDFUIAAADLUSEEAABWYQ6hExVCAAAAy1EhBAAAVqFC6EQgBAAAViEQOjFkDAAAYDkqhAAAwC4UCB2oEAIAAFiOCiEAALAKcwidqBACAABYjgohAACwChVCJwIhvO7Tib3lzPkr0nPoXHPc4r6KMizsISlVPFgOHD0jwyctky9Wb3Nff+K7cZL39hyJnlHg3pfkt2sxf/hcAN5x6tQpGTdmtGxYv078A/yleYtW0u+Fl2TU8KGy9N9LHNfXrFVbps2YLVUrlk32eaPeGCsPtWmbDj0H7EEghFc92ry6tKxfSeYsXWeOK5UJkQUTesigdz6T5Wt2SNO6FeRf47vLfU+Ol22/HpOQ4DwmDJZvPVSuXf//AJg0DCZ9LgDviI+PlwEv9pPcuXPLjDnz5NLFizJ0yCDJls1XXg4fLM+/2N997fHjx6R7187S6cmnzPE3/12T6FlzZs+Ulcu/koaNH0j33wNZCxVCJwIhvCZf7hzyxgtt5aftB93n/tGyhvx3468yaf5qczzlyHfyYIPK0r7pPSYQli1ZWE5EXZSDx86m6rkAvOPggf0SuXWLfLv6BwkqUMCc6xPWTya8OVZeGvCK3H777e5rhwx6VZo2byGNH2hijgsEB7vbjh49IvPnzZGJ709OdA/wVxAInQiE8JoxL7aTf32xQYoE53Gfm/v5evG7zfmPZZ5cAeZr+ZKFZc+h06l+LgDvCCoQLJOmTHOHQZcrl68kOl6/bq1s3rRRln6xItnnTIqYKLXq1JU6de/1aH8BW2WIVcbnz583c0wuXbrk7a4gnTSoebfcd09pGfPh8kTnfzlwylQCXTQANqp1t/xnwy/muOxdhSVHwG2y4sPnZf/K0bLkvWel9B0F//S5ALxDh4rr3VfffRwXFycL/jVXatepk+i6j6ZNlYfbtpPCRYo4nnHi+HH56otl0rN3n3TpMyzg4+FXJuS1CuHKlStl7ty5EhkZKdHR0e7zAQEBUqlSJenSpYs0afL7sAGyFn+/7BIx5HF54Z8fy/XoG7e8LihvTpn/Zg9Zu3W/fP7f3xeVlC1RSPLlzimvRyyQy1euS/+nm8pXU56T0Paj5EbszRQ9F4D3vD1hvOzatVPmLfzEfe7okSNmwcnLrw5O9p4ln34iFSpWkipVqqZjTwG7eCUQzpgxQyIiIqRHjx4SFhYmQUFB4ufnJzExMXLmzBn56aef5NVXX5Xnn39eOnfu7I0uwoMG92olm3cellVrd93ymoL5b5dlH4SJr6+vdBo43UxMVw/3nSS3Zfd1LyLpOmim7Fk+Uh68v7JULBPyp88F4N0wOG/OLBn35ttSpszd7vOrvl4hZcuVl1KlSyd739crV8ij/3g8HXuKrI45hBkkEH700UcyduzYZCuApUqVktq1a0vZsmVl5MiRBMIs6NHm90ihoNwS9cMEc+z/vzmD7ZqESnC9/mYl8VdT+5lzzZ9512wd4xJzI1ZiEhT/omNi5dCxsxJSMM+fPheA94wZPVIWLZwvo/85Xpo0a56o7Yc130ujW6wcPnnihOzft1caNWJlMZDlAuH169elWLFif3hNoUKF5PLly+nWJ6QfDXnZs2dzH49+/vf9xAa/+5nkCPCTf7/fV+Li4qVFz3fl1NnE/wzsWDrUzA/UxSdKry91R0H55eCpP3wuAO+ZPClCPvl4gYwd/5ZZRZyQVv93bN8mPXr2TvbebZFbpXDhIlIkJCSdegsbUCHMIIGwadOmZkh4yJAhUq1aNcmePXuiCcdbtmyRoUOHSvPmif8rElnD4RPnEx1f/u26+br/yBkZ1vchKVmsgAl3qlDQ79tLXIu+IZeuXDd7E7727INy6Pg5OXP+sgzt01qOnbpgzmuIvNVzAXjH/n37ZOrkSdKtR08Jvae6nImKcrfptjK69+Bvv/0mpUolP1y8d+8eKVmqVDr2GLCTVwLhsGHDzJBx9+7d5ebNm5I3b173HMILFy6YgNimTRsJDw/3RvfgRW0fqCo5Av3k+7kDE53XDab1E0d0w2pdPDJrTFfJnStA/rvhV2n33CRHGASQMfzn22/M/85/OOUD80po645f5OzZ3/cUzZ0n+W2izp49I7lzs4UU0hYFQiefeNdsfS+4du2a7N69W6Kiosz3/v7+Zqi4fPnyZrVxSgSGhnm8nwC84/zGCG93AYCHBHhxJ+QyAz27Ndme8YmnRmQGXt2YOjAwUEJDQ73ZBQAAAOvxSSUAAMAqDBln0E8qAQAAgPdQIQQAAFZh2xknKoQAAACWo0IIAACsQoHQiQohAACA5agQAgAAq/j6UiJMigohAACA5agQAgAAqzCH0IlACAAArMK2M04MGQMAAFiOCiEAALAKBUInKoQAAACWo0IIAACswhxCJyqEAAAAlqNCCAAArEKF0IkKIQAAgOWoEAIAAKtQIHQiEAIAAKswZOzEkDEAAEA6OHTokHTv3l1CQ0OlYcOGMm3aNHfbkSNHpGvXrlKtWjVp1aqVrFmzJtG9P/74o7Ru3VqqVq0qTz31lLk+oZkzZ0r9+vXNswcNGiTXrl1LVd8IhAAAwCpaIPTkKzlxcXHSs2dPyZcvnyxZskSGDx8uH3zwgXz++ecSHx8vffv2lQIFCsjixYulTZs2EhYWJsePHzf36ldtf+SRR+STTz6R/PnzS58+fcx9asWKFRIRESEjRoyQWbNmydatW2X8+PGSGgRCAAAADztz5oyUL19ehg0bJiVKlJAGDRpI3bp1ZdOmTbJu3TpT8dNAV6pUKenVq5epFGo4VIsWLZJKlSpJt27dpEyZMjJmzBg5duyYbNiwwbTPnj1bunTpIo0aNZIqVaqYsKn3pqZKSCAEAADWzSH05Cs5BQsWlHfeeUdy5cplKnsaBDdu3Ci1atUyFb0KFSpIjhw53NdXr15dtmzZYr7X9ho1arjbAgMDpWLFiqb95s2bsm3btkTtGiZv3Lghu3fvlpQiEAIAAKSjxo0bS6dOncx8v+bNm0tUVJQJjAkFBQXJyZMnzfd/1H7p0iWJjo5O1J49e3bJmzev+/6UYJUxAACwircXGU+cONEMIevwsQ7/6tCun59fomv0OCYmxnz/R+3Xr193H9/q/pQgEAIAAKSjypUrm69a2RswYIC0b9/eMd9Pw1xAQID53t/f3xHu9Dh37tymzXWctF2HllOKIWMAAGAVb8whPHPmjKxatSrRudKlS5u5fsHBwaY96fWuYeBChQol26736dCwhsKE7bGxsXLhwgXTnlIEQgAAYBVvbDtz9OhRs5XMqVOn3Oe2b99utpDRBSQ7duxwD/8qXXSiew4q/arHLlpN3Llzpznv6+trKo4J23Wxic4jLFeuXIrfEwIhAACAh2lo05XBumn03r17ZfXq1WavwN69e5uVxkWKFJHw8HDZs2ePTJ06VSIjI6VDhw7mXh1S3rx5szmv7XpdsWLFpHbt2qZdF6hMnz7dVCD1Pp2b+Nhjj6VqyNgn3rWrYSYVGBrm7S4A8JDzGyO83QUAHhLgxVUMtces9ujz14c3SPa8VgdHjhwpa9euNWHtySefNHsO6jCzforJ4MGDzRYzd955pwmO9957r/teDZBvvPGGWTmsq5P1OcWLF3e3a1jUTyvRuYPNmjWToUOHuucXpgSBEECGRSAEsi4bA2FGxipjAABgFW9vO5MRMYcQAADAclQIAQCAVW61NYzNqBACAABYjgohAACwCgVCJwIhAACwCkPGTgwZAwAAWI4KIQAAsAoFQicqhAAAAJajQggAAKzCHEInKoQAAACWo0IIAACsQoXQiQohAACA5agQAgAAq1AgdCIQAgAAqzBk7MSQMQAAgOWoEAIAAKtQIHSiQggAAGA5KoQAAMAqzCF0okIIAABgOSqEAADAKhQInagQAgAAWI4KIQAAsIovJUIHAiEAALAKedCJIWMAAADLUSEEAABWYdsZJyqEAAAAlqNCCAAArOJLgdCBCiEAAIDlqBACAACrMIfQiQohAACA5agQAgAAq1AgdCIQAgAAq/gIiTAphowBAAAsR4UQAABYhW1nnKgQAgAAWI4KIQAAsArbzjhRIQQAALAcFUIAAGAVCoROVAgBAAAsR4UQAABYxZcSYdoEwsuXL8vSpUvlwIED0qdPH9m6dauUKlVK7rjjjr/yOAAAgHRDHkyDIeNff/1VmjVrJosXL5YFCxbIb7/9JitXrpQ2bdrIhg0bUvs4AAAAZLZAOGrUKOnYsaN8+umnctttt5lzY8aMkU6dOsm4ceM80UcAAIA03XbGky8rAuG2bdukbdu2jvOPP/647N27N636BQAAgIwaCPPnz2/mDia1efNmCQoKSqt+AQAAeIQW8Tz5siIQPvPMMzJkyBCZN2+exMfHy7p162TixIkyYsQIefrppz3TSwAAgEzu1KlT0q9fP6lVq5bUr1/fTLmLjo52T8krW7ZsotfcuXPd9y5btkyaNGkiVatWlb59+8q5c+fcbZrH3nzzTalTp455tk7hi4uL8+wqYx0aLliwoEyfPl0CAgLMD73rrrtk5MiR0qpVq9Q+DgAAIMtvOxMfH2/CYO7cuU1R7eLFizJo0CDx9fWVV155Rfbt2yf9+/eXdu3aue/JlSuX+RoZGSmDBw+W4cOHS7ly5WT06NESHh4uU6ZMMe0zZswwgTEiIkJiY2Nl4MCBZtS2e/funt12pnHjxuYFAACAP7d//37ZsmWL/PDDD1KgQAFzTgPi2LFj3YFQA1xwcLDjXq0UtmzZ0r2GQ4txjRo1kiNHjkjx4sVl9uzZ5lk1atQw7QMGDJB333037QOhJs6UCgsLS/G1AAAA6c0b0/yCg4Nl2rRp7jDocuXKFfPS4eQSJUoke6/u96xT9lyKFCkiISEh5ryfn5+cOHFCatas6W6vXr26HDt2TE6fPm1GddMsEK5fvz5FD8usS60BAAA8SYeKdd6gi87x08qfzvvT6qBmqMmTJ8t3330nefPmNesyXMPHyQU7HRI+efKkREVFmeOE7a7Qqe1pGgjnzJmToocBAABkdBmhgDV+/HjZuXOnfPLJJ7Jjxw7Tp5IlS8qTTz4pGzdulNdee83MIWzatKlcv37dVAIT0uOYmBjT5jpO2Ka0PaVSFAg/++yzFD8wuT0KAQAAMgpfH++HwVmzZsnbb78td999t5QpU8bMCdTKoNKFIwcPHpT58+ebQOjv7+8Id3ocGBiYKPzpda7vlbanaSDUbWVSQtMtgRAAACB5uiuLBj0Nhc2bN3fnJ1cYdNFqoW7tpwoVKiRnzpxJ1K7HOi9R25QOHRcrVsz9vUpugcrfCoTffvttih8IAACQkXlryDgiIkIWLFggb731lrRo0cJ9XlcE//zzzzJz5kz3ud27d5tQqHTvwU2bNskjjzxijnURib70vAZCXWCi7a5AqN/ruZTOH/zL285cvnxZli5dasqZzz77rFnlUrp0abP0GQAAAInpwpFJkyZJz549zSpgVxVP6XDx1KlTzR7POkS8Zs0aM11Pt5NRHTt2lM6dO0u1atWkcuXKZh/Chg0bunOXtuvG1IULFzbHEyZMkG7duklqpDoQ/vrrr9KlSxez5Fm/f+qpp2TlypXy0ksvmQ0SdYdsAACAjMobBcJvvvlGbt68KR988IF5JfTLL7+YKqFO0dOvRYsWNaEuNDTUtOtX/UQ4bdcNrevVq2eGnl10v8GzZ8+arf+yZcsmHTp0kK5du6aqfz7xunV2KmgA1I0PdQNE7aBWCjWh6li4bk+jq2XSU2Ao+x4CWdX5jSnfAxVA5hLwl8Yo00bneVs9+vw5T1SVLP9Zxtu2bUt24Yh+pN3evXvTql8AAAAem0PoyVdmlOpAmD9/fjlw4IDj/ObNm80miQAAAMhcUl2w1Y9OGTJkiPTu3dt8ULMuiV6yZInZT+fFF1/0TC8BAACyyD6EWSIQ6tCwLmPWlTABAQHmA5bvuusuM7mxVatWnuklAABAGsmsw7qe9JemdDZu3Ni8AAAAkPmleg6ha8NDXWXcpk0bszGi7p3zxRdfpH3vAAAA0piPh19ZNhDq3jYuuuegbqqoe+To4pLY2FjJnj27vPrqq/Kvf/3Lk30FAACAtwKhVgJ112zXx64MGzZMXnnlFbP5odLdsN944w2ZMWOGJ/oIAACQZnx9fDz6yrKB8Omnn5ahQ4fKlStX5NChQ+ajU5KqUqWKnDp1yhN9BAAAgLcDoX4kytdffy05c+Y0n1n8/fffO67RrWe0DQAAICPTIp4nX1l6lbGv7+/ZMTw83OxBqPsP3rhxQyZPnmyqhtu3b3d8Nh8AAACy4LYz+jnGy5cvl3nz5pnjCxcumCFk3Y8wJCTEE30EAABIM+xDmAaBsE+fPtK/f395/vnnU3srAACA15EH02AfQv3MYt1mBgAAAFlDqpNdp06dzGcW60fY6RCxv79/ovaaNWumZf8AAADSVGbdGiZDBcJJkyaZr6+//nqyY/K7du1Km54BAAAgYwbC3bt3e6YnAAAA6YACYRp9ljEAAACyDlaHAAAAq7DtjBMVQgAAAMulukL4008/mc8t9vPzk4zg8PfveLsLADxk/+nfvN0FAB5SISSn13421bA0eE/69u0r+/fvT+1tAAAAGWbI2JMvKwJhmTJlJDIy0jO9AQAAQMYfMs6TJ48MHTpUJk6cKMWKFXMMHc+ePTst+wcAAJCmfDNnES9jBcLy5cubFwAAACwNhGFhYZ7pCQAAQDqgQpgGgTA8PPwP28eMGfN3+gMAAIDMtvI6NjZWDhw4IF9++aXkz58/bXoFAADgIawyToMK4a0qgNOmTZNff/01tY8DAACAl6XZ3owtWrSQr7/+Oq0eBwAA4LE5hJ58WftZxlevXpWPP/5Y8uXLlxaPAwAA8JhMOqqbsQJhuXLlkh0f9/f3l1GjRqVVvwAAAJBRA2HSjac1HN52221SunRpyZUrV1r2DQAAIM35UiL8+4GwVq1a5uuVK1fk8OHDJgjGxMQQBgEAAGxZVKLhb8iQISYYdujQQU6dOiWvvvqqdO/eXS5evOiZXgIAAKRh+PHkKzNKdb/HjRsne/fulSVLlph5g+q5556T8+fPM4cQAADAhkC4cuVKGTx4sJQtW9Z9Tr8fOXKkfPfdd2ndPwAAgDSlUwg9+bIiEP72228SGBjoOB8XFyc3b95Mq34BAAAgowbCxo0by9tvv20WlbgcOXLEDBc3aNAgrfsHAACQ5quMPfmyIhC+/vrr4uvraxaVXLt2Tdq3by/NmjWT3Llzy2uvveaZXgIAAKQRhozTYNuZ22+/Xd577z1TFdy3b5/ExsbKXXfdJaVKlUrtowAAAJBZAuHx48cd57JlyyZ3332345qQkJC07B8AAECayqyfN+z1QKjzBpP7uLqE4uPjzTW7du1Kq74BAAAgowTCb775xvM9AQAASAeZdeGH1wNh0aJFU/QJJlodTMm1AAAAyMSLSjZv3izDhw83n1aiew8mnVe4ffv2tOwfAABAmqJAmAbbzuh+g1oFnDx5stmgWlcc62cb582b13ysHQAAAJxOnTol/fr1M1v31a9fX8aMGSPR0dGmTXdv6dq1q1SrVk1atWola9asSXTvjz/+KK1bt5aqVavKU089Za5PaObMmeaZoaGhMmjQILM1oEcD4Z49e6R///7mh1asWFFuu+02eeKJJ2To0KEyffr01D4OAAAg3VcZe/J1q8W3GgY1qM2bN898yMd//vMfeeedd0xb3759pUCBArJ48WJp06aNhIWFuXdw0a/a/sgjj8gnn3wi+fPnlz59+pj71IoVKyQiIkJGjBghs2bNkq1bt8r48ePFo4FQq4I6NKxKliwpv/zyi/m+SpUqcuDAgdQ+DgAAIF35ePj/krN//37ZsmWLqQqWKVNGatSoYQLismXLZN26dabip4FO93Xu1auXqRRqOFSLFi2SSpUqSbdu3cy9+oxjx47Jhg0bTPvs2bOlS5cu0qhRI5PHdGqf3puaKmGqA2GdOnVkwoQJpuypZckvv/xSLly4IN9++635tBIAAAAkFhwcLNOmTTNVwIT0o4C1olehQgXJkSOH+3z16tVNgFTargEyYXFOR2m1/ebNm7Jt27ZE7Romb9y4Ibt375Y0DYT6UJfBgwfLxYsXZeXKlfLggw9Krly5TEjUtKrlTAAAgIzMG0PGuXPnNtPtXHRh7ty5c02GioqKkoIFCya6PigoSE6ePGm+/6P2S5cumXmICduzZ89u1na47k+zVcb16tWTFi1amMmMOhFSS5Muc+bMMSuO9RctVKhQin8wAACArcaPHy87d+40cwJ1QYifn1+idj3WLf2UDv3eqv369evu41vdn2YVQl1FfObMGenRo4c0aNBAxo4d6/5EEv10Eh3PJgwCAIDMwBsVwqRhUBd/6Ff9GGB/f39HeNPjgIAA8/2t2nXoWNtcx8m1p2mF8OGHHzYvHedetWqVLF++XB577DEpXry4GTZ+6KGH5I477kjxDwUAALDRyJEjZf78+SYMNm/e3JzTopqOtiakhTjXMLC263HS9vLly5uhYQ2FeqwLUlRsbKxZ36HzFj2yqETnC7Zt29bsQbh27Vp55plnJDIy0gwlP/roo4mGkgEAADIiHd305OtWdGuYBQsWyFtvvWUKai66t+COHTvcw79q06ZN5ryrXY9ddAhZh5v1vK+vr1SuXDlRuy420XmE5cqVE4+tMk4YDtu1aydTpkyRqVOnmjSqC0sAAACQ2L59+2TSpEmmmKYriHWhiOul6zOKFCki4eHhZr9nzVVacOvQoYO5t3379uaT4vS8tut1xYoVk9q1a5v2Tp06mb2gdRRX7xs2bJgZyU3NkLFPvGtXw1TQWzZu3GhWGusPv3r1qjRp0sRUCu+9915JT1FXYtP15wFIP1GXft/BH0DWUyEkp9d+9oTV+z36/P4NSjrOaZjTbfuSo3s6Hzp0yOzkolvM3HnnnebTRhJmqtWrV8sbb7xhVg7rtn869KxT9xI+Xxen6NzBZs2amQ8Mcc0vTNNAqBVA/diUr7/+Wr755hsTAnWBic4fvP/++x2rW9ILgRDIugiEQNblzUD41neeDYQv3e8MhBldihaVDBw40CRTDYF169aVl19+WZo2bSo5c3rvjwkAAIB0DIT6GXovvPCC2YtQPz8PAAAgs/L9g4UftkpRINQPYQYAAIDFgRAAACCrSMnm0bb5y9vOAAAAIGugQggAAKzCFEInKoQAAACWo0IIAACs4iuUCJOiQggAAGA5KoQAAMAqzCF0IhACAACrsO2ME0PGAAAAlqNCCAAArMJH1zlRIQQAALAcFUIAAGAVCoROVAgBAAAsR4UQAABYhTmETlQIAQAALEeFEAAAWIUCoROBEAAAWIXhUSfeEwAAAMtRIQQAAFbxYczYgQohAACA5agQAgAAq1AfdKJCCAAAYDkqhAAAwCpsTO1EhRAAAMByVAgBAIBVqA86EQgBAIBVGDF2YsgYAADAclQIAQCAVdiY2okKIQAAgOWoEAIAAKtQDXPiPQEAALAcFUIAAGAV5hA6USEEAACwHBVCAABgFeqDTgRCAABgFYaMnRgyBgAAsBwVQgAAYBWqYU68JwAAAJajQggAAKzCHEInKoQAAACWo0IIAACsQn3QiQohAACA5agQAgAAqzCF0IkKIQAAsIqv+Hj09WdiYmKkdevWsn79eve5UaNGSdmyZRO95s6d625ftmyZNGnSRKpWrSp9+/aVc+fOudvi4+PlzTfflDp16kitWrVk3LhxEhcXJ6lBhRAAACCdREdHS//+/WXPnj2Jzu/bt8+cb9eunftcrly5zNfIyEgZPHiwDB8+XMqVKyejR4+W8PBwmTJlimmfMWOGCYwRERESGxsrAwcOlKCgIOnevXuK+0WFEAAAWDdk7MnXrezdu1cee+wxOXz4sKNNA2GFChUkODjY/QoMDDRtWils2bKltG3b1gRCrQCuXr1ajhw5Ytpnz54t/fr1kxo1apgq4YABA2TevHmSGgRCAACAdLBhwwapXbu2LFy4MNH5K1euyKlTp6REiRLJ3rd161YT9lyKFCkiISEh5rzed+LECalZs6a7vXr16nLs2DE5ffp0ivvGkDEAALCKj5c2nunUqVOy57U6qJtlT548Wb777jvJmzevPP300+7hYw12BQsWTHSPDgmfPHlSoqKizHHC9gIFCpiv2p70vlshEAIAAHjR/v37TSAsWbKkPPnkk7Jx40Z57bXXzBzCpk2byvXr18XPzy/RPXqsi1O0zXWcsE1pe0oRCAEAgFUy2rYzbdu2lUaNGpnKoNJ5ggcPHpT58+ebQOjv7+8Id3qscwwThj+9zvW9cs1BTAnmEAIAAHiRVgddYdBFq4U6P1AVKlRIzpw5k6hdj3XhibYp19Bxwu+1PaUIhAAAwCre3ocwqXfffVe6du2a6Nzu3btNKFS69+CmTZvcbbqIRF96XgOhLjBJ2K7f67mUzh9UDBkDAACrZLQh40aNGsnUqVNl+vTpZoh4zZo18tlnn5ntZFTHjh2lc+fOUq1aNalcubLZh7Bhw4ZSvHhxd7tuTF24cGFzPGHCBOnWrVuq+kAgBAAA8KIqVaqYKuHEiRPN16JFi5pQFxoaatr164gRI0z7xYsXpV69ejJy5Ej3/boB9dmzZyUsLEyyZcsmHTp0cFQc/4xPvH7eSSYWdSXW210A4CFRl6K93QUAHlIhJKfXfvbKXf8/384TmpVP+dy9jII5hAAAAJZjyBgAAFjFWxtTZ2RUCAEAACxHhRAAAFjFlwKhAxVCAAAAy1EhBAAAVmEOoROBEAAAWCWjbUydETBkDAAAYDkqhAAAwCoMGTtRIQQAALAcFUIAAGAVtp1xokIIAABgOSqEAADAKswhdCIQIkNY/e0qGTzw+UTnGj7QVEaNe0d+/H61TJ30rhw7clhCihaXZ/o8J/c1aGyuiY+Pl/lzZsqSRfPl8qVLcn+jB+SFlwdJjhw5vfSbAEjqwvlzMvWdMbJ103rJnSevPNq5hzRu8bBM/OdQ+c+Kzx3XVwqtISPfmio3b96UedPfl/8s/1yuX78m99SqJ8/0e1ny5g/yyu8BZGU+8fpv1Ews6kqst7uANDBr+hTZuT1SXh48zH3Oz99fTp08Ic90/of0eX6A1L2vvqxf+4O8N2GsfDhnoZS5u5x8tvhjef/tcfLykOFSqkxZ0+bn7ydj337fq78P0kbUpWhvdwF/k/4rZtBz3SQu7qb0enGQnD1zWiaOeV36DHhNqtxTS2Ji/v9vfPrkcXnthZ7S//UxUvu+RrJo7jT5etkSeT58hOTOk0+mvTdOfHx9Zdj4SV79nZA2KoR47z/c1+w579Hn31cmn2Q2VAiRIRw6sF9KliojQQWCE52fO2Oa3FOztjza8UlzXKz4nfLD6v/It1+vMIFw8cJ58viTXaVpiwdN++Dhb0i7lo3k8MEDckeJu7zyuwD4f/t+3SW7d2yVD+YtlcIhxaRkmXLSrmNX+WzhbKl7/wOSU253X6tB8d6GTUwYVHE3b0q3vv2lYtXq5vjBRzrKhJHhXvtdkHUwYOxEIESGcHD/PqlRq47jfMuH2siNGzcc53+7ctl8PX70qFSoVMV9vkBwsOTNl1+2R24hEAIZwKnjRyV33nwmDLrcWbKM/Gv6JImNvSHZs99mzkVuWi87I3+W9+cscV/3jy69Eg07r/pyiVSq9ns4BJC2CITIEENKhw8dlPXrfpDZMz6UuJtx0qhJM+nxbJiUuKtUomv379srmzaulzbt/2GO8wcFSdTpU+72a9euyqWLF+XChQvp/nsAcMqTL0iuXrks0deviX9AoDl39vRJuXkzVq7+dsUMBatP58+URi0ekgIFCzueMX/GB/Lx7A8l1+255Y33Pkr33wFZjy+fXefAtjPwOp0nqBPG/W7zk5H/nCB9XxggXy//Qt5/Z0Ki6y6cPy9DBr4glauGSv2Gvy8qady0hcyZOU0OHtgn0dHR8t5b48x5rTwA8L67K1SSfEHB8uHEcXL92jU5ceywLF00z7TF3vh9DvjJ40dl288b5cF2jyf7jIbNHpTxk+dKlXtqy/CBfU2QBJC2CITwusJFQuTLb3+QQcNGS5my5aVB4ybSr/8rsnTJIrPKUJ07e0ae791N4uLjZOS4t8XX9/d/dLs+01vKla8onR9tIy0a1DahskzZspIzJ6uMgYzAz89fBg4bZwLfE63ry+B+PaTZQ4+YtsD//f/p2u++kRKl7pbiJUom+4wiRe+Q0mUryPODRkhMdLSs+/7bdP0dkPX4ePiVGXltyHjjxo0pvrZmzZoe7Qu8T7eiSOjOu0qa/+G/dOmixN64If16dzPnI6bOlHz58ruvCwzMISPHviVXLl8WHx8fyZkrl7RuUl8KFyma7r8DgOSVKVdRpsxfJufPnTH/v75l4zrzVf//V/284Uf3QpKENq79TkqWLidBwQXd4bJQSFG5dJEpIUCWCYQjRoyQvXv3mu//aOcb/Zf8rl270rFnSG/rf1wjw4e8LJ9+8Y0EBP4+x2jPL7slT568EhAQIL16dRNfH1+ZOOUjxyrkSe++KXeVLC0tH2prjnft2GYWnFSuWs0rvwuAxC5fuihvDH5Rwke9JfnyFzDnflr3vVSsVsP9v/97f9kpHZ7s7rh31gfvSKPmraX9E7//B+G1q7/J8SOHpNgdLBjD35RZy3hZMRAuXrxYXnrpJTl69KgsXLhQ/P39vdUVeJnOCfT3D5B/jnxduvXsI8eOHZVJ706QTl26yeyPPpRjR4/Ie1NnmGvPnokyX/X6XLffLgWCC8pHH34gJUqWMvuTjXjtVWnb4R+OiiMA77g9dx65fu2qzJ7yrgl9OnT87VdLZdS700x71KkTJuglN1zcsu1jsmDmZDOcHFyoiMydFiFFihaXe2rX88JvAmRtXt2YOiYmRh577DGpW7euvPLKK3/pGWxMnTXo6uGJE/4pO7ZtNZ8y0qb9Y/L0M8/KE+0fksOHDjiub9m6jdlzUOcYRrw9TlZ+ucwEwuatHpJn+70k2bOzgD4rYGPqrOHY4YPywVujZe8vO6Rg4aLSuedzUrPu/abt153b5JW+XeTjFevkNj+/RPfFxcXJkgWzZMXSRXLxwgWpVqOO9HohXPInGSlA5uTNjanX77vo0efXLpVHMhuvf1LJvn37ZMOGDdKxY8e/dD+BEMi6CIRA1uXNQLhhv2cDYa2SmS8Qer2MUqpUKfMCAACApYEQAAAgPbGmxIl9CAEAACxHhRAAANiFEqEDFUIAAADLUSEEAABW8aFE6ECFEAAAwHJUCAEAgFV8KBA6UCEEAACwHBVCAABgFQqETgRCAABgFxKhA0PGAAAAlqNCCAAArMK2M05UCAEAACxHhRAAAFiFbWecqBACAABYjgohAACwCgVCJyqEAAAAlqNCCAAA7EKJ0IFACAAArMK2M04MGQMAAFiOQAgAAKzbdsaTrz8TExMjrVu3lvXr17vPHTlyRLp27SrVqlWTVq1ayZo1axLd8+OPP5p7qlatKk899ZS5PqGZM2dK/fr1JTQ0VAYNGiTXrl2T1CAQAgAApJPo6Gh56aWXZM+ePe5z8fHx0rdvXylQoIAsXrxY2rRpI2FhYXL8+HHTrl+1/ZFHHpFPPvlE8ufPL3369DH3qRUrVkhERISMGDFCZs2aJVu3bpXx48enql8EQgAAYBUfD79uZe/evfLYY4/J4cOHE51ft26dqfhpoCtVqpT06tXLVAo1HKpFixZJpUqVpFu3blKmTBkZM2aMHDt2TDZs2GDaZ8+eLV26dJFGjRpJlSpVZPjw4ebe1FQJCYQAAADpQANc7dq1ZeHChYnOa0WvQoUKkiNHDve56tWry5YtW9ztNWrUcLcFBgZKxYoVTfvNmzdl27Ztido1TN64cUN2796d4r6xyhgAANjFS4uMO3XqlOz5qKgoKViwYKJzQUFBcvLkyT9tv3TpkhmGTtiePXt2yZs3r/v+lKBCCAAA4EU6tOvn55fonB7r4pM/a79+/br7+Fb3pwQVQgAAYJWMtg+hv7+/XLhwIdE5DXMBAQHu9qThTo9z585t2lzHSdt1aDmlqBACAACreHvbmaQKFSokZ86cSXROj13DwLdqDw4ONkPDGgoTtsfGxpqAqe0pRSAEAADwIt1bcMeOHe7hX7Vp0yZz3tWuxy46hLxz505z3tfXVypXrpyoXReb6DzCcuXKpbgPBEIAAGAVb207cyu1atWSIkWKSHh4uNmfcOrUqRIZGSkdOnQw7e3bt5fNmzeb89qu1xUrVsysWHYtVpk+fbqsWrXK3Dds2DCzvQ1DxgAAAJlEtmzZZNKkSWY1sW4+vXTpUnn//fclJCTEtGv4e++998zeghoSdThY233+Nz794IMPmr0LX3/9dbNXoe5FOHDgwFT1wSfetc11JhV1JdbbXQDgIVGXor3dBQAeUiEkp9d+9q4Tv3n0+eWLeO93+6uoEAIAAFiObWcAAIBVMtq2MxkBFUIAAADLUSEEAABW+St7BWZ1BEIAAGAV8qATQ8YAAACWo0IIAADsQonQgQohAACA5agQAgAAq7DtjBMVQgAAAMtRIQQAAFZh2xknKoQAAACWo0IIAACsQoHQiUAIAADsQiJ0YMgYAADAclQIAQCAVdh2xokKIQAAgOWoEAIAAKuw7YwTFUIAAADLUSEEAABWoUDoRIUQAADAclQIAQCAXSgROhAIAQCAVdh2xokhYwAAAMtRIQQAAFZh2xknKoQAAACWo0IIAACsQoHQiQohAACA5agQAgAAqzCH0IkKIQAAgOWoEAIAAMtQIkyKQAgAAKzCkLETQ8YAAACWo0IIAACsQoHQiQohAACA5agQAgAAqzCH0IkKIQAAgOWoEAIAAKv4MIvQgQohAACA5agQAgAAu1AgdCAQAgAAq5AHnRgyBgAAsBwVQgAAYBW2nXGiQggAAGA5KoQAAMAqbDvjRIUQAADAcgRCAABgFx8Pv27h66+/lrJlyyZ69evXz7Tt3LlTHn30Ualataq0b99etm/fnujeZcuWSZMmTUx737595dy5c5KWCIQAAADpYO/evdKoUSNZs2aN+zVq1Ci5evWq9OzZU2rUqCGffvqphIaGSq9evcx5FRkZKYMHD5awsDBZuHChXLp0ScLDw9O0bwRCAABgFS8VCGXfvn1y9913S3BwsPuVO3du+fLLL8Xf319efvllKVWqlAl/OXPmlOXLl5v75s6dKy1btpS2bdtKuXLlZNy4cbJ69Wo5cuRImr0nBEIAAIB0oIGwRIkSjvNbt26V6tWri8//9sPRr/fcc49s2bLF3a7VQ5ciRYpISEiIOZ9WCIQAAMAqmrs8+UpOfHy8HDhwwAwTN2/e3MwHfPPNNyUmJkaioqKkYMGCia4PCgqSkydPmu9Pnz79h+1pgW1nAACAVbyx7czx48fl2rVr4ufnJ++8844cPXrUzB+8fv26+3xCeqxhUek1f9SeFgiEAAAAHla0aFFZv3695MmTxwwJly9fXuLi4mTgwIFSq1YtR7jT44CAAPO9zi9Mrj0wMDDN+kcgBAAAVvHWR9flzZs30bEuIImOjjaLS86cOZOoTY9dw8SFChVKtl3vSyvMIQQAAPCw77//XmrXrm2Gh1127dplQqIuKPn555/NPEOlXzdv3mz2HFT6ddOmTe77Tpw4YV6u9rRAIAQAAPAw3VtQh36HDBki+/fvN9vG6PYxPXr0kBYtWpi9BUePHm32KtSvGhx1qxnVsWNH+fe//y2LFi2S3bt3m+1pGjZsKMWLF0+z/vnEu+JoJhV1JdbbXQDgIVGXor3dBQAeUiEkp9d+9vmrNz36/Hw5siV7fs+ePfLGG2+Y7WR0n8HHH3/cfOqIzinUzaeHDh1qtqbRTzAZPny4VKhQwX2vblg9ceJEuXjxotSrV09Gjhwp+fLlS7M+EwgBZFgEQiDr8mYgvHDNs4Ewb2DygTAjY8gYAADAcqwyBgAAVvHGPoQZHYEQAABYxVvbzmRkDBkDAABYjgohAACwCgVCJyqEAAAAlqNCCAAA7EKJ0IEKIQAAgOWoEAIAAKuw7YwTFUIAAADLUSEEAABWYR9CJwIhAACwCnnQiSFjAAAAy1EhBAAAdqFE6ECFEAAAwHJUCAEAgFXYdsaJCiEAAIDlqBACAACrsO2MExVCAAAAy/nEx8fHe7sTAAAA8B4qhAAAAJYjEAIAAFiOQAgAAGA5AiEAAIDlCITIFKKjo2XQoEFSo0YNue++++Sjjz7ydpcApLGYmBhp3bq1rF+/3ttdAazDPoTIFMaNGyfbt2+XWbNmyfHjx+WVV16RkJAQadGihbe7BiCN/qOvf//+smfPHm93BbASgRAZ3tWrV2XRokXy4YcfSsWKFc1L/6Uxb948AiGQBezdu9eEQXZBA7yHIWNkeLt375bY2FgJDQ11n6tevbps3bpV4uLivNo3AH/fhg0bpHbt2rJw4UJvdwWwFhVCZHhRUVGSL18+8fPzc58rUKCAGWK6cOGC5M+f36v9A/D3dOrUydtdAKxHhRAZ3rVr1xKFQeU61knoAADg7yEQIsPz9/d3BD/XcUBAgJd6BQBA1kEgRIZXqFAhOX/+vJlHmHAYWcNg7ty5vdo3AACyAgIhMrzy5ctL9uzZZcuWLe5zmzZtksqVK4uvL/8IAwDwd/FvU2R4gYGB0rZtWxk2bJhERkbKqlWrzMbUTz31lLe7BgBAlsAqY2QK4eHhJhB26dJFcuXKJc8995w0a9bM290CACBL8IlnJ1AAAACrMWQMAABgOQIhAACA5QiEAAAAliMQAgAAWI5ACAAAYDkCIQAAgOUIhAAAAJYjEAIAAFiOQAhYqFOnTtK/f/9k25YuXSo1a9aUmJiYW95/9OhRKVu2rPma0T300EPy8ssv/+E1n376qTRu3Nh8v379evO7uezatUs2b97s8X4CgDcRCAELPfjgg7J69epkQ99XX31lPhbQz89PMrsffvhBoqOjZejQoSm+JzQ0VNasWeM+7tu3rxw8eNBDPQSAjIFACFioZcuWcu3aNVm7dm2i81euXDFhqHXr1pIV1KhRQz7//HPJmTNniu/RIBwcHOzRfgFARkMgBCyUP39+qVu3rqxcuTLR+VWrVknevHmldu3acurUKenXr58ZPq5UqZK0a9dONm3alOzzLl26JAMHDpR77rlH7rvvPhk5cqRcv3492SFY9eqrr5qXeu+996RPnz7yxBNPSK1atWTDhg2O5+v9ixYtkiZNmpgKng53//bbb+7h3scff9xU8qpXr26GvPUj2t9//3154IEHpF69etK7d285fvy4+3n6u/Xo0UOqVatmfq/Dhw+72xL2t3PnznLs2DEJDw939/fXX38156tUqSLNmzeXefPm/eW/AwBkFARCwFJaBfzmm2/k5s2b7nPLly+XVq1aia+vrwwYMMC0LViwQD777DMpVKiQDBs2LNlnDR48WC5fvizz58+XSZMmybZt22TEiBEp7ov2Q/sza9YsE7SS8+6778qQIUNk9uzZJpS9/vrr7raff/5ZSpcuLR9//LEJpHPnzjWVwQkTJsjChQslKChIunXrJjdu3DDXP//88xIXF2dC5jPPPGN+bnI0rBYuXFgGDRpkfkcNuXq9K3i+8sor5vfV9wcAMjMCIWAprbZdvXpVNm7caI410OlwsS7C0Aqbtr/22mtSqlQpE7a0grd3717Hc7S6ppXF8ePHm8qaBjqtEC5ZssQ8MyUKFCggHTt2lPLly0tAQECy12gQa9iwoVSuXNmEM53r6Hq+j4+PPPvss6avWv2cNm2aWUiilU49p+H04sWL8v3338uePXtMgBw1apSUKVPGBGD92cnRamm2bNnk9ttvNy8NmRouX3jhBSlRooRZiKLVRw2pAJCZZfd2BwB4R65cuUzA0mHjOnXqmFBXrFgxMzysNCR9+eWXZoXtgQMHZPv27aaqltS+ffvM+fvvvz/ReT136NChFPWlaNGif3qNDke7aB+1eqn9UhrSXEFSh5JPnjwpL774oql0umh1TxeH6CITDXohISHuNg2ZWh39M/v375fdu3ebYWsX7YeGRgDIzAiEgMW0GqjVPK0EasXNtZhEw5wOsercQK2gaSVMh1vDwsIcz9BApNWzxYsXO9p0mDkyMtJxPjY2VrJn////+fH39//Tvt52223u713B1BX4Et7vGgLXIea77ror0TPy5MljFtJoBfRWz/4j2m+de5lwuBoAsgKGjAGLNWjQwAwbr1u3zgQlVyDUoWEdSp45c6YZEtVK4unTp01b0jCloUuHbnXY9s477zQvrcaNGzfObGvjClu6gtnlr+xfqPsBumi1Up+bNPCp3Llzm4phVFSUuz9FihQxQ9paUbz77rvN8HHC6mXCZ/8R/Xn6DK2kup69ZcsWmTNnTqp/HwDISAiEgMV0i5WmTZvK2LFjTVDSeXGuUKXVty+++MKsstXhVF1goZLuXahz9OrXr28WoWg1cMeOHWZVrgZNfY7O09Ph3MmTJ8uRI0fM/L6dO3emuq8TJ040K5C3bt1q5v/p6uBbbSfTtWtXeeedd+Tbb781w8S6GEWHvkuWLGn6q1U+XSiiw786VK6LUG4lR44cZqj4woUL8vDDD5uwqxVCHSrXvRxHjx5tAigAZGYEQsByWhXUCpkOH7voylpdUfzhhx+a9qlTp5pQpcO8yYU5rQZq1UyD2NNPP20qaW+99ZZ7rqIOS2u41GdpCNMFKqnVtm1bs/VL9+7dzVY4Osx9K3pNhw4dTHDT+3TLmenTp5shY/X2229Lvnz5zHY12k/dRuZWdC6lbi2jv7/+LvqeaMjU5+o5/V169eqV6t8HADISn/ik4z8AkMHo6mVdyaurhgEAaY8KIQAAgOUIhAAAAJZjyBgAAMByVAgBAAAsRyAEAACwHIEQAADAcgRCAAAAyxEIAQAALEcgBAAAsByBEAAAwHIEQgAAALHb/wH+QNG2noCg5wAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 800x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Matrice de confusion\n",
+    "cm = confusion_matrix(y_test, y_pred_baseline)\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "sns.heatmap(cm, annot=True, fmt=\"d\", cmap=\"Blues\")\n",
+    "plt.title(\"Matrice de confusion\")\n",
+    "plt.ylabel(\"Valeur réelle\")\n",
+    "plt.xlabel(\"Valeur prédite\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 84,
+   "id": "df84f1fa",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqsAAAIcCAYAAADR1Oc8AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAgoNJREFUeJzt3QV0FFcbBuB34w4kuFuR4g6FluJWXIq7a3F3dy8EKBQof4tDkeJS2uItXtw9QeO6//kuzZKQAElIMivvc07YmdlN9ssOSd69c0Wn1+v1ICIiIiIyQlZaF0BERERE9D4Mq0RERERktBhWiYiIiMhoMawSERERkdFiWCUiIiIio8WwSkRERERGi2GViIiIiIwWwyoRERERGS2GVSIiIiIyWjZaF0BEpIXz589j1apVOHnyJJ4/f47UqVOjTJky6Ny5MzJlypRkdbRq1Urdrl69OsG/9vz587FgwYJoxx0dHZEmTRpUr14dvXr1go1N1D8FV65cwQ8//IBjx46p1yZlypQoWrQo2rRpg0KFChn160lE5odhlYgszpo1azBp0iSUKlUK/fv3V8Hqzp07KqDt2bMHK1euRJ48eWAu1q5dG2X/xYsX2L59OxYvXozQ0FAMHDjQcN/WrVsxfPhwfP755+jbty8yZMiAx48fY8OGDWjWrJl6bLt27Sz69SSipKXT6/X6JH5OIiLNnD59WrVmtmjRQoWyyKRFsF69eqolcdOmTWbTsiotpTH59ttvcffuXRw9elTtX7p0CU2aNEHdunUxfvx4WFlF7Sk2ceJEVefy5cvxxRdfGOXrSUTmh31WiciiSGufq6sr+vXrF+0+d3d3DBkyBJUqVYK/v786FhYWploOa9eujYIFC+Lrr7/GjBkzEBQUZPg8CWsRoTPC8ePHkTt3bnUrJKxJa+X69etRtmxZlCxZEtevXzc8fuHChSoAFilSBN27d8e9e/eifL2rV6+iS5cu6nK8fPTo0SPaY+LKxcUFOp3OsC8trU5OThgxYkS0oCqkVTVdunSq1vi+nkREccVuAERkMeRC0h9//IGKFSuqfpsxqVmzZpT9UaNGqUvjnTp1QvHixVXro4S1f//9F8uWLYsS9j5Ggq+0SkoLpVyKz5Ejh6F18tmzZ+q55DEzZ85E69atsW3bNhUob926haZNmyJ79uyYOnWqunS/aNEidVleavPw8Pjg88rjI4SHh6vn/vXXX/Hnn38aLunLcdkvV67ce18bOzs7VK5cWbWuytdInjx5nF9PIqK4YlglIoshAUtaRDNmzBirx0vLp/TVlH6YMlBISKuo9MkcNGgQfv/9d5QvXz5ONXTt2lW1zkZmbW2tQmzatGnVvoRSuXy+ZcsWtGzZUl3KlzD4448/qvAqZPCSBEcJzIMHD/7gc+bLly/asfTp06vBVRHf18uXL+Hr66v6qH5IlixZVOh/9OiRuo3L60lEFB/sBkBEFkNCoZDWy9g4ceKEuq1Vq1aU47IvXyviEn9c5M2bN9oxuawfEVQjHiMj6GVkvZBR+dJtwMHBQbWSyoeEVmnp/euvvz76nBK45UNaROWSvHyuXOqXrgS2trZRHvvu/vteQwmqcX09iYjigy2rRGQxkiVLBmdnZzx8+PC9j5G+lSEhIeqxr169UsdSpUoV5TEy1VOKFCng4+MT5xqkT+i7ZADSu+TS/uvXrw2tnjt37lQfMfUL/ZgCBQoYtiXgtm3bFn369FEttbIv5PuR2u7fv//BrxXRT1b6rsb19SQiig+2rBKRRZE+mdIiGnmAVGTr1q1D6dKlcfHiRUPA8vLyivIYCV/SpUACXoR3WxfjMqAoIhRHJs8ZEURlAJO05ka0kEb+kO4DcSEDpyZPnqwCtwx+ingdpO9thQoVcOTIEfj5+cX4ufI97tu3T7UER9QWl9eTiCg+GFaJyKK0b99etVTOmTMnxoAo4S9nzpyqn6dcehc7duyI8jjZl+BWrFgxtS+X1WUu0shk0FRsyWMjt9KePXsWDx48UCFPRMwcIN0DpJVUPvLnz69aRvfu3RvHVwCqX2rEjANLly41HJfZBgICAgwDvd41a9YsNX+q9LuNz+tJRBQf7AZARBalcOHC6hK4hKsbN26ogUzSQnrt2jU1DZO0EEYELwlZ9evXx7x581SIK1GihJoFQAY8yQT4X375pXqctEgeOHBAtVjKyPhTp06pwVGxJSPxZaCThEBpsZXZAHLlyoU6deqo+yVYymwAEiZlBgB7e3s10b+0ckpt8SFdAaRlVsKqfI8SYGWqrSlTpmDo0KHqeZo3b64GTz19+lRNvSWzBQwYMCDKoLK4vJ5ERPHBRQGIyCIdPnxYzZ8qU1HJZXjpgykj7CUwynYEaWFcsmQJNm7cqFpPZSYAmXNVAqSExojHzJ49G5s3b1Yj6iXUyv0S+GQJUgm2EvYkBO7fvz/K6HmZn1W+pozOlwAqg6ck/MoE+5H7o8pldHmOv//+Ww1ukjArAVcGTMV3UYBDhw6pAFytWrUooVdacaXVVgZvRXRHkL6tUquE0095PYmI4ophlYiIiIiMFvusEhEREZHRYlglIiIiIqPFsEpERERERothlYiIiIiMFsMqERERERkthlUiIiIiMloMq0RERERktMx2BSsvr7dLFyYFd3dnPH8e83raZBp4Dk0bz5/p4zk0fTyHps89ic9hqlSuH30MW1YTgE4HWFtbqVsyTTyHpo3nz/TxHJo+nkPTpzPSc8iwSkRERERGi2GViIiIiIwWwyoRERERGS2GVSIiIiIyWgyrRERERGS0GFaJiIiIyGgxrBIRERGR0WJYJSIiIiKjxbBKREREREaLYZWIiIiIjBbDKhEREREZLYZVIiIiIjJaDKtEREREZLQYVomIiIjIaBlFWA0ODsY333yD48ePv/cxly5dQuPGjVGoUCE0bNgQFy5cSNIaiYiIiMgCw2pQUBD69euHa9euvfcx/v7+6Ny5M4oXL45NmzahSJEi6NKlizpOREREROZL07B6/fp1NGnSBHfv3v3g43bu3Al7e3sMGjQIOXLkwPDhw+Hs7Ixdu3YlWa1ERERElPRsoKETJ06gVKlS6Nu3LwoXLvzex509exbFihWDTqdT+3JbtGhRnDlzBg0aNEjCiomIiOIpKBhWr3wS5UtbPfaClX8A9NCO/IkOdbKHrX8Q9FoWQvHiG+APewdH6CsUh7HRNKw2b948Vo/z8vJCzpw5oxzz8PD4YNcB8V+2TXQRz5NUz0cJj+fQtPH8mfk5DAqGpB/rx17Q+QeqQ9a37wNhYfE66Tbnr0Lv6ABYJd1/GF1oGHSBQTB3oQDstS6C4uy81yO03LEGNbLnwXSMha6scQVWTcNqbAUEBMDOzi7KMdmXgVnv4+7uDGvrpO3l4OHhmqTPRwmP59C08fyZlvC7jxB24bohNIYAcPvvPv3dx9A/fwn90+eJ8tw6/wBoxtU5cb6ujx+siufjuzaKNb1ej2UHdqH/Wk8EhYQg4DYwOm9Wo/tdahJhVfqrvhtMZd/BweG9n/P8uV+StqzKiX32zIeXPkwUz6Fp4/kzIcEhcNiyF1YvXsHq2ct4fYnQLOnVrVxSDyn8ebzDWVj2TEhq4R7JARuT+NMbZ/w5NC0+Pq/Rr19vbNmySe1XqVINCxYsRorPsibpOUyZ8uPB2CR+YtKkSQNvb+8ox2Q/derUH/y8pP5hkefjD6hp4zk0bTx/iSAkBLYXrsLK6zlgYx2nT9W99oPNzbsId3N5sx8cEmOfzZA8OaB3coCjox0CAt42TOgCgxGaLSPC06REeMoUbw5ax60Go2Tm/0f5c2j8zp07g44d2+D27VuwsbHB8OFj0K1bT8MVaWM7hyYRVmVu1aVLl6rmahlcJbd///03unbtqnVpREQmQ+frp1o21XZ4OBx2HoL+A1eoJKja3H34yc9rLUE3BoGVvkBo3hzQu7qoVjm3lK545c1WOaLEtmHDOhVUM2bMhCVLVqB48ZIwZkYbVmVQlaurq7rUX716dcycORMTJ05E06ZN8csvv6h+rDVq1NC6TCKiOLF64g3d67eti1YvXsP6iTf0trbv/Rzbs/9CL/0cP6Frk9XLTx+FHpI/F/TOTnH7pNBQhKf2QHjyiN6oQFi61IB91HEIRJR0RowYo1pUe/X6DilSuMPYGW1YLVeuHCZPnqympnJxcYGnpydGjx6NdevWIXfu3FiyZAmcnOL4S5OIKLGnJnr5Wm1aPXuhgqjNv9ffjDyXX7if0EqpS8Apj/QRQTEkVLWwBtSq8P7n1esRmikd9O7JE+z5iShp/f33KSxb5ol58xapkCqD1EeNGgdTYTRh9cqVKx/cL1iwIDZv3pzEVRGR2QsNVaHtQ6wfPn3vtEPSJ9Pm+m1ApiYKDYv104alTxPl8nxo1ozQ/9e3M0Y6neq/+UnsbBGe0p2jxYkshF6vh6fnQowfPxohISHImzefak01NUYTVomIElx4OKwee0MX/jZEWj19Bt1rX1g/9obNrXuJ87QuctVHBytfP4TkzaEG1ITmya7uk8v9ahS6learXRORGXvx4jl69+6G3bt/U/u1a9dDmzbtYIoYVonIOMgl6YA3E74rej3sDx1/Mxr92m3o7d7fp1ME6gDndwbmyOjzhBSaNUOMx61e+yKkYN43I9c9UgC2/NVKRNo5ceI4unRphwcP7qtL/uPGTUa7dh0NK4GaGv5GJSJN6F68guPmPdD5+auWRyu5/dDjYxE8P/RrODxFMsO2zPEZXCgPdGHhCM2eGaE5s3w8YLIllIhMwC+/rEHfvj0RFhaGbNmyY9mylShQoBBMGcMqESUd/0DY3H0A2zP/vvcSvD7SynMSJkVglXJqNLlqtYyBNBakcHfGi+d+0aY90jvYAf8NcCIiMndFixZXiylVr14TM2bMhYuLca1GFR8Mq0SUqKTl1GnlphgngxdhHskRXL6UGjEfli4V8IEpnN7/JICVhyv0emvO0UlEFufx40dImzad2s6VKzcOHPgD2bLlMNnL/u9iWCWihCcrFT17Acf1v7338r5MhxRUuSzC06ZK8vKIiMxBeHg45s6diZkzp2LDhm0oXbqMOp49e06YE4ZVIvpk1vcewu7QcVg/fab6dsY0zVO4kyMC61VBWKZ07P9JRPSJnj59ih49OuHw4YNqf9euHYawam4YVoko3nS+/nCZv/K994c7OsAqIBC+PVp9eA5RIiKKtSNHDqNbt454+vQJHB0dMWXKTDRt2gLmimGViOImMAi6oGDYHTsDu78vRLkrNFsmBH1VErCzQXgyN07hRESUgMLCwtQlf/mQCf/z5MmLpUtXInfuPDBn/EtCRO/332glq4dPYHvhWrRwGiHMPTn8uzRL4uKIiCzLzp3bMWPGFLXdokVrTJw4zSKWnmdYJaKo9HrY/n0RDnuOfPhhNjbQhYbCv2W9N/1QiYgoUX3zTR11uf+rr75Go0bfwlIwrBKRgfO8H2HlF/De+2UO1MBqXyG0QG4OkiIiSmShoaFYtGiBWibVzS2Zmopq3rxFsDQMq0SWTq+H3dF/YH/4eLS7gsoWQ0iRz9V69nCw16Q8IiJL9PDhA3Tp0h7Hjx/F2bP/YOnSH81m3tS4YlglssQ5UH18VUC1PX8lxof4dm8JfTLTX/WEiMgU7du3Gz17dsHz58/VClRy+d9Sg6pgWCWyFHo9nJavfzMX6nvIsqYhxQskaVlERPRGSEgIJk0ah4UL56r9ggULY8mSFciePQcsGcMqkZmz/eci7A6fUPOdvisstQdCiuVHaPbMnAeViEhDjx49RIcOrXHq1Am136FDZ4wZMxH29uyCxbBKZG4Cg2D/xylYPfGGzd2H0e7W29rAt297wNpak/KIiCg6Ozt73L9/Tw2kmj17AWrXrqt1SUaDYZXIXISEwP7wCdidPBfj3cGlCiEkf26Ep3IHLLjvExGRMY32t7F5E8U8PDywcuX/4O7ugSxZsmpdmlFhWCUyE64zlkU7FlyyEEIzp0NY9sxsSSUiMiJ37txG585t0b59Z3z7bXN1rEiRYlqXZZQYVolMmV4P6zsP4PTztiiHA+pWRujnn2lWFhERvd+2bVvRt29PvH79ClOmTEC9eg3ZN/UDGFaJTElYGJxWboL1E2/o7e2gCwqO9hCfwV04YT8RkREKDAzEmDHDsXz5UrVfvHhJeHouZ1D9CIZVIhNhffMenNZuN+y/G1TD0qaCf6v6DKpEREbo5s3r6NSpHc6fP6v2e/b8DkOHjoStLLpCH8SwSmRCramR+bVuAL2sKmVvB72Lk2blERHRh3l7e6NKla/h4/Ma7u7uWLDAE5UrV9O6LJPBsEpkZHR+/rB6+BTWj55C5+MHu3OXo9wfXKwAgqqU5Yh+IiITkTJlSrRr1xEnThzD4sU/IH36DFqXZFIYVomMRUhIjCP6I/Pt1gL65G5JVhIREcXPtWtXYWdnZ5iGasiQEeo2Yqoqij2+YkQaszt0DNb3HsHm/uMox8NSuUPn64/QArkRli41Qj/PqVmNREQUe+vW/YxBg/ohd+7c2LZtjwqtDKnxx1eOSAvh4bA9dR62Z/6F9bMX0e72GdAJsOWPJxGRKfHz88OwYQPx888/qX1nZxf4+vqoif4p/vjXkCiphIerOVFt/7kE2ys3o90d9FVJhHyeE/oUyTQpj4iI4u/y5X/RqVMbXLlyGTqdDgMGDEG/foNgzQVZPhnDKlFSCAiC65zlMd4VUjAPgkoXht4jRZKXRUREn0av1+OXX9ZgyJD+CAgIQOrUadQgqnLlvtK6NLPBsEqUiKyeeMN5+fpox0MK5EZI/lwIy5pRk7qIiChhhIaGqkn+JaiWL18BCxcuRerUqbUuy6wwrBIlEtsTZ+Gw/68ox0JzZEFAk5qa1URERAlLJvVfsmSFWkK1Z88+sOLCLAmOYZUoAdkePwPbS9eht7GOMro/JFc2BNasADhyST0iIlO/7L969Y/w9vZSfVJFtmzZ0bt3X61LM1sMq0SfyMr7Oawee8P+yAlYvfSJdr9fp6YIT8n+qEREpk5WoBowoA82b96oBlFVrFgZhQsX1boss8ewSvQJ7Pf9CbuT56IdD6xSDnpnRzU/KifxJyIyfefPn0XHjm1w69ZNNWfqsGGjUbBgYa3LsggMq0TxpHvlEyWohmZKB11gEAK+/QZ6V2dNayMiooS77C8DqEaPHobg4GBkzJgJnp7LUaJEKa1LsxgMq0TxoPPzh8v3byZ9FlwGlYjIPPXq1VWtSCWqV6+JuXO/R4oU7lqXZVEYVoliyfrGXdgf+AvW3lFXnAr5LCuDKhGRmSpb9kts3rwBo0aNQ+fO3VVfVUpaDKtEsWB35CTs/zgV7XhoziwIbFRDk5qIiCjhyWX/x48fIV269Gq/adMWKF36CzXin7TBsEoUx0FUQWWKIDR/LoRLa6oNf4SIiMzFixfP0adPd5w7dxYHDvwBd3cP1ZLKoKot/qUliklICJy/XwMr/4Aoh/2b10FYlgyalUVERInj5Mnj6NKlPe7fvwc7OzucOnUCVavyypkx4DILRO8KDYXrjGXRgqpv7zYMqkREZiY8PBwLFsxF3bo1VFDNmjUbdu7cx6BqRNiyShRZYBBcZy2PcsivTQOEp0kJWFtrVhYRESW8Z8+eoVevLti3b4/ar1evAWbOnAdXVw6aNSYMq0Th4bC+9wiBk36Fyzt3+QztplFRRESU2KZMmaCCqoODAyZMmIpWrdpytL8RYlgli2Z96x6cftke430+fdoleT1ERJR0RowYjXv37mDkyHHIly+/1uXQezCskkV7N6iGuzjBr1sLjvInIjJDT58+xdq1/0PPnn1UC2qyZMnxyy+btC6LPoJ/kcmiJ/mPEFyyINyaVoe3tw+g17QsIiJKBH/88Tu6du2Ap0+fwM3NDW3atNe6JIolzgZAFstp3Q7DdnDFMprWQkREiSMsLAzTp09Go0Z1VFDNnTsPSpXi73xTwpZVskhOS38xbAeVKw5Y8X0bEZG5efLkMbp166haVUWzZi0xadJ0ODs7a10axQHDKlkc6/uPYO39wrAfXLYYOPaTiMi8SEDt3LkdvL294OTkjGnTZqFJk2Zal0XxwLBKFkH38jVsLt+A1fOXsDt72XDct09btqoSEZkha2trPH/+DHnz5sOyZSvx2We5tC6J4olhlcye7T8X4bDrzSWgyIKLF4DeyVGTmoiIKOGFhITA1tZWbZcpUxY//bQWZct+BUdH/q43ZWxSIvOl18Pm/JUoQTXc2RHBRT5HQK0KCKpSTtPyiIgo4ezfvwdlyhTFtWtXDccqV67GoGoG2LJKZst5wSpY+fob9gMrfYGQkoU0rYmIiBK+NXXy5PFYsGCO2p89ezq+/36p1mVRAmJYJbNjffs+7H8/ESWoBjSohtDc2TWti4iIEtb9+/fQpUt7nDx5XO23b98JY8ZM1LosSmAMq2QWdL5+sPvjFOz+uRTtPp8hXQGu9UxEZFZ27/4NvXp1wcuXL+HmlgyzZy9A7dp1tS6LEgHDKpk8qweP4bxqc7TjoTmzILDG1wyqRERmZt++3WjV6lu1XaRIUXh6rkDWrNm0LosSCcMqmTTnuStg5R9o2A9PkQwhebIj+KuSnJKKiMhMlS9fESVLllZBdeTIcbCzs9O6JEpEDKtkuiP9r96KElQ5gIqIyHwdPLgfZct+qYKpTE+1ceM22Nvba10WJQE2PZHJsTl3Ga5TFsNx027DMZ+BnRlUiYjMUFBQEIYOHYBvv62PCRPGGI4zqFoOtqyS6dDrYXfoGOyPnYlyOEgu+dtYa1YWEREljps3b6glU8+de/N738bGBnq9HjqORbAoDKtkMpx+3ADrx96G/cCKZd60pvKXFhGR2dmyZSP69esNX18fuLu7Y/78xahSpbrWZZEGGFbJ+IWHw3WqZ5RDfq3qIzxjWs1KIiKixBEQEICRI4di1arlar9UqTLw9FyO9OkzaF0aaYRhlYya1dNncP5hXZRjvr3bQO/spFlNRESUeJ48eYxNm9arS/19+vTHoEHD1OV/slw8+2S0bE+eg8O+P6Mc8+nbHnBgp3oiInMl86XKJX8nJydUqFBJ63LICHA2ADJOYWFRgmpYutTwGdCRQZWIyMz4+/ujX79eOHz4oOFYrVq1GVTJgC2rZHR0L1/DZdEaw35A/aoIzZND05qIiCjhXblyGZ06tcHly/9i797dOHHiLBwdHbUui4wMwyoZFbujf8P+0PEoxxhUiYjMzy+/rMHgwf3UgKrUqdNg0aJlDKoUI4ZVMg5BwXCd9UOUQyEFciOw5tealURERAnP19cXQ4b0x7p1P6v98uUr4PvvlyFVqlRal0ZGimGVNKd7/hIunm9+aUXw69AE4ak9NKuJiIgS3suXL1CrVhVcu3YVVlZWGDJkBHr37qe2id6HYZU0ZXP+Chy3H4hyzGdIV070T0RkhpIlS46CBQvDx8dHzZ1apkxZrUsiE8CwStoJDokSVMPSpoJ/s9oMqkREZsTH5zXCwsKQPHkKNXfq9OlzEBgYiJQpU2pdGpkItruTdqtSzVxm2A0uVQj+7RpxaioiIjNy/vxZVK78FXr16gq9Xq+Oubi4MKiS6YTVoKAgDBs2DMWLF0e5cuWwfPmbpdVisnfvXtSoUQNFihRBs2bNcPHixSStlRJQaGiU5VPDXZwRVKGMpiUREVHCkWC6fPlS1KhRCbdu3cTFixfw+PEjrcsiE6VpWJ02bRouXLiAlStXYvTo0ViwYAF27doV7XHXrl1D//790aVLF2zduhV58+ZV2zLdBZkexw1Rz7Ffr9a89E9EZCZev36Fjh3bqBH/wcHBqF69JvbvP4J06dJrXRqZKCstV6xYv349hg8fjnz58qFKlSro2LEj1qx5Oxl8hD///BM5c+ZEvXr1kDlzZvTr1w9eXl64fv26JrXTJwgPh82te1EHUxERkVk4efIkKlb8Etu2bYGtrS3GjZuElSt/RooU7lqXRiZMs7B6+fJlhIaGqsv6EYoVK4azZ88iPDw8ymOTJ0+ugunp06fVfZs2bVJ9XiS4kumwvnk3yuV//5Z12aJKRGQmZBBVy5YtcefObWTOnAXbtu1G16491aAqIpOcDUBaRlOkSAE7OzvDMelwLf1YX758CXf3t+/CatasiQMHDqB58+awtrZW87F5enoiWbJkH3yOpPr5iHge/jx+QEAgnNbuMOzqrawQnjk9jOUl4zk0bTx/po/n0PTZ2Fhj1apVmDJlGmbMmKOmqSLTojPSn0PNwqr0N40cVEXEvvRxiezFixcq3I4aNQqFChXCzz//jKFDh2Lz5s3w8Ih54nh3d2dYWydtw7GHh2uSPp+pCH/6DMGzVxj2bWp9BZtKpWGMi+rxHJo2nj/Tx3NoWo4dO4abN2+qxiTh4VEKmzdv1LosMrOfQ83Cqr29fbRQGrHv4OAQ5fiMGTOQK1cutGjRQu2PHz9ezQywceNGdO7cOcav//y5X5K2rMqJffbMB//NzEERQsPgMi3qMqovC+UDvH1gTHgOTRvPn+njOTQt0iVv0aIFmDBhjLrimSFDNuTPn5/n0MTpNPg5TJnS1XjDapo0aVSLqfRbtbF5U4a0nkpQdXNzi/JYmaaqVatWhn3pBpAnTx48fPjwg8+R1D8s8nz8AX3L6ok3nJevN+yHZs2IgMY1ASN+jXgOTRvPn+njOTR+z549Q+/eXbF37261/803dZApU2bDeeM5NH16IzuHmg2wkumnJKSeOXPGcEwGUBUoUCDaGsGpU6fGjRs3ohy7desWMmbMmGT1UtxFDqoiQFansrHWrB4iIvo0x44dRaVK5VRQlSukM2bMhafnCri6Rm1kIjKLsOro6KimohozZgzOnTuHffv2qUUBWrdubWhlleXYRJMmTbBu3Tps2bIFd+7cUd0CpFW1fv36WpVPH6Dz9Yfr5EWG/ZDPssKnf0dNayIiok8zf/4c1K9fEw8fPkCOHDmxa9dBtG7djqP9KdFp1g1AyCApCatt2rRRU1H16tULVatWVffJilaTJ09GgwYN1GwAfn5+agaAx48fq1ZZWUjgfYOrSFsu81dG2Q9sVEOzWoiIKGEEBQWq6akaNfoW06bNVn+3iZKCTh+xWK+Z8fJKugE88qZSOgh7e7NTubwArlMWR5303wTedfMcmjaeP9PHc2icQkJC1OT+QoLq/v17UKVK9RhbU3kOTZ9Og3OYKpWrcS+3SmYmJAQus96O/Pdr39gkgioREUUlwXTGjCmoXr2iYWlzGfVftWoNXvYny+oGQObFdcayKPvhaVJqVgsREcXPkydP0L17Rxw5cljty9KpTZo007ossmBsWaUEYXfoWJR93z5tNauFiIji5/Dhg6hYsawKqk5OzliwwJNBlTTHllVKEPZH/zG5fqpERPSGzHk+Y8ZkzJ49AzKUJW/efFi2bCU++yyX1qURsWWVPp3u+SvDtn+LugyqREQmZuzYEZg1a7oKqq1bt8euXQcYVMloMKzSpwkOgYvn/wy7YRnTaloOERHFXZcuPZA5cxZ4ei7HjBlz1FzoRMaC3QAo3mwu34Dj5j2G/fBkrrIWrqY1ERFR7KakOnz4ACpXrqb2M2bMhKNH/zZMU0VkTJgsKH7CwqIEVeHXoYlm5RARUezcv38P9erVRPPmjbFnz2+G4wyqZKzYskrxm/h/2hLDbnCx/Aiq+qWmJRER0cft3v0bevfuihcvXsDNLRnCwsK1LonooxhWKc4cNu2Oss+gSkRk3IKDgzFhwhgsXrxA7RcpUhSeniuQNWs2rUsj+iiGVYq90FC4Tl8a5ZDP0G6alUNERB93585tdOnSDn//fVrtd+nSHSNHjoOdnZ3WpRHFCsMqxYrVgydwXrUpyjHf7i01q4eIiGLnn39Oq6CaLFlyzJu3CDVq1NK6JKI4YVilj9K98okWVH0GdJTe+JrVREREsVOvXkM8evQI33xTB5kyZda6HKI442wA9FEu3/9k2A7NmeXNClUMqkRERunWrZto0aIxnj59ajjWrVtPBlUyWQyr9EGOa3cYtsM8UiCgcU2uUEVEZKS2bt2ESpW+xN69uzF8+CCtyyFKEOwGQB+k8w8wbPt35DyqRETGKCAgAKNGDcPKlT+o/VKlymDs2Ilal0WUIBhW6YNB1fqxl9oOrFKOq1MRERmh69evoWPHNrh06QJ0Oh369OmPQYOGwcaGf+LJPPB/MsXI5uJVOP6637AflimdpvUQEVF0x44dRdOmDeDv74eUKVNi4cKlqFChktZlESUohlWKxurR0yhBVYSnSalZPUREFLP8+fMjXbp0SJs2HRYv/gFp0qTVuiSiBMewSm+FhsL6zgM4rdtpOBRUpgiCy5XQtCwiInrr3r27yJgxk7rk7+Liik2btiN16jSwtrbWujSiRMFOiGSY9F9Wp4ocVMPSpkLw16UBG/4CJCIyBr/8sgZfflkSS5Z8bziWLl16BlUyawyrpDi9M+l/aOb08G/bULN6iIjoLV9fX/Ts2QW9e3eDv78/Dh8+CL1er3VZREmC3QAICAhCxMypIbmyIbBhdY0LIiKiCJcuXUSnTm1w7dpVWFlZYfDg4WrEv3QDILIEDKsEuxNnDduBdTiKlIjIGEjL6Zo1qzBs2EAEBgaqQVSenstRpkxZrUsjSlLsBkCw/+u0utVbW3EZVSIiI3Hr1g0MGtRXBdWKFSvjwIE/GVTJIrFl1dJF6vMUJIOpiIjIKGTPnhNjxkxAYGAQevbso7oAEFkihlUL57D9gGE7NHd2TWshIrL0y/4rVy5HiRKlkC9ffnWsc+fuWpdFpDmGVUsWEgrbC1cNu/pkrpqWQ0RkqV6/foV+/Xrj1183I2fOz7Bv3xE4OTlpXRaRUWBYtWD2R04atv2b19G0FiIiS3XmzN/o1Kkt7ty5DVtbW7Ru3Q6Ojo5al0VkNBhWLZj1jTuG7bBM6TSthYjIEi/7L1u2GGPGjEBISAgyZ86CJUtWoGjR4lqXRmRUGFYtmN7NBfB+gZACuQF23CciStJJ/nv06Izfftuu9mvVqoM5cxYgWbLkWpdGZHQYVi1RUDDs9/8Jm5v31G5YutRaV0REZFHkMr+Pz2vY2dlh7NiJaN++Myf5J3oPhlULZPvPRdidvWzYD8uaQdN6iIgs5bJ/aGio6pdqbW2NRYt+wOPHD1GoUBGtSyMyarz2a4EcDh4zbPu1b4xwjxSa1kNEZO6eP3+GVq2+xfDhgwzH0qRJw6BKFAsMqxYsuHgBhKdJqXUZRERm7fjxY6hYsRz27NmFX35Zg7t33w5uJaKPY1i1MHYHjxq2g0vzHT0RUWIJDw/HvHmzUK9eDTx8+AA5cuTEzp371ah/Ioo99lm1MNbeLwzbeldnTWshIjJXXl5e6NmzMw4e3K/2GzZsgunTZ8PFhYuvEMUVw6qFsbn+5vJTUNliWpdCRGS2LaqNGtXGv/9eUqP+J0+egWbNWnK0P1E8sRuABdH5+b/dsbXVshQiIrNlZWWFIUNGInfuPNi9+xCaN2/FoEr0CRhWLYjOL8CwHVw8v6a1EBGZkydPnuDEieOG/Ro1auHAgT+RJ09eTesiMgcMq5YiLAwOm/eoTb28w2fLKhFRgvj990OoWLEsWrf+Vg2kiiDzqRLRp2NYtRCu05bA+vlLta3T67Uuh4jI5MkE/1OmTEDjxnXh5fUUadKkQ2Dg2ytYRJQwOMDKAljfuh9l379FXc1qISIyB48fP0KXLu1x9Oifar9Vq7aYMGGqGlBFRAmLYdWc6fVwnbI4yiGfgZ0AG552IqL4OnBgL3r06Ixnz57B2dkFM2fORYMGjbUui8hsMbWYMZdZP0TZDy6an0GViOgT7dixTQXV/PkLYtmyH5E9e06tSyIya0wuZsr61j3ogkMM+z4DOwM21prWRERkDuRyf8aMmdCtWy84ODhoXQ6R2eMAK3MUGASnX7Ybdn27tmBQJSKKp717d6FLl3Zqsn8h/VL79h3IoEqURNiyaoYc9hwxbAc0rA59CjdN6yEiMkUhISGYMGEMFi2ar/bLlSuvBlIRUdJiWDVDOh8/w3Zormya1kJEZIru3r2jWlNPnz6l9jt37oYmTZppXRaRRWJYNUM2dx+q25ACubUuhYjI5OzcuR19+nTHq1cvkSxZcsyd+z1q1vxG67KILBb7rJoZq6fPDNthqT00rYWIyNTMnz8Hbds2V0G1WLESOHDgDwZVIo0xrJoZh+0HDNshJQpqWgsRkan5+uuKauBU9+698euvu5ApU2atSyKyeOwGYE70elg/8X67r9NpWQ0RkUm4ffsWsmZ907+/QIGCOHbsH6RPn0HrsojoP2xZNSPWN+9GmQWAiIjeLzAwEIMG9UW5ciVw5szfhuMMqkTGhWHVjFj5+hu2OQsAEdH73bhxDTVqVMKPP/6A4OBgHD9+VOuSiOg92A3AjFjfuKNuw9Kl1roUIiKjtXHjOgwY8B38/HyRMmVKLFiwBBUrVta6LCJKyJbV33//Xa2LLDZs2IDOnTtjzpw56t0pacfm+puwauX9XOtSiIiMjr+/P/r164Vu3TqqoFq27Jc4cOBPBlUicwurCxcuRJ8+fXD//n2cOHECo0aNQrp06bB3715Mnjw5caqkWAlP9WaqqpD8ubQuhYjI6GzatB4//bQSOp0O/fsPxoYNvyJt2nRal0VECR1W161bh/nz56NQoULYunUrSpQogbFjx2LKlCnYuXNnXL8cJRCdfwCsH3up7bAMabUuh4jI6DRv3grNmrXE+vVbMXjwcFhbW2tdEhElRlh99eoVsmfPDr1ej0OHDqFChQrquIuLC8LCwuL65SiBOC9cbdgOT+WuaS1ERMbAz88PkyaNU7fCyspKrUb11Vdfa10aESXmAKs8efLghx9+QPLkyfH8+XNUqVIFT548waxZs1C4cOG4fjn6VHo9bP+5BF3o2zcK4WlTaVoSEZHW/v33Ejp1aoOrV6/gyZPHKqQSkYW0rI4ZMwanTp3CypUr0b9/f2TIkAHLli3DgwcPMHr06MSpkt7L7vgZOOz+3bDv272lpvUQEWlJrvqtWbMK1ap9rYKq9En99tvmWpdFRIndsjp06FAMGjQIKVKkgI+Pj5oBwNbW1nD/wIEDYWdn9yl1UDzoXvnA/uAxw75/09rQJ3PVtCYiIq34+vpg4MC+amoqIaP8ZVoqmZ6KiMy8ZXXHjh2qr6po3bq1CqyRMahqw3HDb1GCali2jJrWQ0SkFWlFrVKlvAqqMnBqxIix+N//NjCoEllKy2rBggVVSM2SJYu6xNKjR48oLauRrVq1KqFrpJjo9bB++mau2zCP5AyqRGTR3Nzc8OrVS7VUqqfnCpQqVVrrkogoKcOqTFX166+/qhbVkydPqoFUzs7OCVUDxYPVw6eG7cAG1TWthYhIC4GBgXBwcFDb0jd1zZr1yJIlK9zd38w5TUQWFFalr2qbNm0M+x06dICjo2Ni1kUfYX/obV/V8JQpNK2FiCipnTnzNzp1aotRo8ahdu166liRIsW0LouItAqrW7ZsQc2aNVXf1IwZM2L37t3vfWy9em9+aVDi0b14DZu7D7Uug4goyUlXtGXLFmPMmBEICQnBrFnTUatWHTWHKhFZcFidN28eypcvr8KqbL+PLGHHsJr4nNZsMWwHNGQXACKyDC9fvsB33/XEzp3b1H6NGt9g7tyFDKpEZi5WYfXAgQMxbr9LFgmgxGfl82Y1Fr2DPUJzZdO6HCKiRHf69El06dIed+/eUQ0nY8ZMQIcOXVQjCRGZtzi/Hc2bN2+MoVQWBahUqVJC1UXvEx5u2Az4pqKmpRARJYU7d26jTp3qKqjKAKodO/aiY8euDKpEFiLWfVY3bdqktt83ddXTp0+RKhWX+UxsdodPGLbDMqXTtBYioqQgAbVt2w7q78zMmXPh5pZM65KIyNjCapUqVXD//n21feLEiRinrnJyclKPi4ugoCCMHTsWe/bsUdOPtG/fXn3E5MqVK2qp14sXL6r5XocPH47SpS1sHr3QUNgf++ftvoO9ltUQESWaEyeOqwG9Mm+qGDt2kprsn62pRJYnVmFVgmnPnj3VdoYMGVCrVq0EWbVq2rRpuHDhAlauXImHDx9i8ODBSJ8+PapXjzpoSOZ3lRBbsWJFTJkyBVu3blX1yKwEHh6WM5+ezsffsB1Qh10uiMj8hIeHY/78OZg8eTxKlCiFTZu2w8bGRn0QkWWK89RV8q52586d731sbGcD8Pf3x/r167F06VLky5dPfVy7dg1r1qyJFlY3b96sWm6lZVXeWffu3RuHDx9WQVdmKbAUTr+8GQErQj//TNNaiIgSmpeXF5o1a44DB/apfWlVDQ4OZlAlsnCaTV11+fJlhIaGokiRIoZjxYoVw+LFi9U768hTkUjXAxm8JUE1wsaNG2FprF6+frvDS2FEZEb++utPdOvWQV1lk25hkyfPQPPmrXjZn4gSduqquL6DlpWxIncnSJkyperH+vLlS7i7uxuO37t3DwULFsTIkSPV80tXBOkyIOH2Q5Lqd1zE8yTm89meOGvYDqxbiVnVBM8hJR6eP9MVFhaGOXNmYtq0SaqhIleu3Fi2bCXy5v1c69IojvhzaPp0RnoO43Vt5ffff1eX7aW/6IYNG9QAqc8//xzdu3ePdV/WgICAaI+N2JfLPu92GViyZAlat26tug3s2LFDLfn622+/IV26mEfEu7s7w9o6aSeK9vBwTbSvHbjvL8N28vJcUtAUzyElPp4/0yN/C7Zv36KCqizrvXDhwmgDeMm08OfQ9HkY2TmMc1iVXyTLli3Djz/+iBs3bmDUqFFo3Lgx9u7di1evXmH06NGx+jr29vbRQmnEvlwCikwu/8v8rtJXVUgw/vPPP9VAq65du8b49Z8/90vSllU5sc+e+UCvT+AvHhYGh3U7DScqqNIX8PX2SeAnoUQ9h5ToeP5Mm6fnCvzzzyn06NFVncOAAP6OM0X8OTR9Og3OYcqUrgkfVtetW4f58+ejUKFCavqoEiVKqOmnzp8/j44dO8Y6rKZJkwYvXrxQ/VYjOs9L1wAJqm5ublEeK/O3Zs+ePcqxrFmz4tGjRx98jqT+YZHnS+jndJ26JMp+cKG8AH8JmNQ5pKTD82cal/2nT58MJydn9O7dVx377LPc6vK/4Dk0fTyHpk9vZOcwztfJpfVUgqMsDnDo0CFUqFBBHXdxcVG/hGJLWkolpJ45c8Zw7PTp0yhQoEC0dZ5lXleZZzWymzdvqr6rZu2d/yl+HZoA9p8+ZRgRkRYeP36Ehg1rY9asaZg8eRxu3ryudUlEZALiHFbz5MmDH374AQsWLFDLrspCAE+ePMGsWbNUqIwtR0dHNXOATEd17tw57Nu3D8uXL1f9UiNaWQMDA9V206ZNVViVFt07d+5g7ty5atBV3bp1Yc6cVmwwbPv0aYfw1JYzpywRmReZjqpixbL4668/4OzsggULPJE9e06tyyIicwyrEi5PnTqlJvLv16+fat2UPqwPHjyIdReACEOHDlUDtaRTvXQl6NWrF6pWraruK1eunGE+14jnOHjwIL755ht1KwOupCuB2dLrYf3E++2+U9R+vEREpkC6ek2cOBZNmzaAt7c38uUrgH37DqNhwyZal0ZEJkKnl+v5n0gGRiXEilYJycvLJ0k7JEsHYW/vhOuQbOX9As5Lf1Hbvj1aQe/mkjBfmJLsHFLS4fkzTvLnpXHjevj994Nqv127jmrZ1HcH0QqeQ9PHc2j6dBqcw1SpEmGAlbh06ZLqCiD9RqWfarZs2dCiRQuULFkyPl+OYmB/4Khhm0GViEyRTOhfo0Yt/PPPacyePR916tTXuiQisoRuADJFVZMmTdQ75gYNGqgP+YXUvn171e+UEobNjTtal0BEFK8rbXfvvv391b59J/z550kGVSKKtzi3rMrgpgEDBqBt27ZRjsu8qzIAqnLlyvGvht4IDTVsBn1RVNNSiIhiS0Jqly7tVN/U/fuPwM0tmWrMSJs25sVbiIgSpWVVRuFHTFcVmRy7detWXL8cxUAXHGLYDi4Z+xkWiIi0snPndlSq9CVOnz6llsy+cuWy1iURkaWG1Rw5cqjlVt91+PBh85/3NInYR1paFXbx6lZMRJQkgoKCMHz4ILRt2xyvXr1EsWLFVatqiRKltC6NiMxEnJOQTC8lH2fPnlWrWAmZ2H/37t2YNm1aYtRocfSRp6myttayFCKi97p16yY6d26Hs2f/UfvduvXC8OGjjW52GCKysLAql/uXLl2K//3vf/j5559hb2+vZgOQ/YIFCyZOlRbGyuuZug0uwdeTiIyXrEIlQTVFihSYP38xqlatoXVJRGSG4nWNuUyZMurjxYsXamnUZMmSJXxlFszm9gN1q/N/s4IXEZExmjx5JsLCwjFu3CRkyJBR63KIyEzFuc9qeHg45syZg7Jly+KLL75A6dKlUb58ebWiFCWASIOrwjKm1bQUIqLIbt68jlmz3nb38vDwwA8/rGJQJSLjalmdPHky9uzZg/79+yN//vwqvJ4/fx7z5s1T8+v17NkzcSq1EM4r1hu2Qwrn1bQWIqIImzatR//+feDn54vMmbOgUaNvtS6JiCxEnMPq1q1bsWDBgiirVeXJk0fNBCDzrzKsxp/uxStYPX/19oBVnBu+iYgSlL+/P0aMGIyfflqp9r/4ohzKlftK67KIyILEOazKms62trbRjru5uanJnyn+rB97G7Z9e7fRtBYioqtXr6BTpzb4999L6vd7374DMWDAENjYcEo9Iko6cW66GzRoEIYNG4aDBw+qiZ99fX1x6tQpjBw5Em3atMHDhw8NHxQ3DrsOq9twV2fonZ20LoeILNiWLRtRtWp5FVRTpUqNdeu2YMiQEQyqRJTk4vxbRy71i27duhlaUvV6vbr9999/MXv2bLUv98k+xY7OPwC6wCC1beXjp3U5RGThZKlU6QLw5Zdf4/vvlyJNmjRal0REFirOYXX//v2JU4mFc5n7o2Hbr10jTWshIssUEBAAR0dHtV2xYmVs3LhN9VG15uIkRGRKYZVLqiY825PnDNt6B3uEp02laT1EZFnkatj//rcaU6ZMwLZtu5E1azZ1/Msvy2tdGhFR3PusUsKzevbSsO37XTtNayEiy+Lr64Pu3Tuhb9+eePLkMVasWKZ1SUREUbCnvBGw++eiug3Jkx3gjApElEQuXDivRvvfuHFdXeofOnQkevb8TuuyiIiiYFg1JmHhWldARBZy2X/lyuUYOXIIgoKCkD59BixevBylS5fRujQiooTpBnDjxg34+Pio7SNHjmDs2LFYv/7tyksUPyGFuGIVESW+tWv/h0GD+qqgWrVqdRw48AeDKhGZT1hdu3Yt6tSpo6alunTpkprC6t69e5g7d676oLjR+fgatsM9UmhaCxFZhvr1G6FYsRIYO3YSVq9eC3d3D61LIiJKuLC6bNkyTJ06VS23unHjRuTNm1cdk/lV2boad1Zezw3b+hRumtZCROZ72X/r1k0IDQ1V+/b29ti+fQ+6devJlQeJyPzC6pMnT1CsWDG1LatYVa5cWW2nTZsWfn6czD7Owt8sqBDmnpyDq4gowb18+QLt2rVEp05tMWPGZMNxzp1KRGY7wCp79uzYtm0b3N3d1ZKqElZDQkKwfPly5MmTJ3GqNGO2Z7nKFxEljtOnT6JLl/a4e/cObG1tkTIl53AmIgsIq4MHD8Z3332HV69eoXnz5siRIwfGjRuHvXv3YvHixYlTpRmzvXpL3eqCgrUuhYjM6LL/4sULMX78KHXpP0uWrFi69EcULlxU69KIiBI/rJYpUwZHjx5VswEkS5ZMHevevTuGDh2q3rlT3IRlSAvrB48RmuvNijFERJ/i+fNn6N27G/bs2aX2a9euh9mz58PN7c3vayIiswyrJ0+eRJEiRWBjY6O2P6REiRIJVZv50+tVUBVh2TJqXQ0RmQEvLy8cOXJYDaIaN24y2rbtwEFURGT+YbVVq1b4888/4eHhobbfR34hypRWFDtWj70N23o7O01rISLzkDt3HixYsARZs2ZDgQIFtS6HiChpwurly5dj3KZPY3f8jGE7LGsGTWshItPk7e2Nvn17oEeP7wwT+9euXVfrsoiItF1uVTrsP3v2DGFhYYbO/MHBwapVtWbNmglXnZmzufZmcJXCy3REFEdHj/6pRvs/fvwI165dxZ9/nuKUVERkduIcVvft24eRI0fi5cuX0e5LlSoVw2oc6ELfhP3gYgW0LoWITIg0FMydOxPTpk1CeHg4PvssF5YuXcmgSkRmKc6LAsycORNVqlTBjh074Obmhl9++UVNWZUhQwY1pRXFju2xfwzbIQVya1oLEZmOp0+f4ttvG2DKlAkqqDZp0gy7dx/C55/n07o0IiLjaFm9d+8ePD09kTlzZuTPn1+NPJWFAaysrDBt2jQ0aNAgcSo1J3o9HA4eM+yGp+NE3UT0cQ8e3EfVql/Dy+spnJycMGXKTDRt2kLrsoiIjKtlVVpTAwIC1Ha2bNkMA65kZav79+8nfIVmSPfKx7AdUKuCprUQkelInz4DSpYsjTx58qrWVAZVIrIEcQ6r5cuXx9ixY3H9+nWUKlUKW7duxcWLF7F27VqkTp06cao0M1aRwmpoQS5RS0TvJ4OnfHxeG6YHnDt3IXbtOqimqCIisgRxDqvDhw9HlixZcOHCBXX5v1ChQmjUqBHWrFmjlmIlIqKEceDAPlSsWBb9+vVWs64IWYlKugAQEVmKOPdZPXToEAYNGoQUKVKo/RkzZmDMmDFqtRQutxo71vf/W7Uq5ZvXkIjo3ekBZQDVvHmz1P7169fw+vUrJEuWXOvSiIiMv2VVugC8ePEiyjEXFxcG1TiwuXJT3Vp7R30diYhkEFW9ejUNQbVNmw747bf9DKpEZLHiHFaln+r27dvVIgAUP+Gp3NVtaKZ0WpdCREZk795d6rL/iRPH4OLiiqVLf8T06bPh4OCgdWlERKbTDUBWrvr+++/V3Kru7u7q8n9k+/fvT8j6zJLthavqNjRnFq1LISIjIbOsDBjwnbpyVbBgYRVUs2XLrnVZRESmF1abNGmiPij+9A720AUGQRcSqnUpRGQkHB0dsXjxD9i+fStGjRofrSGAiMhSxTms2tjYoFKlShyNGl96vQqqIjR7Zq2rISIN/fbbDgQFBaJevYZqv0yZsuqDiIg+oc+qjP7/4osv0Lt3b+zZswdBQW+CF8V9QYCIvqtEZFmkz/+IEYPRpk0zfPddT9y8eUPrkoiIzCesHj58GCtWrECGDBkwdepUlClTBgMGDMCBAwcQEhKSOFWaKzvOoEBkaW7fvoVvvqmCJUsWqf02bdojY8ZMWpdFRGQ+3QBEkSJF1IcsAiCrV+3evRsDBw5UXQSOHz+e8FWaEd1/gV5vG6+XnohM2LZtW1RLqqxIJXNVz5u3GNWq1dC6LCIioxbvxOTv768WCJCuAH/88QfSpEmDmjVrJmx1Zshx7Q51y8FVRJZDVp8aOnQAli9fqvZLlCgFT8/lbFElIkqMsLp582YVUP/66y+kTJlSBdSffvoJefJwnerY0Ls4Az5+0NvbaV0KESURnU4HZ2cXtd2rV18MGTKCC6kQESVWWJ09ezaqV6+OVatWoVChQnH9dItn/eipug2s9qXWpRBRIpMrUBEzp0hArVKlGkqX/kLrsoiIzDusygAraSWg+Al3cYaVrx9gba11KUSUiBP8y2j/ixfP49dfd8POzk61pDKoEhElQVhlUI0/nZ//m6AqodXtzSVBIjIv165dRceObfDvvxfV78s//jiMihWraF0WEZHlTF1F8Wf18IlhOzwl51glMjdr1/4PVap8pYJqypSpsG7dFgZVIqJPxPmTkpCVj//baas4xyqR2fDz81Oj/X/5ZY3a//LL8vj++6VIkyat1qUREVluy6qvry8uXbqkVmKRbfo4h92/q9vw5G5al0JECah//94qqFpZWWHQoGGqRZVBlYhIo7Aqy6uOGDECJUuWRKNGjfDkyRMMGTIEHTp0wKtXrxKoLDOk1xs22QWAyLxIQM2Z8zNs3LgNAwYMgTUHUBIRaRdWp0+fjuvXr6v5Vu3t7dWxXr164cWLF5gwYULCVWZmbC5cNWwH1iivaS1E9GnkatL27b8a9rNnz4EjR06gbFlOSUdEpHlYlQUBhg8fjty5cxuOyfb48ePx++9vLnNTdDZ3H77d4YIARCbrwoXzahBVhw6t8PvvhwzH2ZpKRGQkYVUGEjg6OkY7Hh4ejrCwsISqy+zYnrusbsOTuWpdChHFc8nUlSuXo0aNirhx4zrSpk0He3sHrcsiIjJ7cQ6rFStWVKtYRR5Ude/ePdUFoHx5Xt7+mHD35FqXQERx5OPzGp07t8PAgd+pfvuyEtWBA3+iVKnSWpdGRGT24hxWR40apUa8ygArWaWlYcOGqFq1Ktzc3DBy5MjEqdLE2Vy9ZdgOrMo+bUSm5Ny5M6hU6Uts3boJNjY2GD16AlavXgsPDw+tSyMisghxnmfV1dUV8+fPV62pN27cQGhoKLJly4YcOXIkToVmwP7gUcO2PgWnrSIytT6qt2/fQsaMmbBkyQoUL15S65KIiCxKrMLqw4eRBgdFGkyQK1euaI9Jnz59QtZnHgKC1E1ojsyyXq3W1RBRHDRr1hJ+fr5o1OhbpEjBaeeIiIwyrEo/VVnjOjb+/fffT63J7FgFBKrb0MwM8kTG7u+/T2Hs2JFYseInuLt7qN99nTp107osIiKLFauwun//fsP2oUOHsHr1agwdOhQFChSAnZ0dLl68iClTpqBJkyaJWavJ42IARMY92t/TcyHGjx+NkJAQTJo0HjNmzNG6LCIiixersJohQwbD9tKlSzF37lwUKlTIcKxUqVIYN24cunXrhmbNmiVOpWawcpU+mYumpRBRzF68eI7evbth9+7f1P4339TFyJFjtC6LiIjiM8BK5lmVQVXvkqmspDWCotL5+Ru2w5Mn07QWIoruxInj6NKlHR48uK+uFI0bNxnt2nWMddcnIiIysrBap04dDBo0CN999x3y5MmjLp2dP38e8+bNQ9OmTROnShNm9eTZ2x3bOL/cRJSIfvttB9q3b6kWNMmWLTuWLVuJAgXeXjUiIiLtxTk9SV9VZ2dnTJ48Gc+fP1fHUqZMiRYtWqBr166JUaNJs7lxV+sSiOg9ypT5AunTZ0CJEiUxY8ZcuLhwhTkiIpMPqzIpdr9+/dRHRFh1d+fAofexevVa3YalTKF1KUQE4MqVy8iVK7e6zJ88eQrs2nVQveHmZX8iIjNZwSoyCakMqh+me/FK3epdnLQuhciiyaX+WbOmoXz50li9+kfD8VSpUjGoEhEZMXaiTGRWL960rHLaKiLtPH36FN27d8Lvvx9U+2fPntG6JCIiiiWG1USmd3KEztePYZVII0eOHEa3bh3x9OkTODo6YurUWWjatIXWZRERUWJ1A5DR/+8T0YeVEG0GgHCP5FpXQmRxl/2nTp2IRo3qqKCaJ09e7NlzmEGViMjcw6qsUnXjxo1ox9evX48aNWrE6WsFBQVh2LBhKF68OMqVK4fly5d/9HPu37+PIkWK4Pjx4zCpeVat2CeOKCmdP38Ws2dPV2+wmzdvpQZS5c6dR+uyiIgosbsBZM+eHfXr10f37t3RqVMnFR5HjBihllzt2bNnnL7WtGnTcOHCBaxcuRIPHz7E4MGDkT59elSvXv29nzNmzBj4+7+daN+Y2Vy+AV3wfwslfKBFmogSXuHCRTFixFikSZMGjRtzDmgiIosJq1OnTkXdunUxevRo/PrrrypkVqlSBTNnzkTq1Klj/XUkcEprrCzfmi9fPvVx7do1rFmz5r1hVZ5PVtAyFbanLxi2w9LG/rUhoriTlfXksn+DBk2QM+dn6ljPnn20LouIiLSYusrNzQ0eHh549uyZ6heWLFkyODnFbWqmy5cvqz8uckk/QrFixXD27FmEh4dHe/yLFy8wffp0jBs3DqbC+t4jdRtY6QuuXkWUiB4+fICKFStixoyp6NixDZd+JiIyI3FOUNLHdOvWrahXrx48PT3x4MEDjBw5UrWGDhgwQB2PDS8vL6RIkUKtxR1BJuaWfqwvX76MNn/rlClTVPeDzz5702ISG0k1dWLE87z7fLqIS/92tklWCyXsOSTjt3fvbvTs2UUN8JQVqL77rh/s7Gy1LoviiD+Dpo/n0PTpjPQcxjmsnj59Wg2EKlWqlNqXVlW5nC/9TqXVM7ZhNSAgIEpQFRH7wcHBUY7/9ddf6nm3b98e6zrd3Z1hbf1Jax7EmYfH26Ua9WFhCPpv2y1fNlil5DKOpiDyOSTjJq2nw4cPV1dcRNGiRbF27VrkzJlT69LoE/Bn0PTxHJo+DyM7h3EOq9u2bYsWMq2srNCuXTtUq1Yt1l/H3t4+WiiN2HdwcDAcCwwMxKhRo1Qf2cjHP+b5c78kbVmVE/vsmY9hHJXMreocUYutA+DtkzTFUIKdQzJe3t7eaN26KU6ePKH2O3Xqgvnz58LXNxje/FkzSfwZNH08h6ZPp8E5TBmLxrw4h9UlS5Z88P7YzgggI3SlH6r0W7WxsTF0DZBAKn1iI5w7dw737t1D7969o3y+zEQgrbgf6sOa1D8s8nyG5/zvVq/TQQ+dYZ+MW5RzSEbLzS2ZOk9yO2fOQtSuXUe9AfbxCeb5M3H8GTR9PIemT29k5zDOYfXd+U1lgJVMX/X69es4tazmzZtXhdQzZ86oeVaFXOovUKCAaqmNULBgQezZsyfK51atWhUTJkxA2bJl41o+EZkoufKi0+lga2urPpYu/VG92c2SJavWpRERkTGF1dWrV8d4fNKkSeoPSWzJsofSMirzpsrnytrd0hd28uTJhlZWV1dX1dKaJUuWGFtmZUYCY2V9+8GbDWN6a0Jkou7cuY3OnduiTJlyGDNmgjqWIUNGrcsiIqIkkGAjkFq1aoVNmzbF6XOGDh2q5ldt06YNxo4di169eqlWUyErWu3cuROmyurZC3VrZAPqiEzOtm1bUanSl/jnn7/x88+r1ZR5RERkORJs8s/Dhw+rPmNxIa2rssiAfLzrypUr7/28D91nNP6bOic0K1t/iOJDBleOGTMcy5cvVfvFi5fEkiUrjPqKChERGUFYlYm3373cL6tKvXr1Si2XSlGFu7loXQKRybl58wY6dWqL8+fPqv2ePb/D0KEjVV9VIiKyLHEOq3KpPrKIAQ/58+ePsW8pEVFcyMIg9evXwqNHD9XiIAsWeKJy5dgP3iQiIgsPq7KK1Icm6WbLBxF9CulOJIOoVqxYhsWLf0D69Bm0LomIiEwprMpk3LLM6vXr19W0VUKv16ugeuPGDZw8eTIx6jQ51nceal0Ckcm4fv2aGjhVqlRptV+/fiPUrdsgyjR2RERkmeL8l2DYsGE4cuSImg/177//RqFChdSlOpm8/90uAhYt/E2Qt/IL0LoSIqO2fv0vqFz5K3To0EpNYReBQZWIiOLVsiotpzIfapEiRfDnn3/i66+/RrFixdTKVr///jtat27NV1Ze2P9aVkNzZ9O6FCKjJAMzhw0biJ9//kntFy1aTF2lISIiiizOTRfyx0Qm5Bc5c+bEpUuX1HaNGjVw/vz5uH45s6e3tta6BCKjc/nyv6hevYIKqjJIc+DAoVi/fqvhdwsREVG8w+rnn3+OrVu3GpZMldZVIUuu0n/+68srwlO5a1oKkTGRN7sSUKtV+xpXrlxG6tRpsHHjNhVWrfnGjoiI4tsNQC79y2V/Gxsb9O/fH127dlUT+tetWxfLli1D7dq18fDhQ9SpUyc2X87s6fzf9lMNT80JzIkiO3z4IAICAlC+fAV8//0ypEqVSuuSiIjI1MOq9EP9448/1Mox0j/14MGDanWZFClSYOPGjdi3bx+SJ0+uugIQoHvlG2mHC64SSYuqXO6Xjxkz5qBEiZJo164TB1EREVHChNV3Bz24uLioDyF9zFq0aBGbL2M5/guoev4hJgsnvztWr/4Rf/xxGJ6eK1RYdXFxRYcOXbQujYiIzG02gHeXWKX3s37irW71bs5al0KkGR+f1xgwoA82b96o9mvXro/atetqXRYREZlrWG3YsGGsLtnt378flk7n46durV76aF0KkSbOnz+Ljh3b4Natm2rg1PDhY1CrVm2tyyIiInMOq+3atYOrq2viVmMmrHze9FkNzZZJ61KIkvyy//LlSzF69DAEBwcjY8ZM8PRcjhIlSmldGhERmXNYlS4AtWrVUgOsKA44wTlZmBEjBmPp0sVqu3r1mpg793ukSMHp24iIKP5iNQKIq8rET3ialFqXQJSk6tdvBCcnJ0yYMAUrV/7MoEpEREnTslq/fn3Y29t/+rNZCNvzV9St3jbOq9kSmRR5IyurUeXN+7naL168JE6fvsirMERElLQtq5MnTzZMVUUfERJi2AxLl1rTUogS04sXz9GmTTO1GtWlSxcNxxlUiYgoIXEi0ARmFWlBgLCcWTSthSixnDx5HJUqfYldu3YiPDwcly9f0rokIiIyUwyrCUz38rXWJRAlGgmmCxbMRd26NXD//j1kzZoNO3fuQ4MGjbUujYiIzBQ7VSYwXVCQ1iUQJYpnz56hV68u2Ldvj9qvV68BZs6cB1dXN61LIyIiM8awmsBsLt9Ut+yvSubm559/UkFVBltOnDgNrVq15cp2RESU6BhWE5jt1Vvq1vrRU61LIUpQ3br1xK1bN9C+fWfky5df63KIiMhCsM9qIgnJ95nWJRB9Ei8vLwwbNhCBgYFqX5ZNlcv+DKpERJSU2LKaSEIKv5l3ksgU/fHH7+jatQOePn2iLvXLZX8iIiItsGU1kWYCCPdIrmktRPERFhaG6dMno1GjOiqo5s6dB61atdO6LCIismBsWU1A1vceGbb1zk6a1kIUV0+ePEb37p1w5Mhhtd+sWUtMmjQdzs7OWpdGREQWjGE1AVnff6xuw10YVMm0nDhxHG3bNoe3txecnJwxbdosNGnSTOuyiIiIGFYTks35q282wsK1LoUoTtKlS4eQkBDkzZsPy5atxGef5dK6JCIiIoVhNQGFZUoHm1v3EJ6ec6yS8fP19YWLi4vazpQpMzZs2IpcufLA0dFR69KIiIgMOMAqAUlQFaG5s2tdCtEH7d+/ByVLFsTevbsMxwoVKsKgSkRERodhNRHouaoPGSm51D9u3Cg0a9YI3t7eWLJkkdYlERERfRDDagLS277pVRGWIa3WpRBFc//+PdStWwMLFsxR++3bd8Lq1Wu1LouIiOiD2Gc1MVjzPQAZl127dqJ37654+fIl3NySYfbsBahdu67WZREREX0Uw2pCCgnVugKiaM6fP4vWrZuq7SJFisLTcwWyZs2mdVlERESxwrCaQPRhYWBPVTJGBQoUQqtWbeHk5ISRI8fBzs5O65KIiIhijWE1gYT//a9hW+/2ZjogIq389tsOFCtWAqlTv5lGbfr0ObCyYvcUIiIyPfzrlUD0fv5vdxgKSCNBQUEYOnQA2rRphp49OyM8/M0CFQyqRERkqtiymsBC8nPlH9LGzZs30LlzO5w7d0bt589fUIVVBlUiIjJlDKtEZmDLlo3o1683fH194O7ujgULPFG5cjWtyyIiIvpkDKsJRP/KV+sSyAIFBARg5MihWLVqudovVaoMPD2XI336DFqXRkRElCB4fTCB6H3e9FnV+QVoXQpZkNDQEBw5cgg6nQ7ffTcAmzfvYFAlIiKzwpbVBKJzclC34ZwJgJKAXq9XAdXV1Q3Llq1US6dWqFBJ67KIiIgSHMNqAtO7OGldApkxf39/DBs2EPny5UenTt0M86gSERGZK4ZVIhNx5cpldOrUBpcv/wsHBwfUrdvQMI8qERGRuWKfVSIT8Msva1C1ankVVFOnToM1a9YzqBIRkUVgyyqREfP19cWQIf2xbt3Pav+rryrg+++XMqgSEZHFYFglMlIhISGoVasK/v33oprYf/Dg4ejTpz8n+SciIovCv3pERsrW1haNGzdF2rTp1JRUffsOZFAlIiKLw798REZEVqC6ffuWYb979144fPgoypQpq2ldREREWmFYJTIS58+fRaVKX6Jlyybw8/NTx6QlNUUKd61LIyIi0gzDKpERTPC/fPlS1KhRCbdu3VRB9cGD+1qXRUREZBQ4wCqBhF+++WZDr3UlZEpev36Fvn17Ydu2LWq/WrUamDdvEVtTiYiI/sOwmkD03i/VrS4oWOtSyET8889pdOrUDnfv3laDqUaOHIsuXXqoZVSJiIjoDYbVhBASYtgMzZFZ01LIdEyePF4F1cyZs2DJkhUoWrS41iUREREZHfZZTQghYYbNsGwZNS2FTIdc7m/RojX27z/CoEpERPQeDKtESeTUqROYOXOqYV/mT509ewGSJUuuaV1ERETGjN0AiBJZeHg4Fi1agIkTxyA0NBT58hVA9eo1tS6LiIjIJDCsEiWiZ8+eoXfvrti7d7far1evAcqWLad1WURERCaDYZUokRw7dhRdu7bHw4cPYG9vj4kTp6FVq7Yc7U9ERBQHDKsJwMrH9+0OgwgBWLp0EUaNGoawsDDkyJETy5atQr58+bUui4iIyORwgFVCCI+0EgDDKgHIkCGTCqqNGn2LvXt/Z1AlIiKKJ7asJqBwV2etSyAN+fi8hqurm9quWfMb7Ny5D8WKleBlfyIiok/AllWiTyQtqDNmTEHp0kXx6NFDw/HixUsyqBIREX0ihlWiT/DkyRM0aVIP06ZNgpfXU2zevFHrkoiIiMwKuwEQxdPhwwfRrVtHeHt7wcnJGdOmzUKTJs20LouIiMisMKwSxZFM7D9jxmTMnj0Der0eefPmw7JlK/HZZ7m0Lo2IiMjssBtAArB68erNRni41qVQEli8eCFmzZqugmqrVu2wa9cBBlUiIqJEwpbVBKC3epP5rfwCtC6FkkD79p2wc+c2dOrUFfXrN9K6HCIiIrPGltUEFJYxrdYlUCIICQnBmjWrEP5fy7mTkxN27NjLoEpERJQE2LJK9AEPHtxH587tcPLkcTWQqk+f/uo4p6QiIiJKGmxZTQC64GCtS6BEsHv3b6hYsawKqjLZf/bsObUuiYiIyOJoGlaDgoIwbNgwFC9eHOXKlcPy5cvf+9hDhw6hbt26KFKkCGrXro39+/fDWFi9fK1udQFBWpdCCSA4OBijRg1Dq1bf4sWLFyhcuAj27z+C2rXral0aERGRxdE0rE6bNg0XLlzAypUrMXr0aCxYsAC7du2K9rjLly+jZ8+eaNiwIbZs2YKmTZuiT58+6rgx0Nvbv7m1Y68KU3f37h3UqVMNixcvUPtdunTH9u17kTVrNq1LIyIiskiapSt/f3+sX78eS5cuRb58+dTHtWvXsGbNGlSvXj3KY7dv347SpUujdevWaj9Lliw4cOAAfvvtN+TJkwfGItwjhdYl0CeSltQLF84jWbLkmDdvEWrUqKV1SURERBZNs7AqraIyubpc1o9QrFgxLF68WI26tvpvOihRv359NSL7XT4+PklWL5kvmS81YsBUoUKFsWjRD+rSf6ZMmbUujYiIyOJpFla9vLyQIkUK2NnZGY6lTJlS9WN9+fIl3N3dDcdz5MgR5XOlBfbo0aOqO8CHJNmAbd3bGw4SNy23bt1Ejx5dMHnyNFSq9JU6f3XqsG+qqYn4uePPn+niOTR9PIemT2ek51CzsBoQEBAlqIqIfRng8j7Pnz9Hr169ULRoUVSqVOm9j3N3d4a1ddJ0yQ32fg6ZgdPO3gYuKV2T5Dnp061btw4dO3ZULfTDhg3EsWPH4OHB82fKeP5MH8+h6eM5NH0eRnYONQur9vb20UJpxL6Dg0OMn+Pt7Y127dqpy7bz5s2L0lXgXc+f+yXZOwN7GxvYyuTxj5/htTe7Jhi7wMBAjBw5FD/++IPaL1WqDJYuXa66Ajx75gO9XusKKa7kZ11+ufL8mS6eQ9PHc2j6dBqcw5SxaOTTLKymSZNGDWaRfqs2NjaGrgESVN3c3KI9/smTJ4YBVqtWrYrSTeB9kuqF1v/XDyAsa0b+gBq5GzeuoWPHtrh48bwKpzLJ/6BBw2Br++b/oJw/nkPTxfNn+ngOTR/PoenTG9k51Cys5s2bV4XUM2fOqHlWxenTp1GgQIFoLaYyc4BcrpXjElRTpUqlUdVkyi5f/hc1alSCn5+v6h+9cOFSVKjw/q4kREREZMFh1dHREfXq1cOYMWMwadIkPH36VC0KMHnyZEMrq6urq2pp9fT0xN27d7F69WrDfULuk8cQxUauXLlRunQZ1Q1g0aJlSJs2ndYlERER0UdoOov90KFDVVht06YNXFxc1MCpqlWrqvtkRSsJrg0aNMDu3btVwGjcuHGUz5cpraZMmaJR9WQKrl27ivTpM8DZ2Vm1zC9ZsgJOTjL4zlrr0oiIiMjYw6q0rk6dOlV9vOvKlSuG7ZhWtSL6mF9+WYMhQ/qjbt0GmDv3e3XM1TV6f2giIiIyXlwflMyOr6+vCqnr1v2s9h88eKBa5t83ywQREREZr6SZiJQoiVy6dBHVqn2tgqpc9h86dCTWrdvMoEpERGSi2LJKZkHm3l2zZpWa3F9aUWXwlKfncpQpU1br0oiIiOgTsGWVzMLLly8wceIYFVQrVaqCAwf+ZFAlIiIyA2xZJbOQIoW7mjf14sUL6NGj9wdXNyMiIiLTwbBKJnvZX5ZLTZ06DWrVqq2OVaxYWX0QERGR+WBYJZPz+vUr9OvXG7/+uhlubslQrFhxTvBPRERkphhWyaScOfM3OnVqizt3bsPW1hYDBgxGmjRptS6LiIiIEgnDKpnMZf9lyxZjzJgRCAkJQebMWdRqVEWLFte6NCIiIkpEDKtk9EJDQ9GxYxvs3LlN7deqVQdz5ixAsmTJtS6NiIiIEhnDagKw8n6udQlmzcbGBunTp4ednR3Gjp2I9u07Q6fTaV0WERERJQGG1QSgC9e/ufUP0LoUsxEeHg4/P1+4urqp/dGjJ6BFizbIly+/1qURERFREuJklAlAb2+rbsM9eFk6ITx//gytWn2LVq2aqi4Awt7enkGViIjIAjGsJiC9nZ3WJZi8Y8eOomLFcti7dzdOnz6Jc+fOaF0SERERaYhhlYzmsv/cuTNRv35NPHz4ADly5MRvvx3gaH8iIiILxz6rpDkvLy/07NkZBw/uV/uNGn2LadNmw8XFRevSiIiISGMMq6S57t074vDhg3B0dMTkyTPQrFlLjvYnIiIihd0ASHPjx09B4cJFsHv3ITRv3opBlYiIiAwYVinJPXnyBFu3bjLs58mTVwVVuSUiIiKKjN0AEoDO11/rEkzG778fQrduHdX0VGnTpkepUqXVcbamEhERUUzYspoArJ69VLe60DCtSzFaYWFhmDJlAho3rgsvr6fIlSs3UqRIoXVZREREZOQYVhNAeDLXN7fOjlqXYpQeP36Ehg1rY9asadDr9WjVqi127TqoAisRERHRh7AbQEJysNe6AqNz4MA+9OjRCc+ePYOzswtmzpyLBg0aa10WERERmQiGVUpUN29eV0E1f/6CWLbsR2TPnlPrkoiIiMiEMKxSgpNL/REDpjp06AJ7ewc0btwUDg4OWpdGREREJoZ9VilB7dnzG2rWrAQfn9dqX0Kr9FFlUCUiIqL4YFilBBEcHIzRo4ejZctvcfr0KSxYMEfrkoiIiMgMsBtAArD2eg5LdvfuHXTp0k6FVNG5czf06zdY67KIiIjIDDCsJgC9jQ10oaHQW1teQ/XOndvRp093vHr1EsmSJcfcud+jZs1vtC6LiIiIzATDagKQoCr0Ls6wJKtX/4j+/Xur7WLFimPJkh+RKVNmrcsiIiIiM2J5TYEJLTjk7badZWX/6tVrIV269OjevTd+/XU3gyoRERElOMtKV4khLNywqXcy/xWs/vnnNIoUKaa2U6VKhSNHjsPNLZnWZREREZGZYssqxUpgYCAGDeqLatUqYP36XwzHGVSJiIgoMbFllT7qxo1r6NixLS5ePK/27927q3VJREREZCEYVumDNm5chwEDvoOfny9SpkyJBQuWoGLFylqXRURERBaCYZVi5O/vjxEjBuOnn1aq/bJlv8SiRcuQNm06rUsjIiIiC8I+qxSj06dPqqAqy6X27z8YGzb8yqBKRERESY4tqxSjL78sjxEjxqJw4SL46quvtS6HiIiILBRbVknx8/PD4MH91NKpEXr37sugSkRERJpiyyrh338voVOnNrh69QrOnz+HHTv2qsv/RERERFpjy6oF0+v1WLNmFapV+1oFVemTOmLEGAZVIiIiMhpsWbVQvr4+GDiwr5qaSsh0VDItlUxPRURERGQsGFYtkPRL/fbb+rhx4zqsra0xdOgo9OzZB1ZWbGgnIiIi48KwaoFSp04DJydnZMiQEZ6eK1CyZCmtSyIiIiKKEcOqhfDxea0CqrSkOjg44Mcf18DZ2Rnu7h5al0ZERET0XrzuawHOnv0HlSp9iRkzphiOZcqUmUGViIiIjB7DqpmP9l+2bDFq1aqC27dvYcOGtWoZVSIiIiJTwbBqpl6+fIF27Vpi2LBBCA4ORs2atbF372E4OTlpXRoRERFRrLHPqhk6ffokunRpr0b929nZYcyYCejQoQvnTyUiIiKTw7BqZl6/foUmTeqrAVVZsmTFsmUrUahQEa3LIiIiIooXdgMwM25uyTBu3CTUrdsA+/cfYVAlIiIik8awagaOHz+GU6dOGPabN2+FJUtWqOBKRET0Pq9fv8b8+bPRuHEdVKpUFi1aNMK6df9DeHh4nLqeySBecfz4cZQtWxzlyr35KF++FBo1qo3//W8VkoK/vx9++237Bx8TFBSE9u1b4NWrl1GOT5w4RtX84MH9aJ8j38POnduiHZdjcl9Cv6Yf8+rVSwwfPhBVqnylnmf37p0ffPyuXTvQrFkDVK1aHkOHDsCzZ96G+2Rcy8KFc1G/fk1Ur14BPXr0wNOnTwz3Hz580HA+Iz5GjBik7jt58hjGjh2BxMawasLkP/68ebNQr14NdOrUFs+fP1PHpW8q+6cSEdHHAk/nzm1w5cq/GDJkJFavXof27Ttj1aoVmDt3Rqy/Tp8+3Qx/fyJs3bpLfaxduxV9+vTHjz/+gP379yCx/fLLGuzY8esHH/PTTz+ibNmvkCxZ8igB9vffD6rFciTYaf2afszEiWPh6+sHT8/laNOmPaZOnYBLly7E+Njjx49i8uRxaNToWyxduhJOTo4YMKC3ITz/8IOn+t5HjRqPRYt+QGhoKIYNG6hmFBK3b99E2bJfGs6pfAwePFLdV6JEaXh5PcXff59CYmKfVRPl7e2Nnj0748CBfWq/VKkyajAVERFRbCxevAC2traYOXM+7O3t1bH06TPA3t4BQ4f2R8OG3yJz5izx+toeHikN22nTpkWVKtWwf/9eVKpUFYkpImC9j0zfuH79L/jpp3VRjh879qd6LerXb4SNG98EzPg0+iTmaxpBWn7/+usI1q//FenSpUf27Dlx4cJ5bN68AZ9/nh/v2rhxLapUqa6eWwwaNBz169fCyZPHVXaQlmh5Q1GkSDHItzx+/Hh8+eWXuH//npqT/c6d2+o5Ip/TyOQ1W7nyBxQtWhyJhS2rJujo0T9RsWJZFVRlNarZsxdg0aJlcHFx1bo0IiISEpqCQ5L24yNBLTK59Ltv3x40bNjEEKoiSCva3LmLkDZtOrV/69ZN9OvXU11yrljxC3Tv3tFw2T/iEnjv3l1VC937ODg4RtmXy8wjRw5BjRoVUatWJcyZM13VFOHChXPo1q0DKlcupy5zb9mywXDf48eP0bdvD1Sp8iW++aYKZs+eploD5ZL8ihVLcebM3+pSdUz27PlNhcWUKVNFOb53724ULFhEtbg+evRQfY24istrGpm0Sr57mT3iI6YWy4sXL6hl0yWoRihYsLB6zWLy8OGDKCFWgrO0IMvjpXV15MhxKFEi+rLrfn6+hpZVCa3vU7r0Fzh37gzu3r2NxMKWVRMi/6nmzJmBadMmqe1cuXKrJv28eT/XujQiIoqg18Np9RZYP3icpE8bmjEtAlrWk75gsWqdCwjwR548+aLdJy2KEa1k8rdm8OC+Ksz07z8Evr6+mDVrKhYtmoepU2dj6dJVqF27CiZOnIaSJUvj0aPogUXCrnQB6Nt3oNoPCQlB797dkClTJixYsETNCy6XsQEdvvtugArCcv+33zbH0KEjVTibOXMKUqTwQPnyFTBnzjQ4OjphxYr/4cWL56r/ZJYs2VCrVm3cvHlDhTCp532XxN8NZtLaevToH+jXb7AKZVmzZlOtjdLSGBexfU3fVaBAIXVpPSYxjT159sw7WthOkcJdXY6Pybv3yTn19vZSXRasrKyivR6rVq1C8uTJkSPHZ6qlWqbBlNdNujKEh4ehQoXK6Nixq2pBFs7OLsiT53M1fiZz5qxIDAyrJkT+s589e0b9R2vatAUmT54BZ2dnrcsiIqJ36I182ICvr4+6dXFx+eDjpC9nvXoNUb9+Yzg6vmkdrVHjG8OAqRQpUqhbV1e3KIvOSKunCAsLUy2OBQoURMmSZdSx48f/grf3UyxZ8iPc3NzUMQmKEoo7d+6Obds2q8aYLl16qPskAEmAleeUsPro0SPkzp1HtVJmzJgJ06fPVc8vLYZSo42NzXsvWV+9elmFrciOHDmkWmalVVV89VUFteKj1CRXLxP6NX2XhL731RuToKDAaN3+ZF/eBMSkUqUq8PT8XrXuSqiUPrvSxzgkJDTaY+W1WL58OQYMGKrqevz4EQID3zzf+PGT8fDhQ9X3Vv5fyBuLCFmzZlevbWJhWDUB8s4mYtDU3LkLUa9eA9VHhIiIjJBO96aFM4YwkKhsbWLVqiqSJXvTYidzcn+IhL969RqpQUeXL19Sl3qvXLkCd3f3D36etHoKaYmTy/bSl3PQoO8wf76nCp7SghkRVIWEWQm2Dx7cw+3bt/H551FbJ+X+rVs3qu0WLVpj0qSxalBQqVJfqH6wuXLlidX3La240moY2b59u1XrZsTx8uUrYtWq5Th8+ACqVaupjkkAjmk0vxyT++Lymr7r7Nl/1ICnmMyYMS/aFJQSHCN3mRCyL2E9JrVr18eNGzfQo0cntf/11xVRpkzZaI1dv/9+CKNHD0XLli1Rp0491atE3hDs3LlfvRmQDPLZZ7mh14dj3LhR6NWrL6ytrQ3f+/XrV5FYGFaNmPzgTp8+Wf1gS59U+Y+SPHkKBlUiImMnodHuzWVSY5Q+fUbVAiij1vPmjX7ZesiQfmpATr58BdCpU2s1cr5cua9QuXI1FVh//vmnD359afGMIC2j0uratWt73Lx5HXZ2UftzirCwcMNtTIOF5XjEY6pWrYFixUqoVsC//voDI0cORosWbVSr7MfI31H52xpBLoXLQCM5JtNsRSZdASLCqowJiejD+W5rasR4kdi+pu9eds+TJ68h3L8rVaqol/tFypSpo82+IPseHh4xfg0JlP37D0aPHn0QHBykuhbIOY1chwT28eNHqVb0YcOGwdv7TStxTF0RpMuFfB2ZoiuiZV1Cu3QpSCwcYGWkpOm9YcPamDVrGjZtWq8GVRERESUEaQ2UFkkZ+f7u5eM//vhdfUi/yH/+Oa36N86btxjNm78JOE+ePP7oqPt3RTxeAqcMcLp3765acTHCxYvnVKiSgT9yv/RTjUzujxhF7+m5EM+fP1ctvtOmzUHHjt1UK6j42Ah+6fca+XkPHTqgalu4cClWrFhj+GjatKUa3BQx32iOHG9G3L/r0qWLqrUxLq/pu6RFVMJ9TB8xtZbmy5dfZYTIc6HKACd5YxGTtWvXYPXqH1WXBgmeMpvQ1atXDH1yZZ52CaoyMKxfvzfzp0aQvqo1a1ZSXQEiXLt2VbWkRgTViNDv7h5zWE4IDKtGSEb5V6jwhXrHKB2XpVX1iy/KaV0WERGZEZmeyc/PT430l1AqA4S2b9+iJsdv3LgZsmXLrkJJQECAasWUUfLbtm2JFsakq8CtWzfU4KvIg4AiPi5f/hfffz9PLQEuoU8Cr0znJAHpxo3rKhTOnj1dTa/k6uqq+sdKIJJQKoN7pIVTGm0aNGisvra07MoMANevX1MDqmTaqYjAKLMOSBiTWmOSK1cu3LhxLUqLokzfJKPpZXqmiA8ZFyLBN2KyfbmiKa+BTNEkUzpJ3cuXL8Gff/5uqCu2r+mnypAho+r/K6+fvAby9WU2g4g6pJVYXveIc5QuXQasWbNSvc7yeo0cOUhlCvk+pa+uzMFauHAx1Totn+fl5WX4fOl+ITMbTJkyXr3u0nD2/fdz1RuXyOT1iG1XjPjQ6eP69shEeHm9bcJOVAFBcJ2zXG36DukCvS7++V/+00yZMkFN9C/kXdKyZT+qEXmUuOTNeMqUrurSh3n+RJg3nj/Tx3OoDWklldB14sQxvHr1ChkyZFCXgqXVMqI/otwvYVH6RUrY/Oabuiq8bNq0A6lSpVahcu3a/6nxFN98UwOtW78NMhL45DJ5yZKl0LlzDxW0IqZTksApAcrJyRlVq1ZX90dM+SStfRKKZCaBNGnSqpZOqUvIDAAyO8CpUydVMPvii7Lo23ew6nMq4VCCorQGb9iwTY2Ej+zXXzerKa4WL16uHtOgQS2MHz9VDdx6l8wyIOHuf//baFitacWKZSpIy/clg8BkVHzhwkXj/Jp+qhcvnqtzcPLkCTU4q3PnbirsCwnqMt2XtIZHzECwevUKNWhMBkZ99dXXanCUvO7SWty1a7sYnyPi8+U1mDdvpmrtlu4cspx7u3adDK3YMpuCTD+2Zs0G9SYkrlKl+vi0mwyrRhRWO3Zso36QRLt2HTF27KQ4jUSk+OMfStPG82f6eA5NnymcQ+l32rDhN/jxx59jnPPU0unicQ6l5XvXrp2YO/f7eD1nbMIquwEYEQmo8s5w2bKVmDp1FoMqERFRApKuddLNYOvWTVqXYja2bt2Eli3bJOpzMKxqSPqDyJQVEWQOtNOnL6BOnfqa1kVERGSu2rTpoMaEyKAg+jQyACtNmjQxroCVkDh1lUak03iXLu1w+fJl7Nt32NAvVeYyIyIiosQhVy1XrvxZ6zLMQqlSZdRHYmPLqgZ27tyOSpWkFfWUmuri/v37WpdEREREZJTYspqEZBSeTDWxZMkitV+sWHF4eq4wzB1HRERERFExrCYRWYWqU6e2hj6q3br1wvDho2NcqYOIiIiI3mBYTSI//7xaBVVZ8WH+/MVquTgiIiIi+jCG1SQyYMBQtY5uz57fGSZFJiIiIqIP4wCrRHLz5nX07dvTsNyZra0tJk+ewaBKREREZCphVQYcDRs2DMWLF0e5cuWwfPmblaBicunSJTRu3BiFChVCw4YNceHCBRgrWZauUqWvsGbNKsycOVXrcoiIiKJp1Ki2Wnr0XXJM7tPaDz94omfPzlqXQZYeVqdNm6ZC58qVKzF69GgsWLAAu3btivY4WXe2c+fOKtRu2rQJRYoUQZcuXdRxYxIQEIB+/Xqha9cOakm3MmXKok2b9lqXRURERGSyNAurEjTXr1+P4cOHI1++fKhSpQo6duyINWvWRHvszp07YW9vj0GDBiFHjhzqc5ydnWMMtlq58vwpqlWvhJ9+WgmdTod+/QZh48ZtSJcuvdalEREREZkszQZYycpNoaGhqpU0QrFixbB48WKEh4fDyuptjj579qy6T0KgkNuiRYvizJkzaNCgAbS248YltN75P/iHhiBVqtT4/vulKF++gtZlERGRhvz8/N57n7W1tVpJKTaPlb+Hjo6OH32sNOIktHPnzmDRovm4evWy+ttbuHBRDBkyCilTplR/w2fOnILffz+I4OBgFC1aHJMnT4S1tRP0ej1Wr16Bbdu2wMvrKZIlS466dRugffs3l/Xl8n6OHDnx119/IiwsFD/9tA5PnjzBtGkT1XPly1cAWbNmS/Dvh0yTZmHVy8tLTeMUeZ5R+c8v/VhfvnwJd3f3KI/NmTNnlM/38PDAtWvXPvgc/2XbxGVjhVweqWGls8KXX36FRYt+UOvkkmmJ+L+SJP9nKMHx/Jk+czyH2bKle+99lStXxc8/bzDs58uX471d2774ohy2bt1p2C9ePD+ePXsW7XFeXq/jVef7XnPpzjZo0Hf49tsWGDVqHLy9vTBp0jj89NMK9O07EBs3rsWZM39j9uyFKnjPmDEZkyZNwqhRE7Br1w6sW/czxo6dqAYWHzv2F2bMmIJy5b5C7tx51HNK39jZsxfA1tZODUKW5ypUqDCGDh2J06dPYs6cGShYsJBZ/Z8wdjoj/Tm00bJ/57sT4kfsyzu02Dz23cdF5u7uDGvrpOnlkLxzSxypVgYFGtVR75bJdHl4uGpdAn0Cnj/TZynn0M7OBilTxu57tbW1jvLYiKuM74rt14sgfyMlYM6ZMz3KcWkxTZUqFZydbdCjRw+0a9fuv+fMg3/+qY5z586p53r50htOTo7Il+8zJE+eHDNmTFeNTXIOc+XKhqlTp+Drr79WX7NAgdxYufIHeHk9QNmyJWBra4MKFSqgQoVy6v5Dhw7h9etXqmXWyckJxYoVwMWLZ/H8+fM4f19kfj+HmoVV6YP6btiM2I98aeRDj333cZE9f+6XZO8MdJ9lQ+HSBfHsmQ/0+qR5TkpY8n9Ffjh5Dk0Tz5/pM8dzePv2o/feJw0b3t4+hv1Ll258sBtA5MeeOnU+xsdFfkxshIWFo2PHLihfvmKU44cPH8CmTRug0zngq6+qYOHCxbh27Spu3bqF69evqtZOea6qVb/Btm3bUbZsWRQpUkx1f2vVqpk6hzlz5sPFixcwfvxk3LlzC1evXlFXSV+98lefGxISCnf3VIaaz569iIwZM8HfPwz+/m+OZc+eC0+e/BHn74tM6+cwNm9GNAurcqn8xYsX6h2cjc2bMuQ/sgRQNze3aI/19vaOckz2U6dO/cHnSOpfePJ85vJL1lLxHJo2nj/TZ07n0Mnpw31II3+fCfHY+LxuyZO7I0OGTNGOiadPn6Jjx1bInTsvihcvhdq16+Ovv/7AxYvn1XNly5YDGzZsU8f++usIFi9egIMH92Lu3MXYtm0r5s2bhdq166ow3KPHd+jdu6uhTvmQy/+Ra5Z+rpH3bWxszer/gynRG9nrrllYzZs3rwqpMkhKpqQSp0+fRoECBaIMrhIyt+rSpUvVf2S5FCG3f//9N7p2ffMfn4iIiBKWDJxydU2GadPmGI5t2LDWsP3bb9tVl7xKlaqiYsXKKsR26dIOL148x5YtG9GuXUc0b95aPdbHxwfPnz9Tf79jIsH33r278PX1hYuLizp27dqVRP8eyTRoNnWVjGysV68exowZo/q/7Nu3Ty0K0Lp1a0Mra2BgoNquXr26Wqp04sSJuH79urqVfqw1atTQqnwiIiKz5uaWDE+ePMapUyfw4MF9/PTTj6qLQES3PBmANXfuTHX/w4cPsGfPb0ibNq0a+Z8sWTJ1/O7dO7h8+V+MHj1UXUkNCYl5rEmJEqWQJk1aTJkyDrdv31KDr/bv35vE3zEZK00XBRg6dKiaY7VNmzYYO3YsevXqhapVq6r7ZEUrmV9VyLssT09P1fIqU1XJVFZLlixRnbCJiIgo4VWsWAXVqtXAiBGD0bFja/z99yn07Pmd6oMqgbVBgyaoXr0Wxo8fhZYtG6uW0EWLFqn+uH36DFBTbLVt2xzDhw9Ezpyf4auvKqi+qzGRK63SgistsO3bt8TmzRvQoEHjJP+eyTjp9O9rkzdxXl4+SdohWToISydw83w1zR/PoWnj+TN9PIemj+fQ9Ok0OIepUrkad8sqEREREdGHMKwSERERkdFiWCUiIiIio8WwSkRERERGi2GViIiIiIwWwyoRERERGS2GVSIiIiIyWgyrRERERGS0GFaJiIiIyGgxrBIRERGR0WJYJSIiIiKjxbBKREREREaLYZWIiIiIjBbDKhEREREZLZ1er9drXQQRERERUUzYskpERERERothlYiIiIiMFsMqERERERkthlUiIiIiMloMq7EUFBSEYcOGoXjx4ihXrhyWL1/+3sdeunQJjRs3RqFChdCwYUNcuHAhSWulTz+Hhw4dQt26dVGkSBHUrl0b+/fvT9Ja6dPOX4T79++rc3j8+PEkqZES7hxeuXIFzZo1Q8GCBdXP4LFjx5K0Vvr0c7h3717UqFFD/QzKubx48WKS1krvFxwcjG+++eaDvxuNKcswrMbStGnT1IlauXIlRo8ejQULFmDXrl3RHufv74/OnTurH+RNmzapH9IuXbqo42Qa5/Dy5cvo2bOn+uHcsmULmjZtij59+qjjZPznL7IxY8bwZ88Ez6GPjw/at2+PnDlzYtu2bahSpYr6mXz27JkmdVPcz+G1a9fQv39/9fdv69atyJs3r9oOCAjQpG6K+oajX79+6hy9j9FlGZm6ij7Mz89PX6BAAf2xY8cMxxYuXKhv2bJltMeuX79eX7FiRX14eLjal9sqVaroN27cmKQ1U/zP4fTp0/UdOnSIcqx9+/b6WbNmJUmt9GnnL8LWrVv1TZs21efKlSvK55Hxn8OVK1fqK1eurA8NDTUca9Cggf7QoUNJVi992jlcsWKFvn79+oZ9Hx8f9bN47ty5JKuXort27Zq+Tp06+tq1a3/wd6OxZRm2rMaCtKiFhoaqdxYRihUrhrNnzyI8PDzKY+WY3KfT6dS+3BYtWhRnzpxJ8ropfuewfv36GDBgQIytPWT850+8ePEC06dPx7hx45K4UkqIc3jixAlUqlQJ1tbWhmMbN25E+fLlk7Rmiv85TJ48Oa5fv47Tp0+r+6R1zsXFBZkzZ9agcor8s1WqVCmsXbsWH2JsWcZGk2c1MV5eXkiRIgXs7OwMx1KmTKma0l++fAl3d/coj5VLV5F5eHh8sLmdjOsc5siRI8rnyrk7evSo6g5Axn/+xJQpU9Sbjs8++0yDaulTz+G9e/dUX9WRI0fiwIEDyJAhAwYPHqz+eJJpnMOaNWuqc9e8eXP1psPKygqenp5IliyZRtWTkPMRG8aWZdiyGgvSxybyD6eI2JdOyrF57LuPI+M9h5E9f/4cvXr1Uu8opaWHjP/8/fXXX6o1p3v37klaIyXcOZR+cUuWLEGqVKmwdOlSlChRAh06dMCjR4+StGaK/zmUqxsSeEaNGoV169apAatDhw5lv2MTEWBkWYZhNRbs7e2jnaCIfQcHh1g99t3HkfGewwje3t5o06aN9OvGvHnzVMsAGff5CwwMVH8cZeAHf+ZM92dQWuJkQE7v3r3x+eefY+DAgciaNasaqEOmcQ5nzJiBXLlyoUWLFsifPz/Gjx8PR0dH1Z2DjJ+9kWUZ/vWNhTRp0qh3idJXJ4K8Y5ST5ubmFu2xEnIik/3UqVMnWb30aedQPHnyRP2SlR/OVatWRbvMTMZ5/s6dO6cuIUvIkX51EX3rOnXqpEIsmcbPoLSoZs+ePcoxCatsWTWdcyjTVOXJk8ewL2/2Zf/hw4dJWjPFj7FlGYbVWJB3+DY2NlE6FstlxgIFCkRrbZP5yP755x/VGifk9u+//1bHyTTOoVyC7Nixozr+008/qR9aMo3zJ/0c9+zZo6Yci/gQEyZMUNOPkWn8DBYuXFjNsxrZzZs3Vd9VMo1zKKHmxo0bUY7dunULGTNmTLJ6Kf6MLcswrMaCXLqoV6+emrNRWm727dunJkJu3bq14Z2lXH4U1atXx+vXrzFx4kQ1ElJupe+HTIxMpnEOZRDA3bt3MXXqVMN98sHZAIz//EkLT5YsWaJ8CHnDIYMDyDR+BmUwo4TV+fPn486dO5g7d65qMZd+j2Qa57BJkyaqr6q8YZRzKN0CpFVVBj6ScfIy5iyjyYRZJsjf318/aNAgfeHChfXlypVTc8hFkLnKIs89dvbsWX29evXUfHSNGjXSX7x4UaOqKT7nsFq1amr/3Y/BgwdrWD3F5WcwMs6zaprn8NSpU2qezvz58+vr1q2rP3HihEZVU3zP4bp16/TVq1dXj23WrJn+woULGlVNsfndaMxZRif/aBOTiYiIiIg+jN0AiIiIiMhoMawSERERkdFiWCUiIiIio8WwSkRERERGi2GViIiIiIwWwyoRERERGS2GVSIiIiIyWgyrRERERGS0GFaJyKQMGTIEuXPnfu/H8ePHNanr/v376vnlNj5kadFixYqhePHi8PX1halr1aqV+p5EcHCwWnozpvuCgoLQvXt3FCxYUB0nInoXV7AiIpPi4+NjWL96586dam3yDRs2GO5PliwZ7OzskrwuCamVKlXC/v37kTFjxjh97qtXr1CyZEmMHz8eZcuWRYYMGWDqXr58CVtbWzg7O2Pz5s0qnB44cCDafbK+fN++ffHzzz8jderU6oOIKDKbKHtEREbO1dVVfURsW1tbI1WqVDBlES2pZcqUMYugKpInT27YfrdNJPJ98uYjZcqUyJ8/f5LWR0Smg90AiMisnD59Gs2aNUOhQoVQuHBhdOrUCU+fPlX3bdq0CRUrVozy+IhL0nI5ulq1ahg6dKjhvsGDB6Nhw4YICwuL9jwhISGqJVQu23/11Vc4fPhwlPtfv36NgQMHomjRoihXrpx6bESL8LstshE1Va5cWXVzEOvXr0f16tVViCtVqhTGjh1rqEMeE/G4CBFdIG7cuKE+Z8uWLYZL8PJ9TZo0KcbXSz5Pnkueu0iRIujfvz/8/PwM9//zzz/q9ZTXUuqUFtAIDx8+RPv27dXnSdCW71Fel8ivq9Qkr+mDBw8M3SQi7pPzId+HfB25T/Y/9DWJyDIxrBKR2ZBWui5duqhL6du3b8cPP/yAu3fvYsmSJR/9XHt7exUIJeSdO3cOf/31F3bs2IHJkyer1tt3Sdg6ePAgFi1ahLlz52LVqlVR7h8+fLiqR8Ld999/j/Pnz2PcuHHRvk66dOlUWBRyK5934sQJTJgwAf369cOuXbtUXdLVQboYfEyOHDnQuXNnzJgxQ7XYLly4EOHh4epS+/tI/SNGjFDfw9WrVzFq1Ch1XIJvmzZtUKJECRUke/XqhalTp2Lv3r3qfgmSTk5O6jWT59m9e3eUvqlCQuewYcOQNm1a/PHHH+r7jVCzZs0o98l+bL4mEVkWdgMgIrMhLZcyWKddu3bQ6XTIlCkTqlatqsJnbJQuXRr16tXDxIkT8ezZM3Tr1g25cuWK9ji5rC3BUlpeJcgJCV0SEoUEZOmLKaEzosuChDD52tLKGHFMSBB2d3dX23Ir90lYkxqkdiF9YFesWIFr164Zjn1I165d8dtvv6ngKwFX+vU6Ojq+9/HS+vz111+rbfkcadkcM2aMComff/65Cs0ie/bsKsAuW7YMVapUUa2l+fLlQ/r06ZElSxb1psDNzS3K15b+w+/rruHg4BDtvth8TSKyLAyrRGQ2JPBIIPzxxx/x77//4vr167hy5Yq6FB9bEkDlsnmKFCkM4fNdL168wPPnz5E3b17DsQIFChi2JdBJa6Z0D4hMjt25c+ej/TPlfgly8+bNM3wP8nnSnSA2JCBKa6xcbpduDDJ460Mivz7y3NLd4NatW+r7kFH677aU/vLLL2q7Y8eOKqRLS6t8r9IyKuH2UyTG1yQi08ZuAERkNp48eYI6derg2LFjqnVOQo+0skaQ1tZ3hYaGRtmXPpPSZ1NuPzYNVeSBQzK6PYKEPWkxlEvZkT/27NmDnDlzfvT7OHLkCBo0aABvb298+eWXKrRGDpTvfh/vfg/i8uXLqsVS+pxKv9UPiVy7BGphZWWluka8S+6P6Dsrr7V0hYjo59q7d2/Mnj0bnyIxviYRmTaGVSIyG9IaJ1NXeXp6qr6WMvjp3r17hlApoSzy4CE5HjmQSgiTvpvffvutuswtfTdjmt1PWl1lBLv0Q41w6dIlw3a2bNlUf1UJlXIpWz6ki8K0adM+GhyFdDGQFlHp49q4cWPVD1W6Frzv+5DvMbLHjx9jzpw5mDJlihqctHjx4g8+n7RCR7hw4YL6+vI9yMfZs2ejPFbCrxwXEiKlu4QMwJLX/LvvvlOB/F0xvUl4n9h+TSKyHAyrRGQ2ZEokaRE9evSoCnDS31GCTkRAlEvcMsfn6tWr1f0yeErmOI0gA4wk6PXp0weDBg1SwS3yHK6Rw1eLFi1Ui6cMxJLQKl8rgoRLaREdMGCA6i978eJF1VfV398/Vv0v5fuQUCiX/6WfqoyY9/LyMnwf0uXgzz//VN+nDIiSUBu5dVS6AMjlemmllNZleR2kO8H7yPch/WslmMrArvr166s5UJs3b66C7KxZs1S3AJkv9X//+5/63sXNmzfVc0srrtQpMyLEdMle+svK63z79u0YW4Eji+3XJCLLwbBKRGajRo0aKqDJpWNpmZRpk6QPqvS9lKCXNWtWtS8j+KVvq7RUSv/UiIE9EtokYEqgTJMmDXr27Inp06ery/ExDWKSryGj7GUGAmkBjUxaUWVgVNu2bVVXBGmNlNAXG/K8Hh4eqoVXPlcux0tLY0QLaN26dVXdMphM+nh+8803hsn0ZfS8dCOQFmIh003J7AgjR46MsZVYyPchgbhDhw5qwJg8VsggJ2ndlK9Xu3Zt9brJ4+S1FTIIS1qYpW9skyZNVA0yQCumgWvSuixfI3Irbkxi+zWJyHJwBSsiIgsm85tKi7LM5UpEZIzYskpERERERothlYiIiIiMFrsBEBEREZHRYssqERERERkthlUiIiIiMloMq0RERERktBhWiYiIiMhoMawSERERkdFiWCUiIiIio8WwSkRERERGi2GViIiIiGCs/g+5sLgPnNBR/QAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Courbe ROC\n",
+    "fpr, tpr, thresholds = roc_curve(y_test, y_pred_proba_baseline)\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "plt.plot(fpr, tpr, label=f'CatBoost (AUC = {roc_auc_score(y_test, y_pred_proba_baseline):.3f})')\n",
+    "plt.plot([0, 1], [0, 1], 'k--', label='Hasard')\n",
+    "plt.xlabel('Taux de faux positifs')\n",
+    "plt.ylabel('Taux de vrais positifs')\n",
+    "plt.title('Courbe ROC')\n",
+    "plt.legend()\n",
+    "plt.grid(True)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 85,
+   "id": "68a8d19d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "=== Importance des variables ===\n",
+      "\n",
+      "           feature  importance\n",
+      "10    capital_gain   22.184166\n",
+      "7     relationship   21.515132\n",
+      "0              age   11.989052\n",
+      "11    capital_loss    8.099907\n",
+      "12  hours_per_week    8.092746\n",
+      "6       occupation    6.768665\n",
+      "5   marital_status    5.823948\n",
+      "4    education_num    5.064122\n",
+      "3        education    3.166436\n",
+      "2           fnlwgt    2.317912\n",
+      "1        workclass    1.725724\n",
+      "9              sex    1.702985\n",
+      "8             race    0.822925\n",
+      "13  native_country    0.726279\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Importance des variables\n",
+    "\n",
+    "print(\"\\n=== Importance des variables ===\\n\")\n",
+    "\n",
+    "feature_importance = model_baseline.get_feature_importance(train_pool)\n",
+    "feature_names = X_train.columns\n",
+    "\n",
+    "importance_df = pd.DataFrame(\n",
+    "    {\"feature\": feature_names, \"importance\": feature_importance}\n",
+    ").sort_values(\"importance\", ascending=False)\n",
+    "\n",
+    "print(importance_df)\n",
+    "\n",
+    "# Visualisation\n",
+    "plt.figure(figsize=(10, 8))\n",
+    "plt.barh(importance_df[\"feature\"][:15], importance_df[\"importance\"][:15])\n",
+    "plt.xlabel(\"Importance\")\n",
+    "plt.title(\"Top 15 variables les plus importantes\")\n",
+    "plt.gca().invert_yaxis()\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c8288a45",
+   "metadata": {},
+   "source": [
+    "# Partie 3 : Exercices"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "64e8d141",
+   "metadata": {},
+   "source": [
+    "## Exercice 1 : Tuning des hyperparamètres"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "86d7206e",
+   "metadata": {},
+   "source": [
+    "**Objectif : Améliorer les performances du modèle en testant différentes combinaisons\n",
+    "d'hyperparamètres.**\n",
+    "\n",
+    "Hyperparamètres à explorer :\n",
+    "- learning_rate : [0.01, 0.05, 0.1, 0.2]\n",
+    "- depth : [4, 6, 8, 10]\n",
+    "- l2_leaf_reg : [1, 3, 5, 7] (régularisation L2)\n",
+    "- bagging_temperature : [0, 0.5, 1] (randomisation de l'échantillonnage)\n",
+    "\n",
+    "Consignes :\n",
+    "1. Utilisez une boucle ou GridSearchCV pour tester différentes combinaisons\n",
+    "2. Comparez les AUC-ROC sur le test set\n",
+    "3. Identifiez la meilleure configuration\n",
+    "4. Entraînez le modèle final avec les meilleurs paramètres"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 93,
+   "id": "1888b8c2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0:\ttotal: 81.2ms\tremaining: 40.5s\n",
+      "0:\ttotal: 83ms\tremaining: 41.4s\n",
+      "0:\ttotal: 81.8ms\tremaining: 40.8s\n",
+      "0:\ttotal: 87.2ms\tremaining: 43.5s\n",
+      "0:\ttotal: 90.8ms\tremaining: 45.3s\n",
+      "0:\ttotal: 98.8ms\tremaining: 49.3s\n",
+      "0:\ttotal: 98.9ms\tremaining: 49.3s\n",
+      "0:\ttotal: 106ms\tremaining: 53s\n",
+      "100:\ttotal: 3.71s\tremaining: 14.7s\n",
+      "100:\ttotal: 3.88s\tremaining: 15.3s\n",
+      "100:\ttotal: 3.9s\tremaining: 15.4s\n",
+      "100:\ttotal: 3.93s\tremaining: 15.5s\n",
+      "100:\ttotal: 3.99s\tremaining: 15.8s\n",
+      "100:\ttotal: 4.08s\tremaining: 16.1s\n",
+      "100:\ttotal: 4.13s\tremaining: 16.3s\n",
+      "100:\ttotal: 4.43s\tremaining: 17.5s\n",
+      "200:\ttotal: 7.97s\tremaining: 11.8s\n",
+      "200:\ttotal: 8.19s\tremaining: 12.2s\n",
+      "200:\ttotal: 8.23s\tremaining: 12.2s\n",
+      "200:\ttotal: 8.24s\tremaining: 12.3s\n",
+      "200:\ttotal: 8.29s\tremaining: 12.3s\n",
+      "200:\ttotal: 8.33s\tremaining: 12.4s\n",
+      "200:\ttotal: 8.44s\tremaining: 12.6s\n",
+      "200:\ttotal: 8.89s\tremaining: 13.2s\n",
+      "300:\ttotal: 12.3s\tremaining: 8.14s\n",
+      "300:\ttotal: 12.4s\tremaining: 8.2s\n",
+      "300:\ttotal: 12.4s\tremaining: 8.18s\n",
+      "300:\ttotal: 12.6s\tremaining: 8.3s\n",
+      "300:\ttotal: 12.7s\tremaining: 8.37s\n",
+      "300:\ttotal: 12.8s\tremaining: 8.43s\n",
+      "300:\ttotal: 13s\tremaining: 8.57s\n",
+      "300:\ttotal: 13.3s\tremaining: 8.78s\n",
+      "400:\ttotal: 16.5s\tremaining: 4.07s\n",
+      "400:\ttotal: 16.7s\tremaining: 4.11s\n",
+      "400:\ttotal: 16.6s\tremaining: 4.1s\n",
+      "400:\ttotal: 17.1s\tremaining: 4.21s\n",
+      "400:\ttotal: 17.2s\tremaining: 4.24s\n",
+      "400:\ttotal: 17.4s\tremaining: 4.3s\n",
+      "400:\ttotal: 17.8s\tremaining: 4.39s\n",
+      "400:\ttotal: 17.8s\tremaining: 4.39s\n",
+      "499:\ttotal: 21.2s\tremaining: 0us\n",
+      "0:\ttotal: 38ms\tremaining: 18.9s\n",
+      "499:\ttotal: 21.6s\tremaining: 0us\n",
+      "499:\ttotal: 21.6s\tremaining: 0us\n",
+      "0:\ttotal: 41.5ms\tremaining: 20.7s\n",
+      "0:\ttotal: 41.9ms\tremaining: 20.9s\n",
+      "499:\ttotal: 22.1s\tremaining: 0us\n",
+      "499:\ttotal: 22.3s\tremaining: 0us\n",
+      "0:\ttotal: 63.4ms\tremaining: 31.6s\n",
+      "0:\ttotal: 45.2ms\tremaining: 22.6s\n",
+      "499:\ttotal: 22.6s\tremaining: 0us\n",
+      "0:\ttotal: 48.6ms\tremaining: 24.3s\n",
+      "499:\ttotal: 23s\tremaining: 0us\n",
+      "499:\ttotal: 23s\tremaining: 0us\n",
+      "0:\ttotal: 36ms\tremaining: 17.9s\n",
+      "0:\ttotal: 41.8ms\tremaining: 20.9s\n",
+      "100:\ttotal: 4.45s\tremaining: 17.6s\n",
+      "100:\ttotal: 4.11s\tremaining: 16.3s\n",
+      "100:\ttotal: 4.45s\tremaining: 17.6s\n",
+      "100:\ttotal: 4.27s\tremaining: 16.9s\n",
+      "100:\ttotal: 4.23s\tremaining: 16.7s\n",
+      "100:\ttotal: 4.19s\tremaining: 16.6s\n",
+      "100:\ttotal: 4.24s\tremaining: 16.8s\n",
+      "100:\ttotal: 4.58s\tremaining: 18.1s\n",
+      "200:\ttotal: 9.07s\tremaining: 13.5s\n",
+      "200:\ttotal: 9.64s\tremaining: 14.3s\n",
+      "200:\ttotal: 9.38s\tremaining: 13.9s\n",
+      "200:\ttotal: 9.24s\tremaining: 13.7s\n",
+      "200:\ttotal: 9.36s\tremaining: 13.9s\n",
+      "200:\ttotal: 9.26s\tremaining: 13.8s\n",
+      "200:\ttotal: 9.21s\tremaining: 13.7s\n",
+      "200:\ttotal: 9.44s\tremaining: 14s\n",
+      "300:\ttotal: 13.3s\tremaining: 8.79s\n",
+      "300:\ttotal: 14s\tremaining: 9.22s\n",
+      "300:\ttotal: 13.5s\tremaining: 8.95s\n",
+      "300:\ttotal: 13.5s\tremaining: 8.94s\n",
+      "300:\ttotal: 13.6s\tremaining: 8.98s\n",
+      "300:\ttotal: 13.5s\tremaining: 8.96s\n",
+      "300:\ttotal: 13.5s\tremaining: 8.95s\n",
+      "300:\ttotal: 13.7s\tremaining: 9.04s\n",
+      "400:\ttotal: 17.5s\tremaining: 4.33s\n",
+      "400:\ttotal: 18.3s\tremaining: 4.5s\n",
+      "400:\ttotal: 17.6s\tremaining: 4.35s\n",
+      "400:\ttotal: 18s\tremaining: 4.43s\n",
+      "400:\ttotal: 17.8s\tremaining: 4.39s\n",
+      "400:\ttotal: 17.5s\tremaining: 4.32s\n",
+      "400:\ttotal: 17.5s\tremaining: 4.32s\n",
+      "400:\ttotal: 17.7s\tremaining: 4.38s\n",
+      "499:\ttotal: 21.8s\tremaining: 0us\n",
+      "499:\ttotal: 22.5s\tremaining: 0us\n",
+      "0:\ttotal: 39.3ms\tremaining: 19.6s\n",
+      "499:\ttotal: 21.8s\tremaining: 0us\n",
+      "499:\ttotal: 22.2s\tremaining: 0us\n",
+      "0:\ttotal: 24.4ms\tremaining: 12.2s\n",
+      "499:\ttotal: 22.2s\tremaining: 0us\n",
+      "0:\ttotal: 46.4ms\tremaining: 23.2s\n",
+      "499:\ttotal: 21.8s\tremaining: 0us\n",
+      "0:\ttotal: 50.9ms\tremaining: 25.4s\n",
+      "0:\ttotal: 27.8ms\tremaining: 13.9s\n",
+      "0:\ttotal: 35.3ms\tremaining: 17.6s\n",
+      "499:\ttotal: 21.7s\tremaining: 0us\n",
+      "499:\ttotal: 22.1s\tremaining: 0us\n",
+      "0:\ttotal: 38.9ms\tremaining: 19.4s\n",
+      "0:\ttotal: 31.6ms\tremaining: 15.8s\n",
+      "100:\ttotal: 4.9s\tremaining: 19.4s\n",
+      "100:\ttotal: 4.78s\tremaining: 18.9s\n",
+      "100:\ttotal: 4.61s\tremaining: 18.2s\n",
+      "100:\ttotal: 4.79s\tremaining: 18.9s\n",
+      "100:\ttotal: 5.13s\tremaining: 20.3s\n",
+      "100:\ttotal: 5.17s\tremaining: 20.4s\n",
+      "100:\ttotal: 4.8s\tremaining: 19s\n",
+      "100:\ttotal: 4.58s\tremaining: 18.1s\n",
+      "200:\ttotal: 9.09s\tremaining: 13.5s\n",
+      "200:\ttotal: 8.8s\tremaining: 13.1s\n",
+      "200:\ttotal: 9.46s\tremaining: 14.1s\n",
+      "200:\ttotal: 8.93s\tremaining: 13.3s\n",
+      "200:\ttotal: 9.46s\tremaining: 14.1s\n",
+      "200:\ttotal: 8.78s\tremaining: 13.1s\n",
+      "200:\ttotal: 9.53s\tremaining: 14.2s\n",
+      "200:\ttotal: 8.68s\tremaining: 12.9s\n",
+      "300:\ttotal: 13.7s\tremaining: 9.08s\n",
+      "300:\ttotal: 13s\tremaining: 8.58s\n",
+      "300:\ttotal: 13.2s\tremaining: 8.7s\n",
+      "300:\ttotal: 13.8s\tremaining: 9.1s\n",
+      "300:\ttotal: 13.7s\tremaining: 9.07s\n",
+      "300:\ttotal: 13.9s\tremaining: 9.2s\n",
+      "300:\ttotal: 13.2s\tremaining: 8.76s\n",
+      "300:\ttotal: 12.9s\tremaining: 8.51s\n",
+      "400:\ttotal: 18s\tremaining: 4.45s\n",
+      "400:\ttotal: 17.3s\tremaining: 4.27s\n",
+      "400:\ttotal: 17.3s\tremaining: 4.28s\n",
+      "400:\ttotal: 18.2s\tremaining: 4.49s\n",
+      "400:\ttotal: 18.1s\tremaining: 4.46s\n",
+      "400:\ttotal: 17.6s\tremaining: 4.34s\n",
+      "400:\ttotal: 18.5s\tremaining: 4.56s\n",
+      "400:\ttotal: 17.2s\tremaining: 4.24s\n",
+      "499:\ttotal: 21.2s\tremaining: 0us\n",
+      "499:\ttotal: 21.3s\tremaining: 0us\n",
+      "499:\ttotal: 22.1s\tremaining: 0us\n",
+      "0:\ttotal: 22.6ms\tremaining: 11.3s\n",
+      "0:\ttotal: 47.3ms\tremaining: 23.6s\n",
+      "0:\ttotal: 34.1ms\tremaining: 17s\n",
+      "499:\ttotal: 22.1s\tremaining: 0us\n",
+      "499:\ttotal: 22.5s\tremaining: 0us\n",
+      "499:\ttotal: 21.5s\tremaining: 0us\n",
+      "499:\ttotal: 22.4s\tremaining: 0us\n",
+      "0:\ttotal: 33.6ms\tremaining: 16.8s\n",
+      "499:\ttotal: 21.3s\tremaining: 0us\n",
+      "0:\ttotal: 43ms\tremaining: 21.5s\n",
+      "0:\ttotal: 37ms\tremaining: 18.5s\n",
+      "0:\ttotal: 40.2ms\tremaining: 20.1s\n",
+      "0:\ttotal: 50ms\tremaining: 25s\n",
+      "100:\ttotal: 3.62s\tremaining: 14.3s\n",
+      "100:\ttotal: 3.88s\tremaining: 15.3s\n",
+      "100:\ttotal: 4.1s\tremaining: 16.2s\n",
+      "100:\ttotal: 3.64s\tremaining: 14.4s\n",
+      "100:\ttotal: 3.96s\tremaining: 15.6s\n",
+      "100:\ttotal: 3.81s\tremaining: 15s\n",
+      "100:\ttotal: 4.25s\tremaining: 16.8s\n",
+      "100:\ttotal: 4.07s\tremaining: 16.1s\n",
+      "200:\ttotal: 7.28s\tremaining: 10.8s\n",
+      "200:\ttotal: 8.03s\tremaining: 11.9s\n",
+      "200:\ttotal: 7.96s\tremaining: 11.8s\n",
+      "200:\ttotal: 7.69s\tremaining: 11.4s\n",
+      "200:\ttotal: 8.01s\tremaining: 11.9s\n",
+      "200:\ttotal: 8.02s\tremaining: 11.9s\n",
+      "200:\ttotal: 7.86s\tremaining: 11.7s\n",
+      "200:\ttotal: 8.38s\tremaining: 12.5s\n",
+      "300:\ttotal: 12.1s\tremaining: 7.98s\n",
+      "300:\ttotal: 12.6s\tremaining: 8.36s\n",
+      "300:\ttotal: 12.4s\tremaining: 8.21s\n",
+      "300:\ttotal: 13.3s\tremaining: 8.82s\n",
+      "300:\ttotal: 13.3s\tremaining: 8.8s\n",
+      "300:\ttotal: 13.4s\tremaining: 8.85s\n",
+      "300:\ttotal: 13.7s\tremaining: 9.08s\n",
+      "300:\ttotal: 13.9s\tremaining: 9.16s\n",
+      "400:\ttotal: 17.1s\tremaining: 4.23s\n",
+      "400:\ttotal: 17.9s\tremaining: 4.42s\n",
+      "400:\ttotal: 17.8s\tremaining: 4.38s\n",
+      "400:\ttotal: 18.1s\tremaining: 4.47s\n",
+      "400:\ttotal: 18.8s\tremaining: 4.65s\n",
+      "400:\ttotal: 18.6s\tremaining: 4.59s\n",
+      "400:\ttotal: 18.4s\tremaining: 4.54s\n",
+      "400:\ttotal: 18.7s\tremaining: 4.62s\n",
+      "499:\ttotal: 21.7s\tremaining: 0us\n",
+      "0:\ttotal: 43.8ms\tremaining: 21.8s\n",
+      "499:\ttotal: 22.2s\tremaining: 0us\n",
+      "0:\ttotal: 36.7ms\tremaining: 18.3s\n",
+      "499:\ttotal: 22.1s\tremaining: 0us\n",
+      "0:\ttotal: 31.8ms\tremaining: 15.9s\n",
+      "499:\ttotal: 22.7s\tremaining: 0us\n",
+      "499:\ttotal: 23.5s\tremaining: 0us\n",
+      "0:\ttotal: 35.1ms\tremaining: 17.5s\n",
+      "0:\ttotal: 35.2ms\tremaining: 17.6s\n",
+      "499:\ttotal: 23.1s\tremaining: 0us\n",
+      "499:\ttotal: 23.1s\tremaining: 0us\n",
+      "0:\ttotal: 29.6ms\tremaining: 14.8s\n",
+      "499:\ttotal: 23.2s\tremaining: 0us\n",
+      "0:\ttotal: 41ms\tremaining: 20.4s\n",
+      "0:\ttotal: 53.5ms\tremaining: 26.7s\n",
+      "100:\ttotal: 5.1s\tremaining: 20.2s\n",
+      "100:\ttotal: 5.05s\tremaining: 19.9s\n",
+      "100:\ttotal: 4.98s\tremaining: 19.7s\n",
+      "100:\ttotal: 4.74s\tremaining: 18.7s\n",
+      "100:\ttotal: 4.93s\tremaining: 19.5s\n",
+      "100:\ttotal: 5.19s\tremaining: 20.5s\n",
+      "100:\ttotal: 5.15s\tremaining: 20.4s\n",
+      "100:\ttotal: 5.04s\tremaining: 19.9s\n",
+      "200:\ttotal: 9.54s\tremaining: 14.2s\n",
+      "200:\ttotal: 9.79s\tremaining: 14.6s\n",
+      "200:\ttotal: 9.49s\tremaining: 14.1s\n",
+      "200:\ttotal: 9.43s\tremaining: 14s\n",
+      "200:\ttotal: 9.51s\tremaining: 14.1s\n",
+      "200:\ttotal: 9.61s\tremaining: 14.3s\n",
+      "200:\ttotal: 9.66s\tremaining: 14.4s\n",
+      "200:\ttotal: 9.46s\tremaining: 14.1s\n",
+      "300:\ttotal: 13.8s\tremaining: 9.12s\n",
+      "300:\ttotal: 14.1s\tremaining: 9.34s\n",
+      "300:\ttotal: 13.7s\tremaining: 9.04s\n",
+      "300:\ttotal: 13.6s\tremaining: 9.02s\n",
+      "300:\ttotal: 13.7s\tremaining: 9.07s\n",
+      "300:\ttotal: 13.8s\tremaining: 9.14s\n",
+      "300:\ttotal: 13.7s\tremaining: 9.04s\n",
+      "300:\ttotal: 13.6s\tremaining: 9.02s\n",
+      "400:\ttotal: 18.1s\tremaining: 4.46s\n",
+      "400:\ttotal: 18.6s\tremaining: 4.58s\n",
+      "400:\ttotal: 18s\tremaining: 4.45s\n",
+      "400:\ttotal: 18.4s\tremaining: 4.54s\n",
+      "400:\ttotal: 18.7s\tremaining: 4.61s\n",
+      "400:\ttotal: 18.5s\tremaining: 4.56s\n",
+      "400:\ttotal: 18.8s\tremaining: 4.63s\n",
+      "400:\ttotal: 18.6s\tremaining: 4.59s\n",
+      "499:\ttotal: 22.8s\tremaining: 0us\n",
+      "0:\ttotal: 33.8ms\tremaining: 16.9s\n",
+      "499:\ttotal: 23.4s\tremaining: 0us\n",
+      "499:\ttotal: 22.9s\tremaining: 0us\n",
+      "499:\ttotal: 22.6s\tremaining: 0us\n",
+      "0:\ttotal: 29.3ms\tremaining: 14.6s\n",
+      "0:\ttotal: 41ms\tremaining: 20.5s\n",
+      "499:\ttotal: 22.9s\tremaining: 0us\n",
+      "0:\ttotal: 39ms\tremaining: 19.4s\n",
+      "499:\ttotal: 22.8s\tremaining: 0us\n",
+      "0:\ttotal: 99.3ms\tremaining: 49.6s\n",
+      "499:\ttotal: 23.2s\tremaining: 0us\n",
+      "499:\ttotal: 23.1s\tremaining: 0us\n",
+      "0:\ttotal: 46.4ms\tremaining: 23.2s\n",
+      "0:\ttotal: 42ms\tremaining: 21s\n",
+      "0:\ttotal: 34.7ms\tremaining: 17.3s\n",
+      "100:\ttotal: 3.94s\tremaining: 15.6s\n",
+      "100:\ttotal: 4.07s\tremaining: 16.1s\n",
+      "100:\ttotal: 4.31s\tremaining: 17s\n",
+      "100:\ttotal: 4.34s\tremaining: 17.2s\n",
+      "100:\ttotal: 4.73s\tremaining: 18.7s\n",
+      "100:\ttotal: 4.43s\tremaining: 17.5s\n",
+      "100:\ttotal: 4.59s\tremaining: 18.1s\n",
+      "100:\ttotal: 4.51s\tremaining: 17.8s\n",
+      "200:\ttotal: 8.35s\tremaining: 12.4s\n",
+      "200:\ttotal: 8.27s\tremaining: 12.3s\n",
+      "200:\ttotal: 8.69s\tremaining: 12.9s\n",
+      "200:\ttotal: 8.57s\tremaining: 12.7s\n",
+      "200:\ttotal: 9s\tremaining: 13.4s\n",
+      "200:\ttotal: 8.61s\tremaining: 12.8s\n",
+      "200:\ttotal: 8.77s\tremaining: 13s\n",
+      "200:\ttotal: 8.71s\tremaining: 13s\n",
+      "300:\ttotal: 12.5s\tremaining: 8.25s\n",
+      "300:\ttotal: 12.3s\tremaining: 8.16s\n",
+      "300:\ttotal: 12.8s\tremaining: 8.44s\n",
+      "300:\ttotal: 12.6s\tremaining: 8.32s\n",
+      "300:\ttotal: 13.2s\tremaining: 8.7s\n",
+      "300:\ttotal: 12.6s\tremaining: 8.34s\n",
+      "300:\ttotal: 13.3s\tremaining: 8.78s\n",
+      "300:\ttotal: 13s\tremaining: 8.57s\n",
+      "400:\ttotal: 16.8s\tremaining: 4.15s\n",
+      "400:\ttotal: 16.6s\tremaining: 4.09s\n",
+      "400:\ttotal: 16.9s\tremaining: 4.18s\n",
+      "400:\ttotal: 16.8s\tremaining: 4.14s\n",
+      "400:\ttotal: 17.2s\tremaining: 4.25s\n",
+      "400:\ttotal: 16.8s\tremaining: 4.14s\n",
+      "400:\ttotal: 17.1s\tremaining: 4.23s\n",
+      "400:\ttotal: 17.7s\tremaining: 4.38s\n",
+      "499:\ttotal: 20.8s\tremaining: 0us\n",
+      "0:\ttotal: 46.8ms\tremaining: 23.4s\n",
+      "499:\ttotal: 20.7s\tremaining: 0us\n",
+      "0:\ttotal: 35.5ms\tremaining: 17.7s\n",
+      "499:\ttotal: 21.1s\tremaining: 0us\n",
+      "0:\ttotal: 35.7ms\tremaining: 17.8s\n",
+      "499:\ttotal: 21s\tremaining: 0us\n",
+      "0:\ttotal: 31.5ms\tremaining: 15.7s\n",
+      "499:\ttotal: 21.5s\tremaining: 0us\n",
+      "499:\ttotal: 20.9s\tremaining: 0us\n",
+      "0:\ttotal: 55.8ms\tremaining: 27.9s\n",
+      "0:\ttotal: 45.3ms\tremaining: 22.6s\n",
+      "499:\ttotal: 21.2s\tremaining: 0us\n",
+      "0:\ttotal: 48.4ms\tremaining: 24.1s\n",
+      "499:\ttotal: 21.8s\tremaining: 0us\n",
+      "0:\ttotal: 85.3ms\tremaining: 42.6s\n",
+      "100:\ttotal: 4.02s\tremaining: 15.9s\n",
+      "100:\ttotal: 3.98s\tremaining: 15.7s\n",
+      "100:\ttotal: 4.17s\tremaining: 16.5s\n",
+      "100:\ttotal: 4.55s\tremaining: 18s\n",
+      "100:\ttotal: 4.51s\tremaining: 17.8s\n",
+      "100:\ttotal: 4.4s\tremaining: 17.4s\n",
+      "100:\ttotal: 4.51s\tremaining: 17.8s\n",
+      "100:\ttotal: 4.5s\tremaining: 17.8s\n",
+      "200:\ttotal: 8.41s\tremaining: 12.5s\n",
+      "200:\ttotal: 8.57s\tremaining: 12.8s\n",
+      "200:\ttotal: 8.28s\tremaining: 12.3s\n",
+      "200:\ttotal: 8.55s\tremaining: 12.7s\n",
+      "200:\ttotal: 8.51s\tremaining: 12.7s\n",
+      "200:\ttotal: 8.5s\tremaining: 12.6s\n",
+      "200:\ttotal: 8.54s\tremaining: 12.7s\n",
+      "200:\ttotal: 8.62s\tremaining: 12.8s\n",
+      "300:\ttotal: 12.8s\tremaining: 8.45s\n",
+      "300:\ttotal: 12.4s\tremaining: 8.2s\n",
+      "300:\ttotal: 13s\tremaining: 8.59s\n",
+      "300:\ttotal: 13s\tremaining: 8.56s\n",
+      "300:\ttotal: 12.6s\tremaining: 8.32s\n",
+      "300:\ttotal: 12.8s\tremaining: 8.47s\n",
+      "300:\ttotal: 12.8s\tremaining: 8.45s\n",
+      "300:\ttotal: 12.9s\tremaining: 8.52s\n",
+      "400:\ttotal: 17s\tremaining: 4.19s\n",
+      "400:\ttotal: 16.5s\tremaining: 4.08s\n",
+      "400:\ttotal: 17s\tremaining: 4.2s\n",
+      "400:\ttotal: 17s\tremaining: 4.21s\n",
+      "400:\ttotal: 16.7s\tremaining: 4.13s\n",
+      "400:\ttotal: 17s\tremaining: 4.19s\n",
+      "400:\ttotal: 16.9s\tremaining: 4.18s\n",
+      "400:\ttotal: 16.9s\tremaining: 4.17s\n",
+      "499:\ttotal: 21s\tremaining: 0us\n",
+      "0:\ttotal: 53.5ms\tremaining: 26.7s\n",
+      "499:\ttotal: 20.7s\tremaining: 0us\n",
+      "499:\ttotal: 21.2s\tremaining: 0us\n",
+      "0:\ttotal: 46.9ms\tremaining: 23.4s\n",
+      "0:\ttotal: 28.4ms\tremaining: 14.2s\n",
+      "499:\ttotal: 21.1s\tremaining: 0us\n",
+      "0:\ttotal: 35.2ms\tremaining: 17.6s\n",
+      "499:\ttotal: 21.1s\tremaining: 0us\n",
+      "499:\ttotal: 21.2s\tremaining: 0us\n",
+      "0:\ttotal: 47.5ms\tremaining: 23.7s\n",
+      "499:\ttotal: 21.1s\tremaining: 0us\n",
+      "0:\ttotal: 59.9ms\tremaining: 29.9s\n",
+      "0:\ttotal: 40.5ms\tremaining: 20.2s\n",
+      "499:\ttotal: 21.4s\tremaining: 0us\n",
+      "0:\ttotal: 29.9ms\tremaining: 14.9s\n",
+      "100:\ttotal: 4.48s\tremaining: 17.7s\n",
+      "100:\ttotal: 4.34s\tremaining: 17.2s\n",
+      "100:\ttotal: 4.41s\tremaining: 17.4s\n",
+      "100:\ttotal: 4.31s\tremaining: 17s\n",
+      "100:\ttotal: 4.28s\tremaining: 16.9s\n",
+      "100:\ttotal: 3.9s\tremaining: 15.4s\n",
+      "100:\ttotal: 4.26s\tremaining: 16.8s\n",
+      "100:\ttotal: 4.02s\tremaining: 15.9s\n",
+      "200:\ttotal: 8.82s\tremaining: 13.1s\n",
+      "200:\ttotal: 8.54s\tremaining: 12.7s\n",
+      "200:\ttotal: 8.66s\tremaining: 12.9s\n",
+      "200:\ttotal: 8.67s\tremaining: 12.9s\n",
+      "200:\ttotal: 8.66s\tremaining: 12.9s\n",
+      "200:\ttotal: 8.54s\tremaining: 12.7s\n",
+      "200:\ttotal: 8.81s\tremaining: 13.1s\n",
+      "200:\ttotal: 7.85s\tremaining: 11.7s\n",
+      "300:\ttotal: 13.4s\tremaining: 8.84s\n",
+      "300:\ttotal: 12.6s\tremaining: 8.34s\n",
+      "300:\ttotal: 13.7s\tremaining: 9.05s\n",
+      "300:\ttotal: 13.4s\tremaining: 8.88s\n",
+      "300:\ttotal: 13.2s\tremaining: 8.71s\n",
+      "300:\ttotal: 13.2s\tremaining: 8.71s\n",
+      "300:\ttotal: 12.5s\tremaining: 8.26s\n",
+      "300:\ttotal: 13.5s\tremaining: 8.91s\n",
+      "400:\ttotal: 18s\tremaining: 4.45s\n",
+      "400:\ttotal: 17.4s\tremaining: 4.3s\n",
+      "400:\ttotal: 17.7s\tremaining: 4.38s\n",
+      "400:\ttotal: 17.5s\tremaining: 4.33s\n",
+      "400:\ttotal: 17.6s\tremaining: 4.35s\n",
+      "400:\ttotal: 17.2s\tremaining: 4.25s\n",
+      "400:\ttotal: 17.5s\tremaining: 4.32s\n",
+      "400:\ttotal: 16.6s\tremaining: 4.1s\n",
+      "499:\ttotal: 22s\tremaining: 0us\n",
+      "0:\ttotal: 35.6ms\tremaining: 17.8s\n",
+      "499:\ttotal: 21.9s\tremaining: 0us\n",
+      "499:\ttotal: 22s\tremaining: 0us\n",
+      "0:\ttotal: 40.5ms\tremaining: 20.2s\n",
+      "499:\ttotal: 21.7s\tremaining: 0us\n",
+      "0:\ttotal: 38ms\tremaining: 18.9s\n",
+      "0:\ttotal: 44.4ms\tremaining: 22.1s\n",
+      "499:\ttotal: 21.7s\tremaining: 0us\n",
+      "499:\ttotal: 21.3s\tremaining: 0us\n",
+      "0:\ttotal: 39.2ms\tremaining: 19.5s\n",
+      "499:\ttotal: 21.3s\tremaining: 0us\n",
+      "499:\ttotal: 20.6s\tremaining: 0us\n",
+      "0:\ttotal: 52.9ms\tremaining: 26.4s\n",
+      "0:\ttotal: 39.4ms\tremaining: 19.6s\n",
+      "0:\ttotal: 80.7ms\tremaining: 40.3s\n",
+      "100:\ttotal: 4.09s\tremaining: 16.2s\n",
+      "100:\ttotal: 4.32s\tremaining: 17.1s\n",
+      "100:\ttotal: 4.26s\tremaining: 16.8s\n",
+      "100:\ttotal: 4.04s\tremaining: 16s\n",
+      "100:\ttotal: 4.3s\tremaining: 17s\n",
+      "100:\ttotal: 4.29s\tremaining: 16.9s\n",
+      "100:\ttotal: 4.21s\tremaining: 16.6s\n",
+      "100:\ttotal: 4.53s\tremaining: 17.9s\n",
+      "200:\ttotal: 7.89s\tremaining: 11.7s\n",
+      "200:\ttotal: 8.44s\tremaining: 12.6s\n",
+      "200:\ttotal: 8.36s\tremaining: 12.4s\n",
+      "200:\ttotal: 8.07s\tremaining: 12s\n",
+      "200:\ttotal: 8.26s\tremaining: 12.3s\n",
+      "200:\ttotal: 8.13s\tremaining: 12.1s\n",
+      "200:\ttotal: 8.48s\tremaining: 12.6s\n",
+      "200:\ttotal: 8.92s\tremaining: 13.3s\n",
+      "300:\ttotal: 11.9s\tremaining: 7.88s\n",
+      "300:\ttotal: 11.9s\tremaining: 7.9s\n",
+      "300:\ttotal: 12.5s\tremaining: 8.29s\n",
+      "300:\ttotal: 12.7s\tremaining: 8.39s\n",
+      "300:\ttotal: 12.1s\tremaining: 8s\n",
+      "300:\ttotal: 12.5s\tremaining: 8.27s\n",
+      "300:\ttotal: 12.6s\tremaining: 8.31s\n",
+      "300:\ttotal: 13s\tremaining: 8.61s\n",
+      "400:\ttotal: 16s\tremaining: 3.96s\n",
+      "400:\ttotal: 16.1s\tremaining: 3.97s\n",
+      "400:\ttotal: 16.7s\tremaining: 4.12s\n",
+      "400:\ttotal: 16.9s\tremaining: 4.17s\n",
+      "400:\ttotal: 16.2s\tremaining: 4s\n",
+      "400:\ttotal: 16.5s\tremaining: 4.07s\n",
+      "400:\ttotal: 16.7s\tremaining: 4.12s\n",
+      "400:\ttotal: 17.1s\tremaining: 4.22s\n",
+      "499:\ttotal: 20s\tremaining: 0us\n",
+      "0:\ttotal: 49.7ms\tremaining: 24.8s\n",
+      "499:\ttotal: 20.3s\tremaining: 0us\n",
+      "0:\ttotal: 79.7ms\tremaining: 39.8s\n",
+      "499:\ttotal: 21.4s\tremaining: 0us\n",
+      "499:\ttotal: 21.3s\tremaining: 0us\n",
+      "0:\ttotal: 40.3ms\tremaining: 20.1s\n",
+      "0:\ttotal: 32.3ms\tremaining: 16.1s\n",
+      "499:\ttotal: 20.8s\tremaining: 0us\n",
+      "499:\ttotal: 20.7s\tremaining: 0us\n",
+      "499:\ttotal: 21s\tremaining: 0us\n",
+      "0:\ttotal: 24ms\tremaining: 12s\n",
+      "0:\ttotal: 46.6ms\tremaining: 23.2s\n",
+      "0:\ttotal: 74.7ms\tremaining: 37.3s\n",
+      "499:\ttotal: 21.7s\tremaining: 0us\n",
+      "0:\ttotal: 27.9ms\tremaining: 13.9s\n",
+      "100:\ttotal: 4.83s\tremaining: 19.1s\n",
+      "100:\ttotal: 4.35s\tremaining: 17.2s\n",
+      "100:\ttotal: 4.28s\tremaining: 16.9s\n",
+      "100:\ttotal: 4.55s\tremaining: 18s\n",
+      "100:\ttotal: 4.08s\tremaining: 16.1s\n",
+      "100:\ttotal: 4.16s\tremaining: 16.4s\n",
+      "100:\ttotal: 4.51s\tremaining: 17.8s\n",
+      "100:\ttotal: 4.19s\tremaining: 16.5s\n",
+      "200:\ttotal: 9.36s\tremaining: 13.9s\n",
+      "200:\ttotal: 8.76s\tremaining: 13s\n",
+      "200:\ttotal: 8.41s\tremaining: 12.5s\n",
+      "200:\ttotal: 8.72s\tremaining: 13s\n",
+      "200:\ttotal: 8.53s\tremaining: 12.7s\n",
+      "200:\ttotal: 8.37s\tremaining: 12.4s\n",
+      "200:\ttotal: 8.69s\tremaining: 12.9s\n",
+      "200:\ttotal: 8.2s\tremaining: 12.2s\n",
+      "300:\ttotal: 14.1s\tremaining: 9.34s\n",
+      "300:\ttotal: 12.9s\tremaining: 8.54s\n",
+      "300:\ttotal: 12.5s\tremaining: 8.27s\n",
+      "300:\ttotal: 13s\tremaining: 8.59s\n",
+      "300:\ttotal: 12.8s\tremaining: 8.46s\n",
+      "300:\ttotal: 12.6s\tremaining: 8.32s\n",
+      "300:\ttotal: 13s\tremaining: 8.57s\n",
+      "300:\ttotal: 12.5s\tremaining: 8.26s\n",
+      "400:\ttotal: 18.6s\tremaining: 4.6s\n",
+      "400:\ttotal: 16.7s\tremaining: 4.12s\n",
+      "400:\ttotal: 17.7s\tremaining: 4.37s\n",
+      "400:\ttotal: 17.6s\tremaining: 4.33s\n",
+      "400:\ttotal: 17.1s\tremaining: 4.23s\n",
+      "400:\ttotal: 17.5s\tremaining: 4.31s\n",
+      "400:\ttotal: 17.6s\tremaining: 4.35s\n",
+      "400:\ttotal: 17.2s\tremaining: 4.25s\n",
+      "499:\ttotal: 22.9s\tremaining: 0us\n",
+      "0:\ttotal: 44.4ms\tremaining: 22.1s\n",
+      "499:\ttotal: 20.9s\tremaining: 0us\n",
+      "499:\ttotal: 22.1s\tremaining: 0us\n",
+      "0:\ttotal: 77.2ms\tremaining: 38.5s\n",
+      "0:\ttotal: 47.8ms\tremaining: 23.8s\n",
+      "499:\ttotal: 21.8s\tremaining: 0us\n",
+      "499:\ttotal: 21.6s\tremaining: 0us\n",
+      "0:\ttotal: 52.8ms\tremaining: 26.4s\n",
+      "499:\ttotal: 21.8s\tremaining: 0us\n",
+      "499:\ttotal: 22.1s\tremaining: 0us\n",
+      "0:\ttotal: 33.7ms\tremaining: 16.8s\n",
+      "0:\ttotal: 54.2ms\tremaining: 27.1s\n",
+      "0:\ttotal: 44.1ms\tremaining: 22s\n",
+      "499:\ttotal: 21.5s\tremaining: 0us\n",
+      "0:\ttotal: 54ms\tremaining: 27s\n",
+      "100:\ttotal: 5.47s\tremaining: 21.6s\n",
+      "100:\ttotal: 5.55s\tremaining: 21.9s\n",
+      "100:\ttotal: 5.63s\tremaining: 22.2s\n",
+      "100:\ttotal: 5.81s\tremaining: 22.9s\n",
+      "100:\ttotal: 5.67s\tremaining: 22.4s\n",
+      "100:\ttotal: 5.96s\tremaining: 23.6s\n",
+      "100:\ttotal: 6.16s\tremaining: 24.3s\n",
+      "100:\ttotal: 6.34s\tremaining: 25s\n",
+      "200:\ttotal: 11.2s\tremaining: 16.7s\n",
+      "200:\ttotal: 11.1s\tremaining: 16.5s\n",
+      "200:\ttotal: 11.3s\tremaining: 16.8s\n",
+      "200:\ttotal: 11.6s\tremaining: 17.3s\n",
+      "200:\ttotal: 11.4s\tremaining: 16.9s\n",
+      "200:\ttotal: 11.3s\tremaining: 16.8s\n",
+      "200:\ttotal: 11.5s\tremaining: 17.1s\n",
+      "200:\ttotal: 11.8s\tremaining: 17.6s\n",
+      "300:\ttotal: 16.5s\tremaining: 10.9s\n",
+      "300:\ttotal: 16.6s\tremaining: 11s\n",
+      "300:\ttotal: 16.8s\tremaining: 11.1s\n",
+      "300:\ttotal: 17.1s\tremaining: 11.3s\n",
+      "300:\ttotal: 16.9s\tremaining: 11.2s\n",
+      "300:\ttotal: 17.3s\tremaining: 11.4s\n",
+      "300:\ttotal: 17.5s\tremaining: 11.6s\n",
+      "300:\ttotal: 17.6s\tremaining: 11.6s\n",
+      "400:\ttotal: 21.9s\tremaining: 5.42s\n",
+      "400:\ttotal: 22s\tremaining: 5.44s\n",
+      "400:\ttotal: 22.4s\tremaining: 5.52s\n",
+      "400:\ttotal: 22.4s\tremaining: 5.54s\n",
+      "400:\ttotal: 22.3s\tremaining: 5.5s\n",
+      "400:\ttotal: 23s\tremaining: 5.67s\n",
+      "400:\ttotal: 23.3s\tremaining: 5.76s\n",
+      "400:\ttotal: 23.6s\tremaining: 5.82s\n",
+      "499:\ttotal: 27.6s\tremaining: 0us\n",
+      "0:\ttotal: 51.3ms\tremaining: 25.6s\n",
+      "499:\ttotal: 27.4s\tremaining: 0us\n",
+      "0:\ttotal: 59.3ms\tremaining: 29.6s\n",
+      "499:\ttotal: 27.8s\tremaining: 0us\n",
+      "0:\ttotal: 59.7ms\tremaining: 29.8s\n",
+      "499:\ttotal: 27.7s\tremaining: 0us\n",
+      "499:\ttotal: 27.6s\tremaining: 0us\n",
+      "0:\ttotal: 92.2ms\tremaining: 46s\n",
+      "0:\ttotal: 40.4ms\tremaining: 20.2s\n",
+      "499:\ttotal: 28.5s\tremaining: 0us\n",
+      "499:\ttotal: 28.9s\tremaining: 0us\n",
+      "0:\ttotal: 56.9ms\tremaining: 28.4s\n",
+      "0:\ttotal: 59.2ms\tremaining: 29.5s\n",
+      "499:\ttotal: 29.1s\tremaining: 0us\n",
+      "0:\ttotal: 55.1ms\tremaining: 27.5s\n",
+      "100:\ttotal: 5.45s\tremaining: 21.5s\n",
+      "100:\ttotal: 5.19s\tremaining: 20.5s\n",
+      "100:\ttotal: 5.51s\tremaining: 21.8s\n",
+      "100:\ttotal: 5.23s\tremaining: 20.7s\n",
+      "100:\ttotal: 5.49s\tremaining: 21.7s\n",
+      "100:\ttotal: 5.14s\tremaining: 20.3s\n",
+      "100:\ttotal: 5.26s\tremaining: 20.8s\n",
+      "100:\ttotal: 5.92s\tremaining: 23.4s\n",
+      "200:\ttotal: 11.4s\tremaining: 17s\n",
+      "200:\ttotal: 11.3s\tremaining: 16.8s\n",
+      "200:\ttotal: 11.4s\tremaining: 17s\n",
+      "200:\ttotal: 12s\tremaining: 17.9s\n",
+      "200:\ttotal: 11.7s\tremaining: 17.5s\n",
+      "200:\ttotal: 11.3s\tremaining: 16.8s\n",
+      "200:\ttotal: 11.6s\tremaining: 17.2s\n",
+      "200:\ttotal: 11.7s\tremaining: 17.4s\n",
+      "300:\ttotal: 17.2s\tremaining: 11.4s\n",
+      "300:\ttotal: 17.1s\tremaining: 11.3s\n",
+      "300:\ttotal: 17s\tremaining: 11.2s\n",
+      "300:\ttotal: 17.6s\tremaining: 11.6s\n",
+      "300:\ttotal: 17.6s\tremaining: 11.6s\n",
+      "300:\ttotal: 17.1s\tremaining: 11.3s\n",
+      "300:\ttotal: 17.2s\tremaining: 11.4s\n",
+      "300:\ttotal: 17.7s\tremaining: 11.7s\n",
+      "400:\ttotal: 26.8s\tremaining: 6.62s\n",
+      "400:\ttotal: 26.6s\tremaining: 6.57s\n",
+      "400:\ttotal: 27.6s\tremaining: 6.81s\n",
+      "400:\ttotal: 28.6s\tremaining: 7.07s\n",
+      "400:\ttotal: 28.6s\tremaining: 7.05s\n",
+      "400:\ttotal: 28.1s\tremaining: 6.95s\n",
+      "400:\ttotal: 28.8s\tremaining: 7.1s\n",
+      "400:\ttotal: 29.2s\tremaining: 7.21s\n",
+      "499:\ttotal: 34.5s\tremaining: 0us\n",
+      "499:\ttotal: 34.1s\tremaining: 0us\n",
+      "0:\ttotal: 46ms\tremaining: 22.9s\n",
+      "0:\ttotal: 59.6ms\tremaining: 29.7s\n",
+      "499:\ttotal: 34s\tremaining: 0us\n",
+      "0:\ttotal: 52.2ms\tremaining: 26.1s\n",
+      "499:\ttotal: 35.1s\tremaining: 0us\n",
+      "499:\ttotal: 34.6s\tremaining: 0us\n",
+      "0:\ttotal: 48.9ms\tremaining: 24.4s\n",
+      "0:\ttotal: 63.8ms\tremaining: 31.8s\n",
+      "499:\ttotal: 34.6s\tremaining: 0us\n",
+      "499:\ttotal: 35s\tremaining: 0us\n",
+      "0:\ttotal: 48.6ms\tremaining: 24.3s\n",
+      "0:\ttotal: 46.9ms\tremaining: 23.4s\n",
+      "499:\ttotal: 36.1s\tremaining: 0us\n",
+      "0:\ttotal: 53.4ms\tremaining: 26.6s\n",
+      "100:\ttotal: 7.05s\tremaining: 27.9s\n",
+      "100:\ttotal: 6.88s\tremaining: 27.2s\n",
+      "100:\ttotal: 6.49s\tremaining: 25.6s\n",
+      "100:\ttotal: 7.66s\tremaining: 30.3s\n",
+      "100:\ttotal: 6.9s\tremaining: 27.3s\n",
+      "100:\ttotal: 6.67s\tremaining: 26.4s\n",
+      "100:\ttotal: 6.88s\tremaining: 27.2s\n",
+      "100:\ttotal: 6.07s\tremaining: 24s\n",
+      "200:\ttotal: 13.4s\tremaining: 19.9s\n",
+      "200:\ttotal: 13.5s\tremaining: 20.1s\n",
+      "200:\ttotal: 12.3s\tremaining: 18.3s\n",
+      "200:\ttotal: 13.7s\tremaining: 20.3s\n",
+      "200:\ttotal: 13.4s\tremaining: 19.9s\n",
+      "200:\ttotal: 13s\tremaining: 19.4s\n",
+      "200:\ttotal: 12.9s\tremaining: 19.2s\n",
+      "200:\ttotal: 11.6s\tremaining: 17.3s\n",
+      "300:\ttotal: 19.4s\tremaining: 12.8s\n",
+      "300:\ttotal: 19.8s\tremaining: 13.1s\n",
+      "300:\ttotal: 18.3s\tremaining: 12.1s\n",
+      "300:\ttotal: 19.7s\tremaining: 13s\n",
+      "300:\ttotal: 19.6s\tremaining: 13s\n",
+      "300:\ttotal: 19s\tremaining: 12.5s\n",
+      "300:\ttotal: 19.1s\tremaining: 12.6s\n",
+      "300:\ttotal: 17.4s\tremaining: 11.5s\n",
+      "400:\ttotal: 25.6s\tremaining: 6.31s\n",
+      "400:\ttotal: 25.9s\tremaining: 6.41s\n",
+      "400:\ttotal: 24.2s\tremaining: 5.96s\n",
+      "400:\ttotal: 25.8s\tremaining: 6.37s\n",
+      "400:\ttotal: 25.4s\tremaining: 6.28s\n",
+      "400:\ttotal: 24.6s\tremaining: 6.08s\n",
+      "400:\ttotal: 24.8s\tremaining: 6.13s\n",
+      "400:\ttotal: 23.1s\tremaining: 5.71s\n",
+      "499:\ttotal: 31.4s\tremaining: 0us\n",
+      "499:\ttotal: 29.5s\tremaining: 0us\n",
+      "499:\ttotal: 31.6s\tremaining: 0us\n",
+      "0:\ttotal: 54.9ms\tremaining: 27.4s\n",
+      "0:\ttotal: 67.9ms\tremaining: 33.9s\n",
+      "499:\ttotal: 31.5s\tremaining: 0us\n",
+      "0:\ttotal: 35.1ms\tremaining: 17.5s\n",
+      "0:\ttotal: 106ms\tremaining: 53s\n",
+      "499:\ttotal: 31.3s\tremaining: 0us\n",
+      "499:\ttotal: 30.2s\tremaining: 0us\n",
+      "0:\ttotal: 46.4ms\tremaining: 23.1s\n",
+      "499:\ttotal: 30.2s\tremaining: 0us\n",
+      "0:\ttotal: 77ms\tremaining: 38.4s\n",
+      "0:\ttotal: 83.5ms\tremaining: 41.7s\n",
+      "499:\ttotal: 29s\tremaining: 0us\n",
+      "0:\ttotal: 36.3ms\tremaining: 18.1s\n",
+      "100:\ttotal: 5.67s\tremaining: 22.4s\n",
+      "100:\ttotal: 6.4s\tremaining: 25.3s\n",
+      "100:\ttotal: 6.06s\tremaining: 24s\n",
+      "100:\ttotal: 6.4s\tremaining: 25.3s\n",
+      "100:\ttotal: 5.87s\tremaining: 23.2s\n",
+      "100:\ttotal: 6.3s\tremaining: 24.9s\n",
+      "100:\ttotal: 6.25s\tremaining: 24.7s\n",
+      "100:\ttotal: 5.85s\tremaining: 23.1s\n",
+      "200:\ttotal: 11.1s\tremaining: 16.6s\n",
+      "200:\ttotal: 11.8s\tremaining: 17.6s\n",
+      "200:\ttotal: 12.4s\tremaining: 18.4s\n",
+      "200:\ttotal: 12.2s\tremaining: 18.1s\n",
+      "200:\ttotal: 11.4s\tremaining: 17s\n",
+      "200:\ttotal: 12s\tremaining: 17.8s\n",
+      "200:\ttotal: 12.5s\tremaining: 18.6s\n",
+      "200:\ttotal: 12.1s\tremaining: 18s\n",
+      "300:\ttotal: 16.7s\tremaining: 11.1s\n",
+      "300:\ttotal: 17.8s\tremaining: 11.8s\n",
+      "300:\ttotal: 18.6s\tremaining: 12.3s\n",
+      "300:\ttotal: 18.4s\tremaining: 12.2s\n",
+      "300:\ttotal: 17.7s\tremaining: 11.7s\n",
+      "300:\ttotal: 17.8s\tremaining: 11.8s\n",
+      "300:\ttotal: 18.5s\tremaining: 12.2s\n",
+      "300:\ttotal: 17.9s\tremaining: 11.8s\n",
+      "400:\ttotal: 22.4s\tremaining: 5.52s\n",
+      "400:\ttotal: 24.4s\tremaining: 6.03s\n",
+      "400:\ttotal: 24s\tremaining: 5.93s\n",
+      "400:\ttotal: 24.1s\tremaining: 5.95s\n",
+      "400:\ttotal: 23.6s\tremaining: 5.84s\n",
+      "400:\ttotal: 23.7s\tremaining: 5.85s\n",
+      "400:\ttotal: 24.5s\tremaining: 6.06s\n",
+      "400:\ttotal: 24s\tremaining: 5.92s\n",
+      "499:\ttotal: 28s\tremaining: 0us\n",
+      "0:\ttotal: 108ms\tremaining: 53.8s\n",
+      "499:\ttotal: 30.1s\tremaining: 0us\n",
+      "499:\ttotal: 29.7s\tremaining: 0us\n",
+      "0:\ttotal: 80.9ms\tremaining: 40.4s\n",
+      "0:\ttotal: 71.2ms\tremaining: 35.5s\n",
+      "499:\ttotal: 30.2s\tremaining: 0us\n",
+      "499:\ttotal: 29.4s\tremaining: 0us\n",
+      "0:\ttotal: 66.8ms\tremaining: 33.3s\n",
+      "0:\ttotal: 56.8ms\tremaining: 28.3s\n",
+      "499:\ttotal: 29.4s\tremaining: 0us\n",
+      "499:\ttotal: 30.2s\tremaining: 0us\n",
+      "0:\ttotal: 76.4ms\tremaining: 38.1s\n",
+      "499:\ttotal: 29.9s\tremaining: 0us\n",
+      "0:\ttotal: 169ms\tremaining: 1m 24s\n",
+      "100:\ttotal: 5.66s\tremaining: 22.4s\n",
+      "0:\ttotal: 60.1ms\tremaining: 30s\n",
+      "100:\ttotal: 6.21s\tremaining: 24.5s\n",
+      "100:\ttotal: 6.26s\tremaining: 24.7s\n",
+      "100:\ttotal: 5.96s\tremaining: 23.5s\n",
+      "100:\ttotal: 6s\tremaining: 23.7s\n",
+      "100:\ttotal: 6.37s\tremaining: 25.2s\n",
+      "100:\ttotal: 6.17s\tremaining: 24.4s\n",
+      "100:\ttotal: 5.88s\tremaining: 23.3s\n",
+      "200:\ttotal: 11.7s\tremaining: 17.5s\n",
+      "200:\ttotal: 12.1s\tremaining: 17.9s\n",
+      "200:\ttotal: 12.1s\tremaining: 18s\n",
+      "200:\ttotal: 11.9s\tremaining: 17.7s\n",
+      "200:\ttotal: 12.1s\tremaining: 18.1s\n",
+      "200:\ttotal: 12.4s\tremaining: 18.5s\n",
+      "200:\ttotal: 11.9s\tremaining: 17.6s\n",
+      "200:\ttotal: 11.7s\tremaining: 17.3s\n",
+      "300:\ttotal: 17.8s\tremaining: 11.7s\n",
+      "300:\ttotal: 18.2s\tremaining: 12.1s\n",
+      "300:\ttotal: 18.2s\tremaining: 12.1s\n",
+      "300:\ttotal: 17.7s\tremaining: 11.7s\n",
+      "300:\ttotal: 18.4s\tremaining: 12.2s\n",
+      "300:\ttotal: 18.6s\tremaining: 12.3s\n",
+      "300:\ttotal: 17.8s\tremaining: 11.8s\n",
+      "300:\ttotal: 17.9s\tremaining: 11.8s\n",
+      "400:\ttotal: 23.8s\tremaining: 5.87s\n",
+      "400:\ttotal: 24s\tremaining: 5.94s\n",
+      "400:\ttotal: 23.4s\tremaining: 5.79s\n",
+      "400:\ttotal: 24.1s\tremaining: 5.96s\n",
+      "400:\ttotal: 24.2s\tremaining: 5.97s\n",
+      "400:\ttotal: 24.3s\tremaining: 6s\n",
+      "400:\ttotal: 23.7s\tremaining: 5.85s\n",
+      "400:\ttotal: 23.2s\tremaining: 5.72s\n",
+      "499:\ttotal: 29.2s\tremaining: 0us\n",
+      "0:\ttotal: 64.5ms\tremaining: 32.2s\n",
+      "499:\ttotal: 29.6s\tremaining: 0us\n",
+      "499:\ttotal: 29.7s\tremaining: 0us\n",
+      "499:\ttotal: 29.1s\tremaining: 0us\n",
+      "0:\ttotal: 34.1ms\tremaining: 17s\n",
+      "0:\ttotal: 49.8ms\tremaining: 24.9s\n",
+      "0:\ttotal: 45.5ms\tremaining: 22.7s\n",
+      "499:\ttotal: 29.9s\tremaining: 0us\n",
+      "0:\ttotal: 46.6ms\tremaining: 23.3s\n",
+      "499:\ttotal: 30s\tremaining: 0us\n",
+      "499:\ttotal: 29s\tremaining: 0us\n",
+      "0:\ttotal: 45.9ms\tremaining: 22.9s\n",
+      "0:\ttotal: 42.1ms\tremaining: 21s\n",
+      "499:\ttotal: 28.9s\tremaining: 0us\n",
+      "100:\ttotal: 5.27s\tremaining: 20.8s\n",
+      "0:\ttotal: 79.8ms\tremaining: 39.8s\n",
+      "100:\ttotal: 5.51s\tremaining: 21.8s\n",
+      "100:\ttotal: 5.44s\tremaining: 21.5s\n",
+      "100:\ttotal: 5.86s\tremaining: 23.2s\n",
+      "100:\ttotal: 5.91s\tremaining: 23.3s\n",
+      "100:\ttotal: 5.84s\tremaining: 23.1s\n",
+      "100:\ttotal: 5.94s\tremaining: 23.5s\n",
+      "200:\ttotal: 11.3s\tremaining: 16.8s\n",
+      "100:\ttotal: 5.37s\tremaining: 21.2s\n",
+      "200:\ttotal: 10.7s\tremaining: 15.9s\n",
+      "200:\ttotal: 10.6s\tremaining: 15.8s\n",
+      "200:\ttotal: 11.1s\tremaining: 16.5s\n",
+      "200:\ttotal: 11.1s\tremaining: 16.5s\n",
+      "200:\ttotal: 11s\tremaining: 16.3s\n",
+      "200:\ttotal: 11.2s\tremaining: 16.6s\n",
+      "200:\ttotal: 10.7s\tremaining: 15.9s\n",
+      "300:\ttotal: 16.8s\tremaining: 11.1s\n",
+      "300:\ttotal: 16.2s\tremaining: 10.7s\n",
+      "300:\ttotal: 15.9s\tremaining: 10.5s\n",
+      "300:\ttotal: 16.4s\tremaining: 10.8s\n",
+      "300:\ttotal: 16.4s\tremaining: 10.8s\n",
+      "300:\ttotal: 16.5s\tremaining: 10.9s\n",
+      "300:\ttotal: 16.7s\tremaining: 11.1s\n",
+      "300:\ttotal: 16.1s\tremaining: 10.6s\n",
+      "400:\ttotal: 22.1s\tremaining: 5.46s\n",
+      "400:\ttotal: 21.5s\tremaining: 5.31s\n",
+      "400:\ttotal: 21.2s\tremaining: 5.25s\n",
+      "400:\ttotal: 22s\tremaining: 5.42s\n",
+      "400:\ttotal: 21.9s\tremaining: 5.4s\n",
+      "400:\ttotal: 21.9s\tremaining: 5.41s\n",
+      "400:\ttotal: 22.4s\tremaining: 5.52s\n",
+      "499:\ttotal: 27.5s\tremaining: 0us\n",
+      "400:\ttotal: 21.6s\tremaining: 5.32s\n",
+      "0:\ttotal: 52.6ms\tremaining: 26.3s\n",
+      "499:\ttotal: 26.7s\tremaining: 0us\n",
+      "499:\ttotal: 27.1s\tremaining: 0us\n",
+      "0:\ttotal: 65ms\tremaining: 32.5s\n",
+      "0:\ttotal: 52.4ms\tremaining: 26.1s\n",
+      "499:\ttotal: 27.6s\tremaining: 0us\n",
+      "0:\ttotal: 53.9ms\tremaining: 26.9s\n",
+      "499:\ttotal: 27.2s\tremaining: 0us\n",
+      "0:\ttotal: 44.3ms\tremaining: 22.1s\n",
+      "499:\ttotal: 27.6s\tremaining: 0us\n",
+      "499:\ttotal: 28s\tremaining: 0us\n",
+      "0:\ttotal: 40.5ms\tremaining: 20.2s\n",
+      "499:\ttotal: 27s\tremaining: 0us\n",
+      "0:\ttotal: 46.3ms\tremaining: 23.1s\n",
+      "0:\ttotal: 59.9ms\tremaining: 29.9s\n",
+      "100:\ttotal: 5.48s\tremaining: 21.6s\n",
+      "100:\ttotal: 5.86s\tremaining: 23.2s\n",
+      "100:\ttotal: 5.9s\tremaining: 23.3s\n",
+      "100:\ttotal: 5.99s\tremaining: 23.7s\n",
+      "100:\ttotal: 6.37s\tremaining: 25.2s\n",
+      "100:\ttotal: 6.11s\tremaining: 24.1s\n",
+      "100:\ttotal: 6.09s\tremaining: 24.1s\n",
+      "100:\ttotal: 6.05s\tremaining: 23.9s\n",
+      "200:\ttotal: 11.6s\tremaining: 17.2s\n",
+      "200:\ttotal: 11.3s\tremaining: 16.8s\n",
+      "200:\ttotal: 11.5s\tremaining: 17.1s\n",
+      "200:\ttotal: 11.9s\tremaining: 17.6s\n",
+      "200:\ttotal: 12.3s\tremaining: 18.2s\n",
+      "200:\ttotal: 11.6s\tremaining: 17.2s\n",
+      "200:\ttotal: 12s\tremaining: 17.9s\n",
+      "200:\ttotal: 11.9s\tremaining: 17.6s\n",
+      "300:\ttotal: 17.5s\tremaining: 11.5s\n",
+      "300:\ttotal: 17.2s\tremaining: 11.3s\n",
+      "300:\ttotal: 17.5s\tremaining: 11.5s\n",
+      "300:\ttotal: 17.8s\tremaining: 11.8s\n",
+      "300:\ttotal: 18.1s\tremaining: 12s\n",
+      "300:\ttotal: 17.6s\tremaining: 11.6s\n",
+      "300:\ttotal: 17.5s\tremaining: 11.5s\n",
+      "400:\ttotal: 23s\tremaining: 5.69s\n",
+      "300:\ttotal: 17.8s\tremaining: 11.8s\n",
+      "400:\ttotal: 22.5s\tremaining: 5.55s\n",
+      "400:\ttotal: 23.3s\tremaining: 5.75s\n",
+      "400:\ttotal: 23.3s\tremaining: 5.76s\n",
+      "400:\ttotal: 23.9s\tremaining: 5.91s\n",
+      "400:\ttotal: 23.2s\tremaining: 5.72s\n",
+      "400:\ttotal: 23.6s\tremaining: 5.82s\n",
+      "499:\ttotal: 28.5s\tremaining: 0us\n",
+      "400:\ttotal: 23.4s\tremaining: 5.78s\n",
+      "0:\ttotal: 55.5ms\tremaining: 27.7s\n",
+      "499:\ttotal: 28.3s\tremaining: 0us\n",
+      "0:\ttotal: 44.4ms\tremaining: 22.2s\n",
+      "499:\ttotal: 29.3s\tremaining: 0us\n",
+      "499:\ttotal: 28.9s\tremaining: 0us\n",
+      "0:\ttotal: 39.4ms\tremaining: 19.7s\n",
+      "0:\ttotal: 58.3ms\tremaining: 29.1s\n",
+      "499:\ttotal: 29.6s\tremaining: 0us\n",
+      "0:\ttotal: 64.6ms\tremaining: 32.2s\n",
+      "499:\ttotal: 28.9s\tremaining: 0us\n",
+      "499:\ttotal: 29.3s\tremaining: 0us\n",
+      "100:\ttotal: 5.39s\tremaining: 21.3s\n",
+      "0:\ttotal: 61.1ms\tremaining: 30.5s\n",
+      "499:\ttotal: 29.2s\tremaining: 0us\n",
+      "0:\ttotal: 51.1ms\tremaining: 25.5s\n",
+      "0:\ttotal: 33.8ms\tremaining: 16.9s\n",
+      "100:\ttotal: 5.21s\tremaining: 20.6s\n",
+      "100:\ttotal: 5.95s\tremaining: 23.5s\n",
+      "100:\ttotal: 5.75s\tremaining: 22.7s\n",
+      "100:\ttotal: 5.37s\tremaining: 21.2s\n",
+      "100:\ttotal: 5.75s\tremaining: 22.7s\n",
+      "100:\ttotal: 5.77s\tremaining: 22.8s\n",
+      "200:\ttotal: 11.6s\tremaining: 17.2s\n",
+      "100:\ttotal: 5.54s\tremaining: 21.9s\n",
+      "200:\ttotal: 11.6s\tremaining: 17.2s\n",
+      "200:\ttotal: 11.6s\tremaining: 17.3s\n",
+      "200:\ttotal: 11.4s\tremaining: 16.9s\n",
+      "200:\ttotal: 10.7s\tremaining: 16s\n",
+      "300:\ttotal: 16.9s\tremaining: 11.1s\n",
+      "200:\ttotal: 11.1s\tremaining: 16.5s\n",
+      "200:\ttotal: 11.5s\tremaining: 17.2s\n",
+      "200:\ttotal: 11s\tremaining: 16.3s\n",
+      "300:\ttotal: 17.3s\tremaining: 11.5s\n",
+      "300:\ttotal: 17.5s\tremaining: 11.6s\n",
+      "300:\ttotal: 17.9s\tremaining: 11.8s\n",
+      "300:\ttotal: 16.7s\tremaining: 11s\n",
+      "300:\ttotal: 16.9s\tremaining: 11.2s\n",
+      "300:\ttotal: 17.2s\tremaining: 11.4s\n",
+      "300:\ttotal: 16.4s\tremaining: 10.8s\n",
+      "400:\ttotal: 22.9s\tremaining: 5.64s\n",
+      "400:\ttotal: 23.7s\tremaining: 5.85s\n",
+      "400:\ttotal: 23.9s\tremaining: 5.89s\n",
+      "400:\ttotal: 24.5s\tremaining: 6.05s\n",
+      "400:\ttotal: 23.1s\tremaining: 5.71s\n",
+      "400:\ttotal: 22.9s\tremaining: 5.66s\n",
+      "499:\ttotal: 28.8s\tremaining: 0us\n",
+      "400:\ttotal: 22.7s\tremaining: 5.59s\n",
+      "400:\ttotal: 23.7s\tremaining: 5.84s\n",
+      "0:\ttotal: 62.3ms\tremaining: 31.1s\n",
+      "499:\ttotal: 29.5s\tremaining: 0us\n",
+      "0:\ttotal: 38.3ms\tremaining: 19.1s\n",
+      "499:\ttotal: 29.4s\tremaining: 0us\n",
+      "499:\ttotal: 29.8s\tremaining: 0us\n",
+      "499:\ttotal: 28.6s\tremaining: 0us\n",
+      "0:\ttotal: 51.8ms\tremaining: 25.9s\n",
+      "0:\ttotal: 66.1ms\tremaining: 33s\n",
+      "0:\ttotal: 62.4ms\tremaining: 31.2s\n",
+      "499:\ttotal: 28.2s\tremaining: 0us\n",
+      "0:\ttotal: 71ms\tremaining: 35.4s\n",
+      "499:\ttotal: 28s\tremaining: 0us\n",
+      "499:\ttotal: 29.1s\tremaining: 0us\n",
+      "0:\ttotal: 43.9ms\tremaining: 21.9s\n",
+      "100:\ttotal: 5.03s\tremaining: 19.9s\n",
+      "0:\ttotal: 35.1ms\tremaining: 17.5s\n",
+      "100:\ttotal: 5.54s\tremaining: 21.9s\n",
+      "100:\ttotal: 5.71s\tremaining: 22.6s\n",
+      "100:\ttotal: 5.76s\tremaining: 22.8s\n",
+      "100:\ttotal: 5.83s\tremaining: 23s\n",
+      "100:\ttotal: 5.67s\tremaining: 22.4s\n",
+      "100:\ttotal: 5.62s\tremaining: 22.2s\n",
+      "200:\ttotal: 11s\tremaining: 16.3s\n",
+      "100:\ttotal: 5.79s\tremaining: 22.9s\n",
+      "200:\ttotal: 11.2s\tremaining: 16.6s\n",
+      "200:\ttotal: 11s\tremaining: 16.4s\n",
+      "200:\ttotal: 11.5s\tremaining: 17.1s\n",
+      "200:\ttotal: 11.8s\tremaining: 17.6s\n",
+      "200:\ttotal: 11.3s\tremaining: 16.9s\n",
+      "200:\ttotal: 11.5s\tremaining: 17.2s\n",
+      "200:\ttotal: 11.5s\tremaining: 17.1s\n",
+      "300:\ttotal: 16.8s\tremaining: 11.1s\n",
+      "300:\ttotal: 17.7s\tremaining: 11.7s\n",
+      "300:\ttotal: 17.5s\tremaining: 11.6s\n",
+      "300:\ttotal: 18s\tremaining: 11.9s\n",
+      "300:\ttotal: 18.2s\tremaining: 12s\n",
+      "300:\ttotal: 17.7s\tremaining: 11.7s\n",
+      "300:\ttotal: 17.8s\tremaining: 11.8s\n",
+      "300:\ttotal: 17.7s\tremaining: 11.7s\n",
+      "400:\ttotal: 23.3s\tremaining: 5.76s\n",
+      "400:\ttotal: 23.7s\tremaining: 5.86s\n",
+      "400:\ttotal: 22.8s\tremaining: 5.62s\n",
+      "400:\ttotal: 23.7s\tremaining: 5.85s\n",
+      "400:\ttotal: 22.9s\tremaining: 5.65s\n",
+      "400:\ttotal: 24.1s\tremaining: 5.94s\n",
+      "400:\ttotal: 23.4s\tremaining: 5.77s\n",
+      "400:\ttotal: 23.3s\tremaining: 5.76s\n",
+      "499:\ttotal: 28.8s\tremaining: 0us\n",
+      "0:\ttotal: 57ms\tremaining: 28.4s\n",
+      "499:\ttotal: 29.3s\tremaining: 0us\n",
+      "499:\ttotal: 28.6s\tremaining: 0us\n",
+      "0:\ttotal: 84.7ms\tremaining: 42.3s\n",
+      "0:\ttotal: 33.3ms\tremaining: 16.6s\n",
+      "499:\ttotal: 29.3s\tremaining: 0us\n",
+      "0:\ttotal: 41.7ms\tremaining: 20.8s\n",
+      "499:\ttotal: 29s\tremaining: 0us\n",
+      "499:\ttotal: 30.1s\tremaining: 0us\n",
+      "0:\ttotal: 70.4ms\tremaining: 35.2s\n",
+      "0:\ttotal: 54.4ms\tremaining: 27.2s\n",
+      "499:\ttotal: 29.6s\tremaining: 0us\n",
+      "499:\ttotal: 29.5s\tremaining: 0us\n",
+      "0:\ttotal: 42.4ms\tremaining: 21.2s\n",
+      "100:\ttotal: 5.77s\tremaining: 22.8s\n",
+      "0:\ttotal: 87.3ms\tremaining: 43.5s\n",
+      "100:\ttotal: 5.4s\tremaining: 21.3s\n",
+      "100:\ttotal: 5.88s\tremaining: 23.2s\n",
+      "100:\ttotal: 6.14s\tremaining: 24.2s\n",
+      "100:\ttotal: 5.99s\tremaining: 23.7s\n",
+      "100:\ttotal: 6.02s\tremaining: 23.8s\n",
+      "100:\ttotal: 6.09s\tremaining: 24.1s\n",
+      "200:\ttotal: 12s\tremaining: 17.8s\n",
+      "100:\ttotal: 6.03s\tremaining: 23.8s\n",
+      "200:\ttotal: 11.3s\tremaining: 16.9s\n",
+      "200:\ttotal: 12s\tremaining: 17.9s\n",
+      "200:\ttotal: 11.8s\tremaining: 17.6s\n",
+      "200:\ttotal: 11.7s\tremaining: 17.4s\n",
+      "200:\ttotal: 11.8s\tremaining: 17.6s\n",
+      "200:\ttotal: 11.7s\tremaining: 17.4s\n",
+      "300:\ttotal: 17.5s\tremaining: 11.6s\n",
+      "200:\ttotal: 11.6s\tremaining: 17.3s\n",
+      "300:\ttotal: 16.8s\tremaining: 11.1s\n",
+      "300:\ttotal: 17.4s\tremaining: 11.5s\n",
+      "300:\ttotal: 17.3s\tremaining: 11.4s\n",
+      "300:\ttotal: 17.3s\tremaining: 11.4s\n",
+      "300:\ttotal: 17.6s\tremaining: 11.6s\n",
+      "300:\ttotal: 17.4s\tremaining: 11.5s\n",
+      "300:\ttotal: 17.3s\tremaining: 11.4s\n",
+      "400:\ttotal: 23.3s\tremaining: 5.76s\n",
+      "400:\ttotal: 22.5s\tremaining: 5.55s\n",
+      "400:\ttotal: 23.2s\tremaining: 5.72s\n",
+      "400:\ttotal: 23.1s\tremaining: 5.71s\n",
+      "400:\ttotal: 22.8s\tremaining: 5.63s\n",
+      "400:\ttotal: 23.2s\tremaining: 5.73s\n",
+      "400:\ttotal: 22.8s\tremaining: 5.63s\n",
+      "499:\ttotal: 28.8s\tremaining: 0us\n",
+      "400:\ttotal: 23.4s\tremaining: 5.77s\n",
+      "0:\ttotal: 96.8ms\tremaining: 48.3s\n",
+      "499:\ttotal: 28.4s\tremaining: 0us\n",
+      "499:\ttotal: 29s\tremaining: 0us\n",
+      "0:\ttotal: 86ms\tremaining: 42.9s\n",
+      "0:\ttotal: 81.7ms\tremaining: 40.8s\n",
+      "499:\ttotal: 29s\tremaining: 0us\n",
+      "499:\ttotal: 28.5s\tremaining: 0us\n",
+      "499:\ttotal: 29.1s\tremaining: 0us\n",
+      "0:\ttotal: 74.3ms\tremaining: 37.1s\n",
+      "0:\ttotal: 67.3ms\tremaining: 33.6s\n",
+      "499:\ttotal: 28.6s\tremaining: 0us\n",
+      "0:\ttotal: 103ms\tremaining: 51.2s\n",
+      "499:\ttotal: 29.1s\tremaining: 0us\n",
+      "0:\ttotal: 60.3ms\tremaining: 30.1s\n",
+      "0:\ttotal: 84.9ms\tremaining: 42.3s\n",
+      "100:\ttotal: 6.61s\tremaining: 26.1s\n",
+      "100:\ttotal: 6.96s\tremaining: 27.5s\n",
+      "100:\ttotal: 7.56s\tremaining: 29.9s\n",
+      "100:\ttotal: 8.21s\tremaining: 32.4s\n",
+      "100:\ttotal: 8.36s\tremaining: 33s\n",
+      "100:\ttotal: 8.99s\tremaining: 35.5s\n",
+      "100:\ttotal: 8.51s\tremaining: 33.6s\n",
+      "100:\ttotal: 8.77s\tremaining: 34.6s\n",
+      "200:\ttotal: 15.2s\tremaining: 22.6s\n",
+      "200:\ttotal: 15.4s\tremaining: 22.9s\n",
+      "200:\ttotal: 15.8s\tremaining: 23.5s\n",
+      "200:\ttotal: 15.9s\tremaining: 23.6s\n",
+      "200:\ttotal: 16s\tremaining: 23.8s\n",
+      "200:\ttotal: 16.3s\tremaining: 24.3s\n",
+      "200:\ttotal: 16s\tremaining: 23.9s\n",
+      "200:\ttotal: 16s\tremaining: 23.9s\n",
+      "300:\ttotal: 22.8s\tremaining: 15.1s\n",
+      "300:\ttotal: 22.9s\tremaining: 15.2s\n",
+      "300:\ttotal: 23.3s\tremaining: 15.4s\n",
+      "300:\ttotal: 23.8s\tremaining: 15.7s\n",
+      "300:\ttotal: 24s\tremaining: 15.9s\n",
+      "300:\ttotal: 24.5s\tremaining: 16.2s\n",
+      "300:\ttotal: 24.1s\tremaining: 15.9s\n",
+      "400:\ttotal: 30.4s\tremaining: 7.51s\n",
+      "300:\ttotal: 24.5s\tremaining: 16.2s\n",
+      "400:\ttotal: 30.8s\tremaining: 7.59s\n",
+      "400:\ttotal: 31.3s\tremaining: 7.72s\n",
+      "400:\ttotal: 31.7s\tremaining: 7.82s\n",
+      "400:\ttotal: 31.7s\tremaining: 7.82s\n",
+      "400:\ttotal: 32.6s\tremaining: 8.05s\n",
+      "499:\ttotal: 38.1s\tremaining: 0us\n",
+      "0:\ttotal: 48.2ms\tremaining: 24.1s\n",
+      "400:\ttotal: 32.6s\tremaining: 8.05s\n",
+      "400:\ttotal: 32.7s\tremaining: 8.07s\n",
+      "499:\ttotal: 38.5s\tremaining: 0us\n",
+      "499:\ttotal: 39.2s\tremaining: 0us\n",
+      "0:\ttotal: 74.5ms\tremaining: 37.2s\n",
+      "0:\ttotal: 68.8ms\tremaining: 34.3s\n",
+      "499:\ttotal: 39.8s\tremaining: 0us\n",
+      "0:\ttotal: 88.6ms\tremaining: 44.2s\n",
+      "499:\ttotal: 40.3s\tremaining: 0us\n",
+      "0:\ttotal: 74.8ms\tremaining: 37.3s\n",
+      "499:\ttotal: 41.4s\tremaining: 0us\n",
+      "100:\ttotal: 8.38s\tremaining: 33.1s\n",
+      "499:\ttotal: 41.4s\tremaining: 0us\n",
+      "0:\ttotal: 64.9ms\tremaining: 32.4s\n",
+      "499:\ttotal: 41.6s\tremaining: 0us\n",
+      "0:\ttotal: 95.7ms\tremaining: 47.8s\n",
+      "0:\ttotal: 68ms\tremaining: 33.9s\n",
+      "100:\ttotal: 7.53s\tremaining: 29.7s\n",
+      "100:\ttotal: 7.42s\tremaining: 29.3s\n",
+      "100:\ttotal: 7.41s\tremaining: 29.3s\n",
+      "100:\ttotal: 7.77s\tremaining: 30.7s\n",
+      "200:\ttotal: 15.8s\tremaining: 23.4s\n",
+      "100:\ttotal: 7.39s\tremaining: 29.2s\n",
+      "100:\ttotal: 7.44s\tremaining: 29.4s\n",
+      "100:\ttotal: 7.77s\tremaining: 30.7s\n",
+      "200:\ttotal: 15.5s\tremaining: 23.1s\n",
+      "200:\ttotal: 15.5s\tremaining: 23.1s\n",
+      "200:\ttotal: 15.6s\tremaining: 23.2s\n",
+      "200:\ttotal: 16s\tremaining: 23.8s\n",
+      "300:\ttotal: 24s\tremaining: 15.9s\n",
+      "200:\ttotal: 15.6s\tremaining: 23.2s\n",
+      "200:\ttotal: 15.4s\tremaining: 23s\n",
+      "200:\ttotal: 15.8s\tremaining: 23.5s\n",
+      "300:\ttotal: 23.4s\tremaining: 15.5s\n",
+      "300:\ttotal: 23.9s\tremaining: 15.8s\n",
+      "300:\ttotal: 23.5s\tremaining: 15.6s\n",
+      "300:\ttotal: 24.2s\tremaining: 16s\n",
+      "400:\ttotal: 32.8s\tremaining: 8.09s\n",
+      "300:\ttotal: 24.5s\tremaining: 16.2s\n",
+      "300:\ttotal: 24.1s\tremaining: 16s\n",
+      "300:\ttotal: 24.3s\tremaining: 16.1s\n",
+      "400:\ttotal: 31.9s\tremaining: 7.87s\n",
+      "400:\ttotal: 32.2s\tremaining: 7.96s\n",
+      "400:\ttotal: 32.2s\tremaining: 7.94s\n",
+      "400:\ttotal: 32.8s\tremaining: 8.11s\n",
+      "499:\ttotal: 41s\tremaining: 0us\n",
+      "400:\ttotal: 32.7s\tremaining: 8.07s\n",
+      "400:\ttotal: 32.3s\tremaining: 7.97s\n",
+      "0:\ttotal: 92.3ms\tremaining: 46.1s\n",
+      "400:\ttotal: 32.3s\tremaining: 7.98s\n",
+      "499:\ttotal: 40.4s\tremaining: 0us\n",
+      "499:\ttotal: 40.2s\tremaining: 0us\n",
+      "0:\ttotal: 101ms\tremaining: 50.5s\n",
+      "0:\ttotal: 66.8ms\tremaining: 33.3s\n",
+      "499:\ttotal: 40.2s\tremaining: 0us\n",
+      "0:\ttotal: 67ms\tremaining: 33.4s\n",
+      "499:\ttotal: 40.9s\tremaining: 0us\n",
+      "0:\ttotal: 79.5ms\tremaining: 39.7s\n",
+      "499:\ttotal: 41s\tremaining: 0us\n",
+      "499:\ttotal: 40.5s\tremaining: 0us\n",
+      "100:\ttotal: 8.07s\tremaining: 31.9s\n",
+      "499:\ttotal: 40.2s\tremaining: 0us\n",
+      "0:\ttotal: 74.5ms\tremaining: 37.2s\n",
+      "0:\ttotal: 76.7ms\tremaining: 38.3s\n",
+      "0:\ttotal: 58.1ms\tremaining: 29s\n",
+      "100:\ttotal: 8.29s\tremaining: 32.8s\n",
+      "100:\ttotal: 7.86s\tremaining: 31.1s\n",
+      "100:\ttotal: 7.78s\tremaining: 30.7s\n",
+      "100:\ttotal: 7.48s\tremaining: 29.6s\n",
+      "200:\ttotal: 16s\tremaining: 23.7s\n",
+      "100:\ttotal: 7.21s\tremaining: 28.5s\n",
+      "100:\ttotal: 7.25s\tremaining: 28.6s\n",
+      "100:\ttotal: 7.18s\tremaining: 28.4s\n",
+      "200:\ttotal: 16.2s\tremaining: 24.1s\n",
+      "200:\ttotal: 16s\tremaining: 23.8s\n",
+      "200:\ttotal: 16s\tremaining: 23.8s\n",
+      "200:\ttotal: 15.2s\tremaining: 22.6s\n",
+      "200:\ttotal: 15s\tremaining: 22.3s\n",
+      "200:\ttotal: 15.2s\tremaining: 22.6s\n",
+      "300:\ttotal: 24.4s\tremaining: 16.1s\n",
+      "200:\ttotal: 15.2s\tremaining: 22.6s\n",
+      "300:\ttotal: 24.5s\tremaining: 16.2s\n",
+      "300:\ttotal: 24.3s\tremaining: 16.1s\n",
+      "300:\ttotal: 22.6s\tremaining: 14.9s\n",
+      "300:\ttotal: 24.3s\tremaining: 16.1s\n",
+      "300:\ttotal: 22.5s\tremaining: 14.9s\n",
+      "300:\ttotal: 22.6s\tremaining: 14.9s\n",
+      "300:\ttotal: 22.8s\tremaining: 15.1s\n",
+      "400:\ttotal: 32.5s\tremaining: 8.01s\n",
+      "400:\ttotal: 32.3s\tremaining: 7.98s\n",
+      "400:\ttotal: 32.3s\tremaining: 7.96s\n",
+      "400:\ttotal: 30.6s\tremaining: 7.54s\n",
+      "400:\ttotal: 32.6s\tremaining: 8.04s\n",
+      "400:\ttotal: 30.1s\tremaining: 7.44s\n",
+      "400:\ttotal: 30.4s\tremaining: 7.51s\n",
+      "400:\ttotal: 30.4s\tremaining: 7.5s\n",
+      "499:\ttotal: 40.4s\tremaining: 0us\n",
+      "0:\ttotal: 73.7ms\tremaining: 36.8s\n",
+      "499:\ttotal: 40.4s\tremaining: 0us\n",
+      "499:\ttotal: 40.4s\tremaining: 0us\n",
+      "0:\ttotal: 90.2ms\tremaining: 45s\n",
+      "0:\ttotal: 63.4ms\tremaining: 31.6s\n",
+      "499:\ttotal: 37.8s\tremaining: 0us\n",
+      "0:\ttotal: 84.1ms\tremaining: 42s\n",
+      "499:\ttotal: 40.5s\tremaining: 0us\n",
+      "499:\ttotal: 37.5s\tremaining: 0us\n",
+      "0:\ttotal: 103ms\tremaining: 51.2s\n",
+      "0:\ttotal: 66.8ms\tremaining: 33.3s\n",
+      "499:\ttotal: 38s\tremaining: 0us\n",
+      "499:\ttotal: 38s\tremaining: 0us\n",
+      "0:\ttotal: 104ms\tremaining: 52s\n",
+      "0:\ttotal: 115ms\tremaining: 57.6s\n",
+      "100:\ttotal: 7.23s\tremaining: 28.6s\n",
+      "100:\ttotal: 8.71s\tremaining: 34.4s\n",
+      "100:\ttotal: 8.51s\tremaining: 33.6s\n",
+      "100:\ttotal: 8.23s\tremaining: 32.5s\n",
+      "100:\ttotal: 8.21s\tremaining: 32.4s\n",
+      "100:\ttotal: 8.35s\tremaining: 33s\n",
+      "100:\ttotal: 8.47s\tremaining: 33.5s\n",
+      "100:\ttotal: 8.54s\tremaining: 33.7s\n",
+      "200:\ttotal: 15.8s\tremaining: 23.5s\n",
+      "200:\ttotal: 16.5s\tremaining: 24.5s\n",
+      "200:\ttotal: 17s\tremaining: 25.3s\n",
+      "200:\ttotal: 16s\tremaining: 23.8s\n",
+      "200:\ttotal: 16.1s\tremaining: 23.9s\n",
+      "200:\ttotal: 16.3s\tremaining: 24.2s\n",
+      "200:\ttotal: 17.1s\tremaining: 25.4s\n",
+      "200:\ttotal: 16.7s\tremaining: 24.8s\n",
+      "300:\ttotal: 24.3s\tremaining: 16.1s\n",
+      "300:\ttotal: 24.8s\tremaining: 16.4s\n",
+      "300:\ttotal: 23.9s\tremaining: 15.8s\n",
+      "300:\ttotal: 25.1s\tremaining: 16.6s\n",
+      "300:\ttotal: 24.4s\tremaining: 16.1s\n",
+      "300:\ttotal: 24.7s\tremaining: 16.3s\n",
+      "300:\ttotal: 25.3s\tremaining: 16.7s\n",
+      "300:\ttotal: 25s\tremaining: 16.5s\n",
+      "400:\ttotal: 32.3s\tremaining: 7.96s\n",
+      "400:\ttotal: 31.9s\tremaining: 7.88s\n",
+      "400:\ttotal: 33.2s\tremaining: 8.18s\n",
+      "400:\ttotal: 33.5s\tremaining: 8.26s\n",
+      "400:\ttotal: 32.5s\tremaining: 8.02s\n",
+      "400:\ttotal: 33.5s\tremaining: 8.28s\n",
+      "400:\ttotal: 34s\tremaining: 8.38s\n",
+      "400:\ttotal: 33.8s\tremaining: 8.36s\n",
+      "499:\ttotal: 40.8s\tremaining: 0us\n",
+      "0:\ttotal: 97ms\tremaining: 48.4s\n",
+      "499:\ttotal: 40.3s\tremaining: 0us\n",
+      "499:\ttotal: 41.6s\tremaining: 0us\n",
+      "0:\ttotal: 73.3ms\tremaining: 36.6s\n",
+      "499:\ttotal: 42.1s\tremaining: 0us\n",
+      "0:\ttotal: 80.7ms\tremaining: 40.3s\n",
+      "0:\ttotal: 89.1ms\tremaining: 44.5s\n",
+      "499:\ttotal: 40.8s\tremaining: 0us\n",
+      "0:\ttotal: 69.9ms\tremaining: 34.9s\n",
+      "499:\ttotal: 41.7s\tremaining: 0us\n",
+      "0:\ttotal: 65.8ms\tremaining: 32.8s\n",
+      "499:\ttotal: 41.9s\tremaining: 0us\n",
+      "499:\ttotal: 41.7s\tremaining: 0us\n",
+      "100:\ttotal: 7.19s\tremaining: 28.4s\n",
+      "0:\ttotal: 69.1ms\tremaining: 34.5s\n",
+      "0:\ttotal: 69.7ms\tremaining: 34.8s\n",
+      "100:\ttotal: 7.23s\tremaining: 28.6s\n",
+      "100:\ttotal: 7.28s\tremaining: 28.8s\n",
+      "100:\ttotal: 7.71s\tremaining: 30.4s\n",
+      "100:\ttotal: 7.3s\tremaining: 28.8s\n",
+      "100:\ttotal: 7.64s\tremaining: 30.2s\n",
+      "100:\ttotal: 7.83s\tremaining: 30.9s\n",
+      "200:\ttotal: 15.3s\tremaining: 22.7s\n",
+      "100:\ttotal: 7.9s\tremaining: 31.2s\n",
+      "200:\ttotal: 15.2s\tremaining: 22.6s\n",
+      "200:\ttotal: 15.7s\tremaining: 23.3s\n",
+      "200:\ttotal: 16s\tremaining: 23.8s\n",
+      "200:\ttotal: 15.6s\tremaining: 23.3s\n",
+      "200:\ttotal: 15.8s\tremaining: 23.5s\n",
+      "300:\ttotal: 23.1s\tremaining: 15.3s\n",
+      "200:\ttotal: 15.8s\tremaining: 23.6s\n",
+      "200:\ttotal: 16s\tremaining: 23.8s\n",
+      "300:\ttotal: 23.2s\tremaining: 15.3s\n",
+      "300:\ttotal: 24.3s\tremaining: 16.1s\n",
+      "300:\ttotal: 24.4s\tremaining: 16.1s\n",
+      "300:\ttotal: 24.1s\tremaining: 16s\n",
+      "300:\ttotal: 24.3s\tremaining: 16.1s\n",
+      "300:\ttotal: 24.1s\tremaining: 15.9s\n",
+      "400:\ttotal: 31.4s\tremaining: 7.75s\n",
+      "300:\ttotal: 24.4s\tremaining: 16.2s\n",
+      "400:\ttotal: 31.7s\tremaining: 7.83s\n",
+      "400:\ttotal: 32.8s\tremaining: 8.09s\n",
+      "400:\ttotal: 32.5s\tremaining: 8.03s\n",
+      "400:\ttotal: 32.1s\tremaining: 7.92s\n",
+      "400:\ttotal: 32.4s\tremaining: 8s\n",
+      "499:\ttotal: 39.2s\tremaining: 0us\n",
+      "400:\ttotal: 32.1s\tremaining: 7.92s\n",
+      "0:\ttotal: 88.1ms\tremaining: 44s\n",
+      "400:\ttotal: 32.8s\tremaining: 8.09s\n",
+      "499:\ttotal: 40.1s\tremaining: 0us\n",
+      "0:\ttotal: 60.4ms\tremaining: 30.2s\n",
+      "499:\ttotal: 41.8s\tremaining: 0us\n",
+      "499:\ttotal: 41.4s\tremaining: 0us\n",
+      "0:\ttotal: 64.4ms\tremaining: 32.2s\n",
+      "0:\ttotal: 78.2ms\tremaining: 39s\n",
+      "499:\ttotal: 41.2s\tremaining: 0us\n",
+      "499:\ttotal: 41.2s\tremaining: 0us\n",
+      "100:\ttotal: 7.99s\tremaining: 31.6s\n",
+      "0:\ttotal: 73.8ms\tremaining: 36.8s\n",
+      "499:\ttotal: 40.8s\tremaining: 0us\n",
+      "0:\ttotal: 69.1ms\tremaining: 34.5s\n",
+      "0:\ttotal: 96.6ms\tremaining: 48.2s\n",
+      "499:\ttotal: 42.1s\tremaining: 0us\n",
+      "0:\ttotal: 52.4ms\tremaining: 26.2s\n",
+      "100:\ttotal: 7.37s\tremaining: 29.1s\n",
+      "100:\ttotal: 7.64s\tremaining: 30.2s\n",
+      "100:\ttotal: 7.38s\tremaining: 29.2s\n",
+      "200:\ttotal: 15.9s\tremaining: 23.6s\n",
+      "100:\ttotal: 7.88s\tremaining: 31.1s\n",
+      "100:\ttotal: 7.52s\tremaining: 29.7s\n",
+      "100:\ttotal: 8.07s\tremaining: 31.9s\n",
+      "100:\ttotal: 8.39s\tremaining: 33.2s\n",
+      "200:\ttotal: 15.8s\tremaining: 23.4s\n",
+      "200:\ttotal: 16.4s\tremaining: 24.4s\n",
+      "200:\ttotal: 16.4s\tremaining: 24.3s\n",
+      "300:\ttotal: 24.6s\tremaining: 16.2s\n",
+      "200:\ttotal: 16.6s\tremaining: 24.7s\n",
+      "200:\ttotal: 16.2s\tremaining: 24.1s\n",
+      "200:\ttotal: 16.9s\tremaining: 25.2s\n",
+      "200:\ttotal: 16.7s\tremaining: 24.9s\n",
+      "300:\ttotal: 24.3s\tremaining: 16.1s\n",
+      "300:\ttotal: 24.4s\tremaining: 16.1s\n",
+      "300:\ttotal: 24.2s\tremaining: 16s\n",
+      "300:\ttotal: 24.1s\tremaining: 15.9s\n",
+      "400:\ttotal: 32.5s\tremaining: 8.02s\n",
+      "300:\ttotal: 24.7s\tremaining: 16.3s\n",
+      "300:\ttotal: 25.3s\tremaining: 16.7s\n",
+      "300:\ttotal: 24.8s\tremaining: 16.4s\n",
+      "400:\ttotal: 32.3s\tremaining: 7.96s\n",
+      "400:\ttotal: 31.9s\tremaining: 7.87s\n",
+      "400:\ttotal: 32.4s\tremaining: 8s\n",
+      "400:\ttotal: 31.5s\tremaining: 7.77s\n",
+      "499:\ttotal: 39.9s\tremaining: 0us\n",
+      "0:\ttotal: 62.8ms\tremaining: 31.3s\n",
+      "400:\ttotal: 32.5s\tremaining: 8.02s\n",
+      "400:\ttotal: 33.1s\tremaining: 8.16s\n",
+      "400:\ttotal: 33s\tremaining: 8.15s\n",
+      "499:\ttotal: 40.2s\tremaining: 0us\n",
+      "0:\ttotal: 82.9ms\tremaining: 41.4s\n",
+      "499:\ttotal: 39.5s\tremaining: 0us\n",
+      "0:\ttotal: 73.2ms\tremaining: 36.5s\n",
+      "499:\ttotal: 41.1s\tremaining: 0us\n",
+      "499:\ttotal: 40.3s\tremaining: 0us\n",
+      "0:\ttotal: 68.6ms\tremaining: 34.2s\n",
+      "0:\ttotal: 114ms\tremaining: 56.9s\n",
+      "100:\ttotal: 9.3s\tremaining: 36.8s\n",
+      "499:\ttotal: 41.8s\tremaining: 0us\n",
+      "499:\ttotal: 42.4s\tremaining: 0us\n",
+      "0:\ttotal: 91.2ms\tremaining: 45.5s\n",
+      "0:\ttotal: 64.7ms\tremaining: 32.3s\n",
+      "499:\ttotal: 42.5s\tremaining: 0us\n",
+      "100:\ttotal: 8.42s\tremaining: 33.3s\n",
+      "0:\ttotal: 93.1ms\tremaining: 46.4s\n",
+      "100:\ttotal: 8.49s\tremaining: 33.5s\n",
+      "100:\ttotal: 7.69s\tremaining: 30.4s\n",
+      "100:\ttotal: 8.17s\tremaining: 32.3s\n",
+      "200:\ttotal: 17s\tremaining: 25.3s\n",
+      "100:\ttotal: 7.27s\tremaining: 28.7s\n",
+      "100:\ttotal: 7.47s\tremaining: 29.5s\n",
+      "200:\ttotal: 15.9s\tremaining: 23.7s\n",
+      "100:\ttotal: 8.18s\tremaining: 32.3s\n",
+      "200:\ttotal: 16.6s\tremaining: 24.8s\n",
+      "200:\ttotal: 16s\tremaining: 23.8s\n",
+      "200:\ttotal: 16.5s\tremaining: 24.6s\n",
+      "300:\ttotal: 25.6s\tremaining: 16.9s\n",
+      "200:\ttotal: 15.7s\tremaining: 23.3s\n",
+      "200:\ttotal: 16.1s\tremaining: 24s\n",
+      "300:\ttotal: 24.6s\tremaining: 16.3s\n",
+      "200:\ttotal: 17s\tremaining: 25.3s\n",
+      "300:\ttotal: 25.2s\tremaining: 16.7s\n",
+      "300:\ttotal: 25s\tremaining: 16.5s\n",
+      "300:\ttotal: 25.5s\tremaining: 16.9s\n",
+      "400:\ttotal: 33.9s\tremaining: 8.37s\n",
+      "300:\ttotal: 24.2s\tremaining: 16s\n",
+      "300:\ttotal: 25s\tremaining: 16.6s\n",
+      "400:\ttotal: 34.8s\tremaining: 8.59s\n",
+      "300:\ttotal: 27.2s\tremaining: 18s\n",
+      "400:\ttotal: 35.3s\tremaining: 8.7s\n",
+      "400:\ttotal: 34.5s\tremaining: 8.52s\n",
+      "499:\ttotal: 43.2s\tremaining: 0us\n",
+      "400:\ttotal: 35.4s\tremaining: 8.74s\n",
+      "0:\ttotal: 116ms\tremaining: 57.7s\n",
+      "400:\ttotal: 34.1s\tremaining: 8.41s\n",
+      "400:\ttotal: 34.4s\tremaining: 8.5s\n",
+      "499:\ttotal: 43.1s\tremaining: 0us\n",
+      "0:\ttotal: 75.6ms\tremaining: 37.7s\n",
+      "400:\ttotal: 35.5s\tremaining: 8.77s\n",
+      "499:\ttotal: 43.2s\tremaining: 0us\n",
+      "0:\ttotal: 67.8ms\tremaining: 33.9s\n",
+      "499:\ttotal: 42.6s\tremaining: 0us\n",
+      "0:\ttotal: 83.3ms\tremaining: 41.6s\n",
+      "100:\ttotal: 7.82s\tremaining: 30.9s\n",
+      "499:\ttotal: 43.9s\tremaining: 0us\n",
+      "499:\ttotal: 42.1s\tremaining: 0us\n",
+      "499:\ttotal: 42.1s\tremaining: 0us\n",
+      "0:\ttotal: 68ms\tremaining: 33.9s\n",
+      "0:\ttotal: 80.6ms\tremaining: 40.2s\n",
+      "0:\ttotal: 101ms\tremaining: 50.5s\n",
+      "100:\ttotal: 7.67s\tremaining: 30.3s\n",
+      "499:\ttotal: 43.1s\tremaining: 0us\n",
+      "100:\ttotal: 7.42s\tremaining: 29.3s\n",
+      "0:\ttotal: 82.6ms\tremaining: 41.2s\n",
+      "100:\ttotal: 7.3s\tremaining: 28.9s\n",
+      "200:\ttotal: 15.5s\tremaining: 23.1s\n",
+      "100:\ttotal: 7.34s\tremaining: 29s\n",
+      "100:\ttotal: 7.32s\tremaining: 28.9s\n",
+      "100:\ttotal: 7.44s\tremaining: 29.4s\n",
+      "200:\ttotal: 15.5s\tremaining: 23.1s\n",
+      "100:\ttotal: 7.31s\tremaining: 28.9s\n",
+      "200:\ttotal: 15.4s\tremaining: 22.9s\n",
+      "200:\ttotal: 15.3s\tremaining: 22.7s\n",
+      "300:\ttotal: 24.4s\tremaining: 16.1s\n",
+      "200:\ttotal: 15.5s\tremaining: 23s\n",
+      "200:\ttotal: 15.4s\tremaining: 22.9s\n",
+      "200:\ttotal: 15.5s\tremaining: 23s\n",
+      "200:\ttotal: 15.3s\tremaining: 22.7s\n",
+      "300:\ttotal: 24s\tremaining: 15.9s\n",
+      "300:\ttotal: 23.8s\tremaining: 15.7s\n",
+      "300:\ttotal: 24.2s\tremaining: 16s\n",
+      "300:\ttotal: 23.5s\tremaining: 15.5s\n",
+      "400:\ttotal: 32.8s\tremaining: 8.09s\n",
+      "300:\ttotal: 23.2s\tremaining: 15.3s\n",
+      "300:\ttotal: 23.5s\tremaining: 15.6s\n",
+      "300:\ttotal: 23.2s\tremaining: 15.4s\n",
+      "400:\ttotal: 32.5s\tremaining: 8.04s\n",
+      "400:\ttotal: 31.7s\tremaining: 7.82s\n",
+      "400:\ttotal: 32.6s\tremaining: 8.05s\n",
+      "400:\ttotal: 31.2s\tremaining: 7.7s\n",
+      "400:\ttotal: 30.7s\tremaining: 7.58s\n",
+      "499:\ttotal: 40.7s\tremaining: 0us\n",
+      "400:\ttotal: 31.3s\tremaining: 7.74s\n",
+      "0:\ttotal: 71.1ms\tremaining: 35.5s\n",
+      "400:\ttotal: 31.6s\tremaining: 7.8s\n",
+      "499:\ttotal: 40.4s\tremaining: 0us\n",
+      "499:\ttotal: 40s\tremaining: 0us\n",
+      "0:\ttotal: 60.6ms\tremaining: 30.2s\n",
+      "0:\ttotal: 82.3ms\tremaining: 41.1s\n",
+      "499:\ttotal: 38.6s\tremaining: 0us\n",
+      "499:\ttotal: 40.3s\tremaining: 0us\n",
+      "499:\ttotal: 38.1s\tremaining: 0us\n",
+      "0:\ttotal: 56.2ms\tremaining: 28.1s\n",
+      "0:\ttotal: 62ms\tremaining: 30.9s\n",
+      "0:\ttotal: 105ms\tremaining: 52.4s\n",
+      "100:\ttotal: 7.24s\tremaining: 28.6s\n",
+      "499:\ttotal: 39s\tremaining: 0us\n",
+      "0:\ttotal: 88.2ms\tremaining: 44s\n",
+      "499:\ttotal: 39s\tremaining: 0us\n",
+      "0:\ttotal: 148ms\tremaining: 1m 13s\n",
+      "100:\ttotal: 8.18s\tremaining: 32.3s\n",
+      "100:\ttotal: 8.16s\tremaining: 32.2s\n",
+      "100:\ttotal: 8.3s\tremaining: 32.8s\n",
+      "100:\ttotal: 8.33s\tremaining: 32.9s\n",
+      "100:\ttotal: 8.52s\tremaining: 33.7s\n",
+      "200:\ttotal: 15.6s\tremaining: 23.2s\n",
+      "100:\ttotal: 8.73s\tremaining: 34.5s\n",
+      "100:\ttotal: 8.44s\tremaining: 33.3s\n",
+      "200:\ttotal: 15.8s\tremaining: 23.6s\n",
+      "200:\ttotal: 16.4s\tremaining: 24.5s\n",
+      "200:\ttotal: 16.2s\tremaining: 24s\n",
+      "200:\ttotal: 16.3s\tremaining: 24.2s\n",
+      "200:\ttotal: 16.6s\tremaining: 24.7s\n",
+      "300:\ttotal: 23.5s\tremaining: 15.5s\n",
+      "200:\ttotal: 17s\tremaining: 25.3s\n",
+      "200:\ttotal: 16.6s\tremaining: 24.7s\n",
+      "300:\ttotal: 24.4s\tremaining: 16.1s\n",
+      "300:\ttotal: 25.1s\tremaining: 16.6s\n",
+      "300:\ttotal: 24.3s\tremaining: 16.1s\n",
+      "300:\ttotal: 24.7s\tremaining: 16.3s\n",
+      "400:\ttotal: 31.5s\tremaining: 7.78s\n",
+      "300:\ttotal: 25.1s\tremaining: 16.6s\n",
+      "300:\ttotal: 25.3s\tremaining: 16.7s\n",
+      "300:\ttotal: 25.3s\tremaining: 16.7s\n",
+      "400:\ttotal: 33.1s\tremaining: 8.18s\n",
+      "400:\ttotal: 33.3s\tremaining: 8.21s\n",
+      "499:\ttotal: 39.5s\tremaining: 0us\n",
+      "400:\ttotal: 33s\tremaining: 8.15s\n",
+      "0:\ttotal: 75.8ms\tremaining: 37.8s\n",
+      "400:\ttotal: 33.7s\tremaining: 8.32s\n",
+      "400:\ttotal: 33.6s\tremaining: 8.29s\n",
+      "400:\ttotal: 34.3s\tremaining: 8.48s\n",
+      "400:\ttotal: 34.3s\tremaining: 8.46s\n",
+      "499:\ttotal: 41.8s\tremaining: 0us\n",
+      "0:\ttotal: 68.8ms\tremaining: 34.3s\n",
+      "499:\ttotal: 41.9s\tremaining: 0us\n",
+      "0:\ttotal: 63.9ms\tremaining: 31.9s\n",
+      "100:\ttotal: 7.94s\tremaining: 31.4s\n",
+      "499:\ttotal: 41.7s\tremaining: 0us\n",
+      "499:\ttotal: 42.4s\tremaining: 0us\n",
+      "0:\ttotal: 50.2ms\tremaining: 25.1s\n",
+      "499:\ttotal: 42.4s\tremaining: 0us\n",
+      "0:\ttotal: 66.9ms\tremaining: 33.4s\n",
+      "0:\ttotal: 77ms\tremaining: 38.4s\n",
+      "499:\ttotal: 42.5s\tremaining: 0us\n",
+      "0:\ttotal: 71.3ms\tremaining: 35.6s\n",
+      "499:\ttotal: 42.3s\tremaining: 0us\n",
+      "0:\ttotal: 61.9ms\tremaining: 30.9s\n",
+      "100:\ttotal: 7.69s\tremaining: 30.4s\n",
+      "100:\ttotal: 7.93s\tremaining: 31.3s\n",
+      "200:\ttotal: 16.4s\tremaining: 24.4s\n",
+      "100:\ttotal: 8.68s\tremaining: 34.3s\n",
+      "100:\ttotal: 8.54s\tremaining: 33.7s\n",
+      "100:\ttotal: 9.09s\tremaining: 35.9s\n",
+      "100:\ttotal: 9.16s\tremaining: 36.2s\n",
+      "100:\ttotal: 8.92s\tremaining: 35.2s\n",
+      "200:\ttotal: 17.2s\tremaining: 25.6s\n",
+      "200:\ttotal: 17.3s\tremaining: 25.8s\n",
+      "300:\ttotal: 25.2s\tremaining: 16.7s\n",
+      "200:\ttotal: 17.4s\tremaining: 25.9s\n",
+      "200:\ttotal: 17.3s\tremaining: 25.7s\n",
+      "200:\ttotal: 17.5s\tremaining: 26s\n",
+      "200:\ttotal: 17.3s\tremaining: 25.8s\n",
+      "200:\ttotal: 16.9s\tremaining: 25.2s\n",
+      "300:\ttotal: 25.7s\tremaining: 17s\n",
+      "300:\ttotal: 25.6s\tremaining: 16.9s\n",
+      "400:\ttotal: 33.7s\tremaining: 8.33s\n",
+      "300:\ttotal: 25.8s\tremaining: 17.1s\n",
+      "300:\ttotal: 25.8s\tremaining: 17s\n",
+      "300:\ttotal: 26.2s\tremaining: 17.3s\n",
+      "300:\ttotal: 26.1s\tremaining: 17.3s\n",
+      "300:\ttotal: 25.8s\tremaining: 17s\n",
+      "400:\ttotal: 34.1s\tremaining: 8.43s\n",
+      "400:\ttotal: 33.6s\tremaining: 8.3s\n",
+      "499:\ttotal: 41.6s\tremaining: 0us\n",
+      "0:\ttotal: 109ms\tremaining: 54.2s\n",
+      "400:\ttotal: 33.9s\tremaining: 8.38s\n",
+      "400:\ttotal: 34.1s\tremaining: 8.43s\n",
+      "400:\ttotal: 34.1s\tremaining: 8.41s\n",
+      "400:\ttotal: 34.4s\tremaining: 8.5s\n",
+      "400:\ttotal: 34.1s\tremaining: 8.41s\n",
+      "499:\ttotal: 41.9s\tremaining: 0us\n",
+      "499:\ttotal: 42.7s\tremaining: 0us\n",
+      "0:\ttotal: 128ms\tremaining: 1m 4s\n",
+      "0:\ttotal: 108ms\tremaining: 53.9s\n",
+      "499:\ttotal: 42.5s\tremaining: 0us\n",
+      "499:\ttotal: 42.5s\tremaining: 0us\n",
+      "499:\ttotal: 42.4s\tremaining: 0us\n",
+      "0:\ttotal: 103ms\tremaining: 51.2s\n",
+      "0:\ttotal: 110ms\tremaining: 55.1s\n",
+      "0:\ttotal: 179ms\tremaining: 1m 29s\n",
+      "100:\ttotal: 11.6s\tremaining: 45.7s\n",
+      "499:\ttotal: 43.5s\tremaining: 0us\n",
+      "0:\ttotal: 148ms\tremaining: 1m 13s\n",
+      "499:\ttotal: 43.2s\tremaining: 0us\n",
+      "0:\ttotal: 80.3ms\tremaining: 40.1s\n",
+      "100:\ttotal: 12.8s\tremaining: 50.6s\n",
+      "100:\ttotal: 13.3s\tremaining: 52.5s\n",
+      "100:\ttotal: 13.5s\tremaining: 53.4s\n",
+      "100:\ttotal: 14.3s\tremaining: 56.6s\n",
+      "100:\ttotal: 14.9s\tremaining: 58.8s\n",
+      "200:\ttotal: 26.4s\tremaining: 39.3s\n",
+      "100:\ttotal: 14.5s\tremaining: 57.4s\n",
+      "100:\ttotal: 14.7s\tremaining: 58.2s\n",
+      "200:\ttotal: 27.3s\tremaining: 40.7s\n",
+      "200:\ttotal: 27.5s\tremaining: 40.9s\n",
+      "200:\ttotal: 27.9s\tremaining: 41.5s\n",
+      "200:\ttotal: 28.4s\tremaining: 42.3s\n",
+      "200:\ttotal: 28.7s\tremaining: 42.7s\n",
+      "300:\ttotal: 41.2s\tremaining: 27.2s\n",
+      "200:\ttotal: 29s\tremaining: 43.1s\n",
+      "200:\ttotal: 28.7s\tremaining: 42.7s\n",
+      "300:\ttotal: 41.2s\tremaining: 27.2s\n",
+      "300:\ttotal: 41.1s\tremaining: 27.2s\n",
+      "300:\ttotal: 41.4s\tremaining: 27.4s\n",
+      "300:\ttotal: 42.2s\tremaining: 27.9s\n",
+      "300:\ttotal: 42.9s\tremaining: 28.4s\n",
+      "400:\ttotal: 55s\tremaining: 13.6s\n",
+      "300:\ttotal: 43.5s\tremaining: 28.8s\n",
+      "300:\ttotal: 43.6s\tremaining: 28.8s\n",
+      "400:\ttotal: 1m 2s\tremaining: 15.5s\n",
+      "400:\ttotal: 1m 3s\tremaining: 15.7s\n",
+      "400:\ttotal: 1m 5s\tremaining: 16.3s\n",
+      "400:\ttotal: 1m 6s\tremaining: 16.5s\n",
+      "400:\ttotal: 1m 10s\tremaining: 17.3s\n",
+      "499:\ttotal: 1m 21s\tremaining: 0us\n",
+      "0:\ttotal: 193ms\tremaining: 1m 36s\n",
+      "400:\ttotal: 1m 12s\tremaining: 17.9s\n",
+      "400:\ttotal: 1m 13s\tremaining: 18.1s\n",
+      "499:\ttotal: 1m 23s\tremaining: 0us\n",
+      "499:\ttotal: 1m 23s\tremaining: 0us\n",
+      "0:\ttotal: 185ms\tremaining: 1m 32s\n",
+      "0:\ttotal: 138ms\tremaining: 1m 9s\n",
+      "499:\ttotal: 1m 23s\tremaining: 0us\n",
+      "499:\ttotal: 1m 24s\tremaining: 0us\n",
+      "0:\ttotal: 134ms\tremaining: 1m 6s\n",
+      "0:\ttotal: 179ms\tremaining: 1m 29s\n",
+      "499:\ttotal: 1m 27s\tremaining: 0us\n",
+      "0:\ttotal: 329ms\tremaining: 2m 44s\n",
+      "100:\ttotal: 17.4s\tremaining: 1m 8s\n",
+      "499:\ttotal: 1m 30s\tremaining: 0us\n",
+      "0:\ttotal: 85.9ms\tremaining: 42.9s\n",
+      "499:\ttotal: 1m 33s\tremaining: 0us\n",
+      "100:\ttotal: 19.2s\tremaining: 1m 15s\n",
+      "0:\ttotal: 115ms\tremaining: 57.3s\n",
+      "100:\ttotal: 19.3s\tremaining: 1m 16s\n",
+      "100:\ttotal: 19.9s\tremaining: 1m 18s\n",
+      "100:\ttotal: 20.2s\tremaining: 1m 19s\n",
+      "100:\ttotal: 21.3s\tremaining: 1m 24s\n",
+      "200:\ttotal: 37.7s\tremaining: 56.1s\n",
+      "100:\ttotal: 18.3s\tremaining: 1m 12s\n",
+      "200:\ttotal: 35.3s\tremaining: 52.5s\n",
+      "100:\ttotal: 16.5s\tremaining: 1m 5s\n",
+      "200:\ttotal: 36.3s\tremaining: 54s\n",
+      "200:\ttotal: 35.6s\tremaining: 53s\n",
+      "200:\ttotal: 35.6s\tremaining: 53s\n",
+      "300:\ttotal: 51.9s\tremaining: 34.3s\n",
+      "200:\ttotal: 36.1s\tremaining: 53.8s\n",
+      "200:\ttotal: 32.4s\tremaining: 48.1s\n",
+      "300:\ttotal: 50s\tremaining: 33.1s\n",
+      "200:\ttotal: 31.2s\tremaining: 46.5s\n",
+      "300:\ttotal: 51.3s\tremaining: 33.9s\n",
+      "300:\ttotal: 49.7s\tremaining: 32.8s\n",
+      "300:\ttotal: 51.1s\tremaining: 33.8s\n",
+      "400:\ttotal: 1m 6s\tremaining: 16.3s\n",
+      "300:\ttotal: 50.7s\tremaining: 33.5s\n",
+      "300:\ttotal: 46.7s\tremaining: 30.9s\n",
+      "400:\ttotal: 1m 3s\tremaining: 15.7s\n",
+      "300:\ttotal: 44.7s\tremaining: 29.6s\n",
+      "400:\ttotal: 1m 5s\tremaining: 16.1s\n",
+      "400:\ttotal: 1m 3s\tremaining: 15.6s\n",
+      "400:\ttotal: 1m 5s\tremaining: 16.1s\n",
+      "499:\ttotal: 1m 19s\tremaining: 0us\n",
+      "400:\ttotal: 1m 4s\tremaining: 15.9s\n",
+      "0:\ttotal: 112ms\tremaining: 56s\n",
+      "400:\ttotal: 1m\tremaining: 14.9s\n",
+      "400:\ttotal: 58.2s\tremaining: 14.4s\n",
+      "499:\ttotal: 1m 17s\tremaining: 0us\n",
+      "0:\ttotal: 182ms\tremaining: 1m 30s\n",
+      "499:\ttotal: 1m 19s\tremaining: 0us\n",
+      "499:\ttotal: 1m 17s\tremaining: 0us\n",
+      "0:\ttotal: 137ms\tremaining: 1m 8s\n",
+      "0:\ttotal: 115ms\tremaining: 57.4s\n",
+      "499:\ttotal: 1m 19s\tremaining: 0us\n",
+      "0:\ttotal: 209ms\tremaining: 1m 44s\n",
+      "100:\ttotal: 15s\tremaining: 59.4s\n",
+      "499:\ttotal: 1m 20s\tremaining: 0us\n",
+      "0:\ttotal: 149ms\tremaining: 1m 14s\n",
+      "499:\ttotal: 1m 16s\tremaining: 0us\n",
+      "0:\ttotal: 119ms\tremaining: 59.2s\n",
+      "499:\ttotal: 1m 14s\tremaining: 0us\n",
+      "100:\ttotal: 15.1s\tremaining: 59.8s\n",
+      "0:\ttotal: 143ms\tremaining: 1m 11s\n",
+      "100:\ttotal: 15.4s\tremaining: 1m\n",
+      "100:\ttotal: 15.3s\tremaining: 1m\n",
+      "100:\ttotal: 12.5s\tremaining: 49.3s\n",
+      "100:\ttotal: 12.5s\tremaining: 49.3s\n",
+      "200:\ttotal: 29.8s\tremaining: 44.3s\n",
+      "100:\ttotal: 13s\tremaining: 51.4s\n",
+      "100:\ttotal: 12.6s\tremaining: 49.6s\n",
+      "200:\ttotal: 31.2s\tremaining: 46.4s\n",
+      "200:\ttotal: 30.8s\tremaining: 45.8s\n",
+      "200:\ttotal: 30.9s\tremaining: 46s\n",
+      "200:\ttotal: 27.8s\tremaining: 41.3s\n",
+      "200:\ttotal: 27.7s\tremaining: 41.1s\n",
+      "300:\ttotal: 46.3s\tremaining: 30.6s\n",
+      "200:\ttotal: 28.7s\tremaining: 42.8s\n",
+      "200:\ttotal: 27.5s\tremaining: 40.9s\n",
+      "300:\ttotal: 46.4s\tremaining: 30.7s\n",
+      "300:\ttotal: 41.8s\tremaining: 27.6s\n",
+      "300:\ttotal: 46.2s\tremaining: 30.6s\n",
+      "300:\ttotal: 46.4s\tremaining: 30.7s\n",
+      "300:\ttotal: 41.6s\tremaining: 27.5s\n",
+      "400:\ttotal: 1m\tremaining: 15s\n",
+      "300:\ttotal: 42.8s\tremaining: 28.3s\n",
+      "300:\ttotal: 41.8s\tremaining: 27.7s\n",
+      "400:\ttotal: 1m 1s\tremaining: 15.3s\n",
+      "400:\ttotal: 56.6s\tremaining: 14s\n",
+      "400:\ttotal: 1m 1s\tremaining: 15.3s\n",
+      "400:\ttotal: 1m 2s\tremaining: 15.4s\n",
+      "400:\ttotal: 56.9s\tremaining: 14s\n",
+      "499:\ttotal: 1m 17s\tremaining: 0us\n",
+      "400:\ttotal: 59.3s\tremaining: 14.6s\n",
+      "0:\ttotal: 103ms\tremaining: 51.2s\n",
+      "400:\ttotal: 59.1s\tremaining: 14.6s\n",
+      "499:\ttotal: 1m 21s\tremaining: 0us\n",
+      "499:\ttotal: 1m 15s\tremaining: 0us\n",
+      "0:\ttotal: 168ms\tremaining: 1m 23s\n",
+      "0:\ttotal: 124ms\tremaining: 1m 1s\n",
+      "499:\ttotal: 1m 21s\tremaining: 0us\n",
+      "499:\ttotal: 1m 22s\tremaining: 0us\n",
+      "0:\ttotal: 160ms\tremaining: 1m 19s\n",
+      "499:\ttotal: 1m 16s\tremaining: 0us\n",
+      "0:\ttotal: 138ms\tremaining: 1m 8s\n",
+      "0:\ttotal: 170ms\tremaining: 1m 24s\n",
+      "100:\ttotal: 16.2s\tremaining: 1m 3s\n",
+      "499:\ttotal: 1m 16s\tremaining: 0us\n",
+      "0:\ttotal: 117ms\tremaining: 58.2s\n",
+      "499:\ttotal: 1m 16s\tremaining: 0us\n",
+      "0:\ttotal: 100ms\tremaining: 50.1s\n",
+      "100:\ttotal: 15.6s\tremaining: 1m 1s\n",
+      "100:\ttotal: 15.7s\tremaining: 1m 2s\n",
+      "100:\ttotal: 15.2s\tremaining: 1m\n",
+      "100:\ttotal: 15s\tremaining: 59.2s\n",
+      "100:\ttotal: 15s\tremaining: 59.4s\n",
+      "200:\ttotal: 30.9s\tremaining: 46s\n",
+      "100:\ttotal: 14.8s\tremaining: 58.3s\n",
+      "100:\ttotal: 13.8s\tremaining: 54.5s\n",
+      "200:\ttotal: 29.5s\tremaining: 43.9s\n",
+      "200:\ttotal: 30.1s\tremaining: 44.7s\n",
+      "200:\ttotal: 28.6s\tremaining: 42.5s\n",
+      "200:\ttotal: 29.3s\tremaining: 43.5s\n",
+      "200:\ttotal: 29.6s\tremaining: 44.1s\n",
+      "300:\ttotal: 44.8s\tremaining: 29.6s\n",
+      "200:\ttotal: 29.9s\tremaining: 44.5s\n",
+      "200:\ttotal: 29s\tremaining: 43.1s\n",
+      "300:\ttotal: 44.2s\tremaining: 29.2s\n",
+      "300:\ttotal: 44.8s\tremaining: 29.6s\n",
+      "300:\ttotal: 44s\tremaining: 29.1s\n",
+      "300:\ttotal: 43.7s\tremaining: 28.9s\n",
+      "400:\ttotal: 58.2s\tremaining: 14.4s\n",
+      "300:\ttotal: 44.3s\tremaining: 29.3s\n",
+      "300:\ttotal: 45s\tremaining: 29.7s\n",
+      "300:\ttotal: 42.8s\tremaining: 28.3s\n",
+      "400:\ttotal: 58.8s\tremaining: 14.5s\n",
+      "400:\ttotal: 59.6s\tremaining: 14.7s\n",
+      "499:\ttotal: 1m 11s\tremaining: 0us\n",
+      "400:\ttotal: 58.4s\tremaining: 14.4s\n",
+      "400:\ttotal: 57.8s\tremaining: 14.3s\n",
+      "0:\ttotal: 112ms\tremaining: 55.7s\n",
+      "400:\ttotal: 58.6s\tremaining: 14.5s\n",
+      "400:\ttotal: 59.3s\tremaining: 14.6s\n",
+      "400:\ttotal: 57.9s\tremaining: 14.3s\n",
+      "499:\ttotal: 1m 13s\tremaining: 0us\n",
+      "0:\ttotal: 110ms\tremaining: 54.7s\n",
+      "499:\ttotal: 1m 14s\tremaining: 0us\n",
+      "0:\ttotal: 93.4ms\tremaining: 46.6s\n",
+      "100:\ttotal: 13.6s\tremaining: 53.7s\n",
+      "499:\ttotal: 1m 12s\tremaining: 0us\n",
+      "499:\ttotal: 1m 13s\tremaining: 0us\n",
+      "499:\ttotal: 1m 12s\tremaining: 0us\n",
+      "0:\ttotal: 185ms\tremaining: 1m 32s\n",
+      "0:\ttotal: 120ms\tremaining: 59.6s\n",
+      "0:\ttotal: 182ms\tremaining: 1m 30s\n",
+      "499:\ttotal: 1m 13s\tremaining: 0us\n",
+      "0:\ttotal: 82.2ms\tremaining: 41s\n",
+      "499:\ttotal: 1m 11s\tremaining: 0us\n",
+      "0:\ttotal: 107ms\tremaining: 53.3s\n",
+      "100:\ttotal: 13.4s\tremaining: 53.1s\n",
+      "100:\ttotal: 13.3s\tremaining: 52.6s\n",
+      "200:\ttotal: 28.7s\tremaining: 42.7s\n",
+      "100:\ttotal: 14.5s\tremaining: 57.2s\n",
+      "100:\ttotal: 14.8s\tremaining: 58.4s\n",
+      "100:\ttotal: 14.7s\tremaining: 58s\n",
+      "100:\ttotal: 14.4s\tremaining: 57s\n",
+      "100:\ttotal: 15.3s\tremaining: 1m\n",
+      "200:\ttotal: 29s\tremaining: 43.1s\n",
+      "200:\ttotal: 28.9s\tremaining: 43s\n",
+      "300:\ttotal: 44.3s\tremaining: 29.3s\n",
+      "200:\ttotal: 29.4s\tremaining: 43.7s\n",
+      "200:\ttotal: 29.8s\tremaining: 44.3s\n",
+      "200:\ttotal: 29.9s\tremaining: 44.4s\n",
+      "200:\ttotal: 29.4s\tremaining: 43.7s\n",
+      "200:\ttotal: 30.3s\tremaining: 45.1s\n",
+      "300:\ttotal: 43.5s\tremaining: 28.7s\n",
+      "300:\ttotal: 43.8s\tremaining: 29s\n",
+      "400:\ttotal: 59.1s\tremaining: 14.6s\n",
+      "300:\ttotal: 44.1s\tremaining: 29.1s\n",
+      "300:\ttotal: 44.4s\tremaining: 29.4s\n",
+      "300:\ttotal: 44.4s\tremaining: 29.4s\n",
+      "300:\ttotal: 44.4s\tremaining: 29.4s\n",
+      "300:\ttotal: 45.6s\tremaining: 30.1s\n",
+      "400:\ttotal: 59.6s\tremaining: 14.7s\n",
+      "400:\ttotal: 59.9s\tremaining: 14.8s\n",
+      "499:\ttotal: 1m 14s\tremaining: 0us\n",
+      "400:\ttotal: 59.9s\tremaining: 14.8s\n",
+      "0:\ttotal: 153ms\tremaining: 1m 16s\n",
+      "400:\ttotal: 60s\tremaining: 14.8s\n",
+      "400:\ttotal: 1m\tremaining: 14.9s\n",
+      "400:\ttotal: 59.8s\tremaining: 14.8s\n",
+      "400:\ttotal: 1m 1s\tremaining: 15.1s\n",
+      "499:\ttotal: 1m 18s\tremaining: 0us\n",
+      "0:\ttotal: 503ms\tremaining: 4m 10s\n",
+      "499:\ttotal: 1m 19s\tremaining: 0us\n",
+      "0:\ttotal: 262ms\tremaining: 2m 10s\n",
+      "100:\ttotal: 19s\tremaining: 1m 15s\n",
+      "499:\ttotal: 1m 22s\tremaining: 0us\n",
+      "499:\ttotal: 1m 22s\tremaining: 0us\n",
+      "499:\ttotal: 1m 23s\tremaining: 0us\n",
+      "0:\ttotal: 167ms\tremaining: 1m 23s\n",
+      "0:\ttotal: 102ms\tremaining: 50.8s\n",
+      "0:\ttotal: 163ms\tremaining: 1m 21s\n",
+      "499:\ttotal: 1m 23s\tremaining: 0us\n",
+      "0:\ttotal: 115ms\tremaining: 57.2s\n",
+      "499:\ttotal: 1m 23s\tremaining: 0us\n",
+      "0:\ttotal: 114ms\tremaining: 57s\n",
+      "100:\ttotal: 16.7s\tremaining: 1m 5s\n",
+      "100:\ttotal: 15.3s\tremaining: 1m\n",
+      "200:\ttotal: 35.2s\tremaining: 52.4s\n",
+      "100:\ttotal: 12.7s\tremaining: 50.4s\n",
+      "100:\ttotal: 13s\tremaining: 51.5s\n",
+      "100:\ttotal: 13.5s\tremaining: 53.4s\n",
+      "100:\ttotal: 13.5s\tremaining: 53.2s\n",
+      "100:\ttotal: 13.6s\tremaining: 53.6s\n",
+      "200:\ttotal: 30.6s\tremaining: 45.4s\n",
+      "200:\ttotal: 29.3s\tremaining: 43.6s\n",
+      "300:\ttotal: 48.6s\tremaining: 32.1s\n",
+      "200:\ttotal: 26.5s\tremaining: 39.5s\n",
+      "200:\ttotal: 27.1s\tremaining: 40.3s\n",
+      "200:\ttotal: 27.2s\tremaining: 40.5s\n",
+      "200:\ttotal: 28.4s\tremaining: 42.3s\n",
+      "200:\ttotal: 27.7s\tremaining: 41.2s\n",
+      "300:\ttotal: 45s\tremaining: 29.8s\n",
+      "300:\ttotal: 43.9s\tremaining: 29s\n",
+      "400:\ttotal: 1m 2s\tremaining: 15.5s\n",
+      "300:\ttotal: 41.2s\tremaining: 27.2s\n",
+      "300:\ttotal: 40.9s\tremaining: 27.1s\n",
+      "300:\ttotal: 42.3s\tremaining: 28s\n",
+      "300:\ttotal: 43s\tremaining: 28.4s\n",
+      "300:\ttotal: 42.5s\tremaining: 28.1s\n",
+      "400:\ttotal: 58.1s\tremaining: 14.3s\n",
+      "400:\ttotal: 57.4s\tremaining: 14.2s\n",
+      "499:\ttotal: 1m 16s\tremaining: 0us\n",
+      "0:\ttotal: 164ms\tremaining: 1m 22s\n",
+      "400:\ttotal: 54.4s\tremaining: 13.4s\n",
+      "400:\ttotal: 54.7s\tremaining: 13.5s\n",
+      "400:\ttotal: 57.5s\tremaining: 14.2s\n",
+      "400:\ttotal: 59.5s\tremaining: 14.7s\n",
+      "499:\ttotal: 1m 13s\tremaining: 0us\n",
+      "0:\ttotal: 97.3ms\tremaining: 48.6s\n",
+      "400:\ttotal: 59.8s\tremaining: 14.8s\n",
+      "499:\ttotal: 1m 14s\tremaining: 0us\n",
+      "0:\ttotal: 136ms\tremaining: 1m 7s\n",
+      "100:\ttotal: 16.9s\tremaining: 1m 6s\n",
+      "499:\ttotal: 1m 12s\tremaining: 0us\n",
+      "499:\ttotal: 1m 12s\tremaining: 0us\n",
+      "0:\ttotal: 171ms\tremaining: 1m 25s\n",
+      "0:\ttotal: 106ms\tremaining: 52.9s\n",
+      "499:\ttotal: 1m 16s\tremaining: 0us\n",
+      "0:\ttotal: 203ms\tremaining: 1m 41s\n",
+      "499:\ttotal: 1m 17s\tremaining: 0us\n",
+      "0:\ttotal: 110ms\tremaining: 54.9s\n",
+      "100:\ttotal: 16.5s\tremaining: 1m 5s\n",
+      "499:\ttotal: 1m 17s\tremaining: 0us\n",
+      "200:\ttotal: 32.8s\tremaining: 48.8s\n",
+      "0:\ttotal: 195ms\tremaining: 1m 37s\n",
+      "100:\ttotal: 16.6s\tremaining: 1m 5s\n",
+      "100:\ttotal: 16.8s\tremaining: 1m 6s\n",
+      "100:\ttotal: 17.8s\tremaining: 1m 10s\n",
+      "100:\ttotal: 16.4s\tremaining: 1m 4s\n",
+      "100:\ttotal: 15.6s\tremaining: 1m 1s\n",
+      "200:\ttotal: 33.2s\tremaining: 49.5s\n",
+      "100:\ttotal: 16.8s\tremaining: 1m 6s\n",
+      "200:\ttotal: 33.5s\tremaining: 49.8s\n",
+      "300:\ttotal: 50.2s\tremaining: 33.2s\n",
+      "200:\ttotal: 32.5s\tremaining: 48.3s\n",
+      "200:\ttotal: 33.7s\tremaining: 50.1s\n",
+      "200:\ttotal: 32.1s\tremaining: 47.7s\n",
+      "200:\ttotal: 31.3s\tremaining: 46.6s\n",
+      "300:\ttotal: 49.4s\tremaining: 32.6s\n",
+      "200:\ttotal: 32.9s\tremaining: 49s\n",
+      "300:\ttotal: 49.3s\tremaining: 32.6s\n",
+      "400:\ttotal: 1m 6s\tremaining: 16.4s\n",
+      "300:\ttotal: 48s\tremaining: 31.8s\n",
+      "300:\ttotal: 49s\tremaining: 32.4s\n",
+      "300:\ttotal: 47.2s\tremaining: 31.2s\n",
+      "300:\ttotal: 48s\tremaining: 31.7s\n",
+      "400:\ttotal: 1m 7s\tremaining: 16.7s\n",
+      "300:\ttotal: 50.8s\tremaining: 33.6s\n",
+      "499:\ttotal: 1m 23s\tremaining: 0us\n",
+      "400:\ttotal: 1m 7s\tremaining: 16.7s\n",
+      "0:\ttotal: 159ms\tremaining: 1m 19s\n",
+      "400:\ttotal: 1m 6s\tremaining: 16.4s\n",
+      "400:\ttotal: 1m 7s\tremaining: 16.7s\n",
+      "400:\ttotal: 1m 5s\tremaining: 16.3s\n",
+      "400:\ttotal: 1m 5s\tremaining: 16.3s\n",
+      "499:\ttotal: 1m 24s\tremaining: 0us\n",
+      "0:\ttotal: 99.3ms\tremaining: 49.5s\n",
+      "100:\ttotal: 15.9s\tremaining: 1m 2s\n",
+      "499:\ttotal: 1m 24s\tremaining: 0us\n",
+      "400:\ttotal: 1m 8s\tremaining: 16.9s\n",
+      "0:\ttotal: 176ms\tremaining: 1m 27s\n",
+      "499:\ttotal: 1m 22s\tremaining: 0us\n",
+      "0:\ttotal: 171ms\tremaining: 1m 25s\n",
+      "499:\ttotal: 1m 24s\tremaining: 0us\n",
+      "0:\ttotal: 182ms\tremaining: 1m 30s\n",
+      "499:\ttotal: 1m 22s\tremaining: 0us\n",
+      "0:\ttotal: 169ms\tremaining: 1m 24s\n",
+      "499:\ttotal: 1m 21s\tremaining: 0us\n",
+      "0:\ttotal: 144ms\tremaining: 1m 11s\n",
+      "100:\ttotal: 15.3s\tremaining: 1m\n",
+      "200:\ttotal: 31s\tremaining: 46.1s\n",
+      "499:\ttotal: 1m 23s\tremaining: 0us\n",
+      "100:\ttotal: 15s\tremaining: 59.4s\n",
+      "0:\ttotal: 192ms\tremaining: 1m 35s\n",
+      "100:\ttotal: 12.8s\tremaining: 50.7s\n",
+      "100:\ttotal: 15s\tremaining: 59.4s\n",
+      "100:\ttotal: 12.8s\tremaining: 50.7s\n",
+      "100:\ttotal: 13s\tremaining: 51.4s\n",
+      "200:\ttotal: 30.8s\tremaining: 45.8s\n",
+      "300:\ttotal: 46.5s\tremaining: 30.7s\n",
+      "100:\ttotal: 13.5s\tremaining: 53.5s\n",
+      "200:\ttotal: 30.6s\tremaining: 45.4s\n",
+      "200:\ttotal: 27.8s\tremaining: 41.3s\n",
+      "200:\ttotal: 30.3s\tremaining: 45.1s\n",
+      "200:\ttotal: 27.6s\tremaining: 41.1s\n",
+      "200:\ttotal: 27.6s\tremaining: 41.1s\n",
+      "300:\ttotal: 46.3s\tremaining: 30.6s\n",
+      "200:\ttotal: 28.4s\tremaining: 42.2s\n",
+      "300:\ttotal: 41.7s\tremaining: 27.5s\n",
+      "400:\ttotal: 1m 2s\tremaining: 15.4s\n",
+      "300:\ttotal: 45.6s\tremaining: 30.1s\n",
+      "300:\ttotal: 46.1s\tremaining: 30.5s\n",
+      "300:\ttotal: 41.6s\tremaining: 27.5s\n",
+      "300:\ttotal: 42.9s\tremaining: 28.3s\n",
+      "400:\ttotal: 1m 1s\tremaining: 15.3s\n",
+      "300:\ttotal: 43.9s\tremaining: 29s\n",
+      "400:\ttotal: 56.4s\tremaining: 13.9s\n",
+      "400:\ttotal: 1m\tremaining: 15s\n",
+      "499:\ttotal: 1m 18s\tremaining: 0us\n",
+      "0:\ttotal: 108ms\tremaining: 54.1s\n",
+      "400:\ttotal: 55.8s\tremaining: 13.8s\n",
+      "400:\ttotal: 1m 1s\tremaining: 15.3s\n",
+      "400:\ttotal: 56.9s\tremaining: 14.1s\n",
+      "499:\ttotal: 1m 16s\tremaining: 0us\n",
+      "400:\ttotal: 58.1s\tremaining: 14.3s\n",
+      "499:\ttotal: 1m 10s\tremaining: 0us\n",
+      "0:\ttotal: 117ms\tremaining: 58.4s\n",
+      "0:\ttotal: 148ms\tremaining: 1m 14s\n",
+      "499:\ttotal: 1m 15s\tremaining: 0us\n",
+      "100:\ttotal: 13.1s\tremaining: 51.6s\n",
+      "499:\ttotal: 1m 9s\tremaining: 0us\n",
+      "0:\ttotal: 114ms\tremaining: 56.8s\n",
+      "0:\ttotal: 90.9ms\tremaining: 45.4s\n",
+      "499:\ttotal: 1m 17s\tremaining: 0us\n",
+      "0:\ttotal: 113ms\tremaining: 56.6s\n",
+      "499:\ttotal: 1m 11s\tremaining: 0us\n",
+      "0:\ttotal: 131ms\tremaining: 1m 5s\n",
+      "499:\ttotal: 1m 12s\tremaining: 0us\n",
+      "0:\ttotal: 121ms\tremaining: 1m\n",
+      "100:\ttotal: 15.7s\tremaining: 1m 1s\n",
+      "100:\ttotal: 15.7s\tremaining: 1m 1s\n",
+      "200:\ttotal: 28.9s\tremaining: 43s\n",
+      "100:\ttotal: 16s\tremaining: 1m 3s\n",
+      "100:\ttotal: 16.1s\tremaining: 1m 3s\n",
+      "100:\ttotal: 17.5s\tremaining: 1m 9s\n",
+      "100:\ttotal: 18.3s\tremaining: 1m 12s\n",
+      "100:\ttotal: 20.2s\tremaining: 1m 19s\n",
+      "200:\ttotal: 35.7s\tremaining: 53.1s\n",
+      "200:\ttotal: 35.9s\tremaining: 53.5s\n",
+      "300:\ttotal: 50.7s\tremaining: 33.5s\n",
+      "200:\ttotal: 37.5s\tremaining: 55.8s\n",
+      "200:\ttotal: 37.8s\tremaining: 56.3s\n",
+      "200:\ttotal: 37.3s\tremaining: 55.5s\n",
+      "200:\ttotal: 38.1s\tremaining: 56.7s\n",
+      "200:\ttotal: 37.7s\tremaining: 56.1s\n",
+      "300:\ttotal: 53.7s\tremaining: 35.5s\n",
+      "300:\ttotal: 53.8s\tremaining: 35.6s\n",
+      "400:\ttotal: 1m 7s\tremaining: 16.6s\n",
+      "300:\ttotal: 54.4s\tremaining: 35.9s\n",
+      "300:\ttotal: 54.1s\tremaining: 35.7s\n",
+      "300:\ttotal: 52.9s\tremaining: 35s\n",
+      "300:\ttotal: 54.9s\tremaining: 36.3s\n",
+      "300:\ttotal: 55s\tremaining: 36.3s\n",
+      "499:\ttotal: 1m 23s\tremaining: 0us\n",
+      "400:\ttotal: 1m 11s\tremaining: 17.6s\n",
+      "400:\ttotal: 1m 11s\tremaining: 17.6s\n",
+      "0:\ttotal: 234ms\tremaining: 1m 57s\n",
+      "400:\ttotal: 1m 11s\tremaining: 17.7s\n",
+      "400:\ttotal: 1m 11s\tremaining: 17.8s\n",
+      "400:\ttotal: 1m 10s\tremaining: 17.4s\n",
+      "400:\ttotal: 1m 12s\tremaining: 18s\n",
+      "100:\ttotal: 15.6s\tremaining: 1m 1s\n",
+      "400:\ttotal: 1m 11s\tremaining: 17.7s\n",
+      "499:\ttotal: 1m 27s\tremaining: 0us\n",
+      "0:\ttotal: 210ms\tremaining: 1m 44s\n",
+      "499:\ttotal: 1m 28s\tremaining: 0us\n",
+      "0:\ttotal: 75.7ms\tremaining: 37.8s\n",
+      "499:\ttotal: 1m 28s\tremaining: 0us\n",
+      "499:\ttotal: 1m 28s\tremaining: 0us\n",
+      "0:\ttotal: 107ms\tremaining: 53.2s\n",
+      "499:\ttotal: 1m 26s\tremaining: 0us\n",
+      "0:\ttotal: 159ms\tremaining: 1m 19s\n",
+      "0:\ttotal: 174ms\tremaining: 1m 26s\n",
+      "499:\ttotal: 1m 28s\tremaining: 0us\n",
+      "0:\ttotal: 92.3ms\tremaining: 46s\n",
+      "200:\ttotal: 32.2s\tremaining: 47.9s\n",
+      "100:\ttotal: 15.5s\tremaining: 1m 1s\n",
+      "499:\ttotal: 1m 28s\tremaining: 0us\n",
+      "100:\ttotal: 14.9s\tremaining: 59s\n",
+      "0:\ttotal: 202ms\tremaining: 1m 41s\n",
+      "100:\ttotal: 16.4s\tremaining: 1m 4s\n",
+      "100:\ttotal: 16.6s\tremaining: 1m 5s\n",
+      "100:\ttotal: 17s\tremaining: 1m 7s\n",
+      "100:\ttotal: 17.3s\tremaining: 1m 8s\n",
+      "300:\ttotal: 49.3s\tremaining: 32.6s\n",
+      "200:\ttotal: 32.5s\tremaining: 48.4s\n",
+      "200:\ttotal: 32.6s\tremaining: 48.5s\n",
+      "100:\ttotal: 17s\tremaining: 1m 7s\n",
+      "200:\ttotal: 34.2s\tremaining: 50.9s\n",
+      "200:\ttotal: 33.9s\tremaining: 50.5s\n",
+      "200:\ttotal: 35.7s\tremaining: 53.1s\n",
+      "200:\ttotal: 36.3s\tremaining: 54s\n",
+      "400:\ttotal: 1m 8s\tremaining: 16.9s\n",
+      "300:\ttotal: 51.7s\tremaining: 34.2s\n",
+      "300:\ttotal: 51.5s\tremaining: 34s\n",
+      "200:\ttotal: 36.3s\tremaining: 53.9s\n",
+      "300:\ttotal: 53.4s\tremaining: 35.3s\n",
+      "300:\ttotal: 53.9s\tremaining: 35.6s\n",
+      "300:\ttotal: 54.2s\tremaining: 35.8s\n",
+      "300:\ttotal: 53.2s\tremaining: 35.2s\n",
+      "400:\ttotal: 1m 7s\tremaining: 16.6s\n",
+      "499:\ttotal: 1m 24s\tremaining: 0us\n",
+      "400:\ttotal: 1m 6s\tremaining: 16.4s\n",
+      "0:\ttotal: 71.4ms\tremaining: 35.7s\n",
+      "300:\ttotal: 51.5s\tremaining: 34s\n",
+      "400:\ttotal: 1m 8s\tremaining: 16.9s\n",
+      "400:\ttotal: 1m 9s\tremaining: 17.2s\n",
+      "400:\ttotal: 1m 8s\tremaining: 17s\n",
+      "100:\ttotal: 5.45s\tremaining: 21.5s\n",
+      "400:\ttotal: 1m 8s\tremaining: 16.8s\n",
+      "200:\ttotal: 10.6s\tremaining: 15.8s\n",
+      "499:\ttotal: 1m 21s\tremaining: 0us\n",
+      "499:\ttotal: 1m 20s\tremaining: 0us\n",
+      "400:\ttotal: 1m 5s\tremaining: 16.2s\n",
+      "0:\ttotal: 28.1ms\tremaining: 14s\n",
+      "0:\ttotal: 43.1ms\tremaining: 21.5s\n",
+      "300:\ttotal: 15.6s\tremaining: 10.3s\n",
+      "499:\ttotal: 1m 22s\tremaining: 0us\n",
+      "499:\ttotal: 1m 23s\tremaining: 0us\n",
+      "0:\ttotal: 45.9ms\tremaining: 22.9s\n",
+      "499:\ttotal: 1m 22s\tremaining: 0us\n",
+      "100:\ttotal: 4.59s\tremaining: 18.1s\n",
+      "100:\ttotal: 5.01s\tremaining: 19.8s\n",
+      "0:\ttotal: 55.4ms\tremaining: 27.6s\n",
+      "0:\ttotal: 98.4ms\tremaining: 49.1s\n",
+      "400:\ttotal: 20.3s\tremaining: 5.01s\n",
+      "100:\ttotal: 4s\tremaining: 15.8s\n",
+      "100:\ttotal: 4.3s\tremaining: 17s\n",
+      "499:\ttotal: 1m 21s\tremaining: 0us\n",
+      "200:\ttotal: 9.31s\tremaining: 13.8s\n",
+      "200:\ttotal: 10s\tremaining: 14.9s\n",
+      "0:\ttotal: 50.1ms\tremaining: 25s\n",
+      "100:\ttotal: 4.91s\tremaining: 19.4s\n",
+      "499:\ttotal: 24.9s\tremaining: 0us\n",
+      "0:\ttotal: 42.4ms\tremaining: 21.1s\n",
+      "499:\ttotal: 1m 19s\tremaining: 0us\n",
+      "200:\ttotal: 9.44s\tremaining: 14s\n",
+      "0:\ttotal: 27.5ms\tremaining: 13.7s\n",
+      "200:\ttotal: 9.52s\tremaining: 14.2s\n",
+      "300:\ttotal: 14.2s\tremaining: 9.41s\n",
+      "300:\ttotal: 14.8s\tremaining: 9.76s\n",
+      "100:\ttotal: 4.75s\tremaining: 18.8s\n",
+      "200:\ttotal: 9.87s\tremaining: 14.7s\n",
+      "100:\ttotal: 4.53s\tremaining: 17.9s\n",
+      "300:\ttotal: 14s\tremaining: 9.24s\n",
+      "100:\ttotal: 4.42s\tremaining: 17.5s\n",
+      "400:\ttotal: 18.7s\tremaining: 4.62s\n",
+      "400:\ttotal: 19.1s\tremaining: 4.72s\n",
+      "300:\ttotal: 14.1s\tremaining: 9.35s\n",
+      "200:\ttotal: 9.33s\tremaining: 13.9s\n",
+      "200:\ttotal: 9.05s\tremaining: 13.5s\n",
+      "300:\ttotal: 14.6s\tremaining: 9.65s\n",
+      "400:\ttotal: 17.8s\tremaining: 4.4s\n",
+      "499:\ttotal: 22.5s\tremaining: 0us\n",
+      "200:\ttotal: 8.62s\tremaining: 12.8s\n",
+      "0:\ttotal: 52.7ms\tremaining: 26.3s\n",
+      "499:\ttotal: 23.2s\tremaining: 0us\n",
+      "400:\ttotal: 18.3s\tremaining: 4.51s\n",
+      "0:\ttotal: 39.9ms\tremaining: 19.9s\n",
+      "300:\ttotal: 13.6s\tremaining: 9s\n",
+      "300:\ttotal: 13.1s\tremaining: 8.68s\n",
+      "400:\ttotal: 18.6s\tremaining: 4.6s\n",
+      "499:\ttotal: 21.8s\tremaining: 0us\n",
+      "0:\ttotal: 31.1ms\tremaining: 15.5s\n",
+      "499:\ttotal: 22.1s\tremaining: 0us\n",
+      "100:\ttotal: 4.13s\tremaining: 16.3s\n",
+      "300:\ttotal: 12.7s\tremaining: 8.42s\n",
+      "0:\ttotal: 34.5ms\tremaining: 17.2s\n",
+      "100:\ttotal: 4.07s\tremaining: 16.1s\n",
+      "400:\ttotal: 17.7s\tremaining: 4.36s\n",
+      "499:\ttotal: 22.7s\tremaining: 0us\n",
+      "400:\ttotal: 17.4s\tremaining: 4.3s\n",
+      "0:\ttotal: 28.7ms\tremaining: 14.3s\n",
+      "100:\ttotal: 3.76s\tremaining: 14.9s\n",
+      "200:\ttotal: 8.3s\tremaining: 12.3s\n",
+      "400:\ttotal: 17.1s\tremaining: 4.22s\n",
+      "100:\ttotal: 4.35s\tremaining: 17.2s\n",
+      "200:\ttotal: 8.42s\tremaining: 12.5s\n",
+      "499:\ttotal: 21.9s\tremaining: 0us\n",
+      "0:\ttotal: 43.2ms\tremaining: 21.6s\n",
+      "499:\ttotal: 21.5s\tremaining: 0us\n",
+      "100:\ttotal: 4.18s\tremaining: 16.5s\n",
+      "0:\ttotal: 30.4ms\tremaining: 15.1s\n",
+      "200:\ttotal: 7.9s\tremaining: 11.8s\n",
+      "300:\ttotal: 12.6s\tremaining: 8.32s\n",
+      "499:\ttotal: 21.2s\tremaining: 0us\n",
+      "300:\ttotal: 12.4s\tremaining: 8.21s\n",
+      "200:\ttotal: 8.53s\tremaining: 12.7s\n",
+      "0:\ttotal: 32.6ms\tremaining: 16.3s\n",
+      "100:\ttotal: 4.2s\tremaining: 16.6s\n",
+      "100:\ttotal: 4.12s\tremaining: 16.3s\n",
+      "200:\ttotal: 8.35s\tremaining: 12.4s\n",
+      "300:\ttotal: 12.1s\tremaining: 7.97s\n",
+      "400:\ttotal: 16.6s\tremaining: 4.09s\n",
+      "400:\ttotal: 16.6s\tremaining: 4.09s\n",
+      "100:\ttotal: 4.02s\tremaining: 15.9s\n",
+      "300:\ttotal: 12.9s\tremaining: 8.5s\n",
+      "200:\ttotal: 8.32s\tremaining: 12.4s\n",
+      "300:\ttotal: 12.4s\tremaining: 8.23s\n",
+      "200:\ttotal: 8.29s\tremaining: 12.3s\n",
+      "400:\ttotal: 16.2s\tremaining: 3.99s\n",
+      "499:\ttotal: 20.8s\tremaining: 0us\n",
+      "499:\ttotal: 20.6s\tremaining: 0us\n",
+      "200:\ttotal: 8.02s\tremaining: 11.9s\n",
+      "0:\ttotal: 30.2ms\tremaining: 15.1s\n",
+      "0:\ttotal: 40.7ms\tremaining: 20.3s\n",
+      "400:\ttotal: 17s\tremaining: 4.2s\n",
+      "300:\ttotal: 12.2s\tremaining: 8.07s\n",
+      "300:\ttotal: 12.2s\tremaining: 8.09s\n",
+      "400:\ttotal: 16.6s\tremaining: 4.09s\n",
+      "499:\ttotal: 20.5s\tremaining: 0us\n",
+      "0:\ttotal: 38.3ms\tremaining: 19.1s\n",
+      "300:\ttotal: 12.4s\tremaining: 8.17s\n",
+      "100:\ttotal: 4.74s\tremaining: 18.7s\n",
+      "100:\ttotal: 4.54s\tremaining: 17.9s\n",
+      "499:\ttotal: 21.6s\tremaining: 0us\n",
+      "400:\ttotal: 16.6s\tremaining: 4.11s\n",
+      "0:\ttotal: 32.2ms\tremaining: 16.1s\n",
+      "400:\ttotal: 16.8s\tremaining: 4.15s\n",
+      "499:\ttotal: 21s\tremaining: 0us\n",
+      "0:\ttotal: 29.7ms\tremaining: 14.8s\n",
+      "100:\ttotal: 4.07s\tremaining: 16.1s\n",
+      "400:\ttotal: 16.6s\tremaining: 4.1s\n",
+      "100:\ttotal: 3.68s\tremaining: 14.5s\n",
+      "499:\ttotal: 20.8s\tremaining: 0us\n",
+      "200:\ttotal: 8.87s\tremaining: 13.2s\n",
+      "200:\ttotal: 9.12s\tremaining: 13.6s\n",
+      "0:\ttotal: 43.7ms\tremaining: 21.8s\n",
+      "499:\ttotal: 20.9s\tremaining: 0us\n",
+      "100:\ttotal: 3.85s\tremaining: 15.2s\n",
+      "0:\ttotal: 36.1ms\tremaining: 18s\n",
+      "200:\ttotal: 8.18s\tremaining: 12.2s\n",
+      "499:\ttotal: 20.7s\tremaining: 0us\n",
+      "200:\ttotal: 7.51s\tremaining: 11.2s\n",
+      "100:\ttotal: 3.66s\tremaining: 14.5s\n",
+      "300:\ttotal: 12.9s\tremaining: 8.5s\n",
+      "0:\ttotal: 64.9ms\tremaining: 32.4s\n",
+      "300:\ttotal: 13.2s\tremaining: 8.7s\n",
+      "200:\ttotal: 7.65s\tremaining: 11.4s\n",
+      "100:\ttotal: 3.68s\tremaining: 14.5s\n",
+      "300:\ttotal: 12.3s\tremaining: 8.15s\n",
+      "300:\ttotal: 11.3s\tremaining: 7.46s\n",
+      "200:\ttotal: 7.8s\tremaining: 11.6s\n",
+      "400:\ttotal: 17.1s\tremaining: 4.23s\n",
+      "100:\ttotal: 4.12s\tremaining: 16.3s\n",
+      "300:\ttotal: 11.5s\tremaining: 7.61s\n",
+      "400:\ttotal: 17.3s\tremaining: 4.26s\n",
+      "200:\ttotal: 7.67s\tremaining: 11.4s\n",
+      "400:\ttotal: 16.7s\tremaining: 4.12s\n",
+      "400:\ttotal: 15.6s\tremaining: 3.85s\n",
+      "200:\ttotal: 8.34s\tremaining: 12.4s\n",
+      "300:\ttotal: 12.2s\tremaining: 8.04s\n",
+      "400:\ttotal: 15.9s\tremaining: 3.93s\n",
+      "499:\ttotal: 21.7s\tremaining: 0us\n",
+      "499:\ttotal: 21.6s\tremaining: 0us\n",
+      "0:\ttotal: 64ms\tremaining: 31.9s\n",
+      "300:\ttotal: 12.2s\tremaining: 8.07s\n",
+      "0:\ttotal: 25.9ms\tremaining: 12.9s\n",
+      "499:\ttotal: 20.9s\tremaining: 0us\n",
+      "0:\ttotal: 29.9ms\tremaining: 14.9s\n",
+      "499:\ttotal: 20s\tremaining: 0us\n",
+      "0:\ttotal: 29.4ms\tremaining: 14.7s\n",
+      "300:\ttotal: 12.8s\tremaining: 8.48s\n",
+      "400:\ttotal: 17s\tremaining: 4.2s\n",
+      "499:\ttotal: 20.6s\tremaining: 0us\n",
+      "0:\ttotal: 31.6ms\tremaining: 15.7s\n",
+      "100:\ttotal: 4.54s\tremaining: 17.9s\n",
+      "100:\ttotal: 4.77s\tremaining: 18.8s\n",
+      "400:\ttotal: 17.1s\tremaining: 4.21s\n",
+      "100:\ttotal: 4.24s\tremaining: 16.7s\n",
+      "100:\ttotal: 4.29s\tremaining: 16.9s\n",
+      "400:\ttotal: 17s\tremaining: 4.2s\n",
+      "499:\ttotal: 21.3s\tremaining: 0us\n",
+      "100:\ttotal: 4.13s\tremaining: 16.3s\n",
+      "200:\ttotal: 8.75s\tremaining: 13s\n",
+      "0:\ttotal: 24.6ms\tremaining: 12.3s\n",
+      "499:\ttotal: 21.2s\tremaining: 0us\n",
+      "200:\ttotal: 9.05s\tremaining: 13.5s\n",
+      "0:\ttotal: 33.8ms\tremaining: 16.9s\n",
+      "200:\ttotal: 8.86s\tremaining: 13.2s\n",
+      "200:\ttotal: 9.2s\tremaining: 13.7s\n",
+      "499:\ttotal: 21.9s\tremaining: 0us\n",
+      "0:\ttotal: 13.7ms\tremaining: 6.83s\n",
+      "100:\ttotal: 4.94s\tremaining: 19.5s\n",
+      "200:\ttotal: 9.32s\tremaining: 13.9s\n",
+      "300:\ttotal: 13.9s\tremaining: 9.2s\n",
+      "300:\ttotal: 14.4s\tremaining: 9.49s\n",
+      "100:\ttotal: 5.14s\tremaining: 20.3s\n",
+      "300:\ttotal: 13.5s\tremaining: 8.91s\n",
+      "300:\ttotal: 13.8s\tremaining: 9.1s\n",
+      "100:\ttotal: 4.07s\tremaining: 16.1s\n",
+      "200:\ttotal: 9.14s\tremaining: 13.6s\n",
+      "300:\ttotal: 13.5s\tremaining: 8.95s\n",
+      "400:\ttotal: 18.2s\tremaining: 4.48s\n",
+      "400:\ttotal: 18.7s\tremaining: 4.62s\n",
+      "200:\ttotal: 9.47s\tremaining: 14.1s\n",
+      "400:\ttotal: 17.6s\tremaining: 4.34s\n",
+      "200:\ttotal: 8.05s\tremaining: 12s\n",
+      "400:\ttotal: 17.9s\tremaining: 4.41s\n",
+      "400:\ttotal: 17.7s\tremaining: 4.37s\n",
+      "300:\ttotal: 13.4s\tremaining: 8.88s\n",
+      "499:\ttotal: 22.3s\tremaining: 0us\n",
+      "0:\ttotal: 53.8ms\tremaining: 26.9s\n",
+      "300:\ttotal: 13.5s\tremaining: 8.93s\n",
+      "499:\ttotal: 22.9s\tremaining: 0us\n",
+      "0:\ttotal: 37ms\tremaining: 18.5s\n",
+      "499:\ttotal: 21.7s\tremaining: 0us\n",
+      "0:\ttotal: 30.6ms\tremaining: 15.3s\n",
+      "300:\ttotal: 12s\tremaining: 7.94s\n",
+      "499:\ttotal: 21.9s\tremaining: 0us\n",
+      "0:\ttotal: 23.4ms\tremaining: 11.7s\n",
+      "499:\ttotal: 22s\tremaining: 0us\n",
+      "400:\ttotal: 17.8s\tremaining: 4.4s\n",
+      "0:\ttotal: 51.7ms\tremaining: 25.8s\n",
+      "400:\ttotal: 17.7s\tremaining: 4.37s\n",
+      "100:\ttotal: 4.29s\tremaining: 17s\n",
+      "100:\ttotal: 4.29s\tremaining: 16.9s\n",
+      "100:\ttotal: 4.4s\tremaining: 17.4s\n",
+      "400:\ttotal: 16.4s\tremaining: 4.04s\n",
+      "100:\ttotal: 4.09s\tremaining: 16.2s\n",
+      "100:\ttotal: 4.26s\tremaining: 16.8s\n",
+      "200:\ttotal: 8.41s\tremaining: 12.5s\n",
+      "499:\ttotal: 21.8s\tremaining: 0us\n",
+      "499:\ttotal: 22.3s\tremaining: 0us\n",
+      "0:\ttotal: 25.2ms\tremaining: 12.6s\n",
+      "200:\ttotal: 8.47s\tremaining: 12.6s\n",
+      "0:\ttotal: 41.7ms\tremaining: 20.8s\n",
+      "200:\ttotal: 8.67s\tremaining: 12.9s\n",
+      "499:\ttotal: 20.3s\tremaining: 0us\n",
+      "200:\ttotal: 8.2s\tremaining: 12.2s\n",
+      "0:\ttotal: 36.8ms\tremaining: 18.4s\n",
+      "300:\ttotal: 12.4s\tremaining: 8.21s\n",
+      "200:\ttotal: 8.31s\tremaining: 12.4s\n",
+      "100:\ttotal: 4.01s\tremaining: 15.9s\n",
+      "100:\ttotal: 3.98s\tremaining: 15.7s\n",
+      "300:\ttotal: 12.6s\tremaining: 8.34s\n",
+      "300:\ttotal: 12.9s\tremaining: 8.54s\n",
+      "100:\ttotal: 3.83s\tremaining: 15.1s\n",
+      "300:\ttotal: 12.1s\tremaining: 8.03s\n",
+      "400:\ttotal: 16.3s\tremaining: 4.03s\n",
+      "300:\ttotal: 12.5s\tremaining: 8.24s\n",
+      "200:\ttotal: 7.87s\tremaining: 11.7s\n",
+      "200:\ttotal: 8.16s\tremaining: 12.1s\n",
+      "400:\ttotal: 16.8s\tremaining: 4.15s\n",
+      "200:\ttotal: 8.21s\tremaining: 12.2s\n",
+      "400:\ttotal: 17.4s\tremaining: 4.3s\n",
+      "400:\ttotal: 16.7s\tremaining: 4.13s\n",
+      "499:\ttotal: 20.6s\tremaining: 0us\n",
+      "0:\ttotal: 38.7ms\tremaining: 19.3s\n",
+      "400:\ttotal: 16.9s\tremaining: 4.16s\n",
+      "300:\ttotal: 12.9s\tremaining: 8.5s\n",
+      "300:\ttotal: 13.2s\tremaining: 8.7s\n",
+      "499:\ttotal: 21.5s\tremaining: 0us\n",
+      "0:\ttotal: 43.1ms\tremaining: 21.5s\n",
+      "300:\ttotal: 12.4s\tremaining: 8.18s\n",
+      "499:\ttotal: 21.7s\tremaining: 0us\n",
+      "499:\ttotal: 20.9s\tremaining: 0us\n",
+      "0:\ttotal: 40.2ms\tremaining: 20s\n",
+      "0:\ttotal: 29.8ms\tremaining: 14.9s\n",
+      "100:\ttotal: 3.68s\tremaining: 14.5s\n",
+      "499:\ttotal: 21.3s\tremaining: 0us\n",
+      "400:\ttotal: 16.8s\tremaining: 4.14s\n",
+      "0:\ttotal: 26.5ms\tremaining: 13.2s\n",
+      "400:\ttotal: 17.2s\tremaining: 4.24s\n",
+      "100:\ttotal: 3.73s\tremaining: 14.7s\n",
+      "400:\ttotal: 16.4s\tremaining: 4.06s\n",
+      "100:\ttotal: 3.57s\tremaining: 14.1s\n",
+      "100:\ttotal: 3.77s\tremaining: 14.9s\n",
+      "200:\ttotal: 7.52s\tremaining: 11.2s\n",
+      "100:\ttotal: 3.98s\tremaining: 15.7s\n",
+      "200:\ttotal: 7.55s\tremaining: 11.2s\n",
+      "499:\ttotal: 21s\tremaining: 0us\n",
+      "499:\ttotal: 21.2s\tremaining: 0us\n",
+      "0:\ttotal: 67.1ms\tremaining: 33.5s\n",
+      "0:\ttotal: 31.3ms\tremaining: 15.6s\n",
+      "499:\ttotal: 20.3s\tremaining: 0us\n",
+      "200:\ttotal: 7.49s\tremaining: 11.1s\n",
+      "200:\ttotal: 7.59s\tremaining: 11.3s\n",
+      "0:\ttotal: 56.7ms\tremaining: 28.3s\n",
+      "300:\ttotal: 11.3s\tremaining: 7.5s\n",
+      "200:\ttotal: 7.8s\tremaining: 11.6s\n",
+      "300:\ttotal: 11.5s\tremaining: 7.6s\n",
+      "100:\ttotal: 3.91s\tremaining: 15.5s\n",
+      "100:\ttotal: 4.07s\tremaining: 16.1s\n",
+      "300:\ttotal: 11.3s\tremaining: 7.5s\n",
+      "100:\ttotal: 4.05s\tremaining: 16s\n",
+      "300:\ttotal: 11.8s\tremaining: 7.82s\n",
+      "400:\ttotal: 15.2s\tremaining: 3.75s\n",
+      "400:\ttotal: 15.7s\tremaining: 3.87s\n",
+      "300:\ttotal: 12.2s\tremaining: 8.05s\n",
+      "200:\ttotal: 8.11s\tremaining: 12.1s\n",
+      "200:\ttotal: 8.21s\tremaining: 12.2s\n",
+      "400:\ttotal: 15.4s\tremaining: 3.81s\n",
+      "200:\ttotal: 8.26s\tremaining: 12.3s\n",
+      "400:\ttotal: 16s\tremaining: 3.95s\n",
+      "499:\ttotal: 19.4s\tremaining: 0us\n",
+      "0:\ttotal: 30.5ms\tremaining: 15.2s\n",
+      "499:\ttotal: 19.4s\tremaining: 0us\n",
+      "0:\ttotal: 34.7ms\tremaining: 17.3s\n",
+      "400:\ttotal: 16.4s\tremaining: 4.06s\n",
+      "300:\ttotal: 12.1s\tremaining: 8.03s\n",
+      "300:\ttotal: 12.1s\tremaining: 8.02s\n",
+      "499:\ttotal: 19.6s\tremaining: 0us\n",
+      "0:\ttotal: 44.6ms\tremaining: 22.3s\n",
+      "499:\ttotal: 20.1s\tremaining: 0us\n",
+      "0:\ttotal: 31.6ms\tremaining: 15.8s\n",
+      "300:\ttotal: 12.6s\tremaining: 8.34s\n",
+      "100:\ttotal: 3.96s\tremaining: 15.6s\n",
+      "100:\ttotal: 4.08s\tremaining: 16.1s\n",
+      "499:\ttotal: 20.4s\tremaining: 0us\n",
+      "400:\ttotal: 16.2s\tremaining: 3.99s\n",
+      "0:\ttotal: 43.5ms\tremaining: 21.7s\n",
+      "400:\ttotal: 16.5s\tremaining: 4.07s\n",
+      "100:\ttotal: 4.71s\tremaining: 18.6s\n",
+      "100:\ttotal: 4.66s\tremaining: 18.4s\n",
+      "200:\ttotal: 8.58s\tremaining: 12.8s\n",
+      "400:\ttotal: 17.4s\tremaining: 4.31s\n",
+      "200:\ttotal: 9.04s\tremaining: 13.4s\n",
+      "100:\ttotal: 4.98s\tremaining: 19.7s\n",
+      "499:\ttotal: 21.2s\tremaining: 0us\n",
+      "499:\ttotal: 21.4s\tremaining: 0us\n",
+      "0:\ttotal: 30.6ms\tremaining: 15.3s\n",
+      "0:\ttotal: 34.4ms\tremaining: 17.2s\n",
+      "200:\ttotal: 9.03s\tremaining: 13.4s\n",
+      "200:\ttotal: 8.89s\tremaining: 13.2s\n",
+      "499:\ttotal: 21.7s\tremaining: 0us\n",
+      "300:\ttotal: 12.9s\tremaining: 8.54s\n",
+      "0:\ttotal: 29.4ms\tremaining: 14.7s\n",
+      "300:\ttotal: 13.3s\tremaining: 8.78s\n",
+      "100:\ttotal: 4.26s\tremaining: 16.9s\n",
+      "200:\ttotal: 9.58s\tremaining: 14.3s\n",
+      "100:\ttotal: 4.24s\tremaining: 16.8s\n",
+      "300:\ttotal: 12.6s\tremaining: 8.31s\n",
+      "300:\ttotal: 13.1s\tremaining: 8.68s\n",
+      "100:\ttotal: 3.83s\tremaining: 15.1s\n",
+      "400:\ttotal: 17.1s\tremaining: 4.23s\n",
+      "400:\ttotal: 17.6s\tremaining: 4.35s\n",
+      "200:\ttotal: 8.27s\tremaining: 12.3s\n",
+      "200:\ttotal: 8.25s\tremaining: 12.3s\n",
+      "300:\ttotal: 13.7s\tremaining: 9.07s\n",
+      "400:\ttotal: 17.1s\tremaining: 4.23s\n",
+      "400:\ttotal: 16.8s\tremaining: 4.14s\n",
+      "200:\ttotal: 7.84s\tremaining: 11.7s\n",
+      "499:\ttotal: 21.1s\tremaining: 0us\n",
+      "0:\ttotal: 34ms\tremaining: 17s\n",
+      "499:\ttotal: 22s\tremaining: 0us\n",
+      "300:\ttotal: 12.2s\tremaining: 8.06s\n",
+      "0:\ttotal: 34ms\tremaining: 17s\n",
+      "300:\ttotal: 12.5s\tremaining: 8.25s\n",
+      "400:\ttotal: 18s\tremaining: 4.44s\n",
+      "499:\ttotal: 21.2s\tremaining: 0us\n",
+      "499:\ttotal: 21s\tremaining: 0us\n",
+      "0:\ttotal: 28.1ms\tremaining: 14s\n",
+      "0:\ttotal: 27.4ms\tremaining: 13.7s\n",
+      "300:\ttotal: 11.9s\tremaining: 7.87s\n",
+      "100:\ttotal: 4.11s\tremaining: 16.2s\n",
+      "100:\ttotal: 4.09s\tremaining: 16.2s\n",
+      "400:\ttotal: 16.7s\tremaining: 4.11s\n",
+      "499:\ttotal: 22s\tremaining: 0us\n",
+      "400:\ttotal: 16.7s\tremaining: 4.13s\n",
+      "100:\ttotal: 3.56s\tremaining: 14.1s\n",
+      "0:\ttotal: 48.3ms\tremaining: 24.1s\n",
+      "100:\ttotal: 4.03s\tremaining: 15.9s\n",
+      "400:\ttotal: 16.1s\tremaining: 3.96s\n",
+      "200:\ttotal: 8.3s\tremaining: 12.3s\n",
+      "200:\ttotal: 7.99s\tremaining: 11.9s\n",
+      "499:\ttotal: 20.7s\tremaining: 0us\n",
+      "499:\ttotal: 20.7s\tremaining: 0us\n",
+      "0:\ttotal: 32.5ms\tremaining: 16.2s\n",
+      "100:\ttotal: 3.67s\tremaining: 14.5s\n",
+      "0:\ttotal: 30.5ms\tremaining: 15.2s\n",
+      "200:\ttotal: 7.63s\tremaining: 11.3s\n",
+      "499:\ttotal: 19.8s\tremaining: 0us\n",
+      "200:\ttotal: 8.28s\tremaining: 12.3s\n",
+      "0:\ttotal: 46.4ms\tremaining: 23.1s\n",
+      "300:\ttotal: 12.5s\tremaining: 8.23s\n",
+      "300:\ttotal: 11.9s\tremaining: 7.86s\n",
+      "100:\ttotal: 3.95s\tremaining: 15.6s\n",
+      "300:\ttotal: 11.5s\tremaining: 7.58s\n",
+      "100:\ttotal: 3.91s\tremaining: 15.4s\n",
+      "200:\ttotal: 7.96s\tremaining: 11.8s\n",
+      "300:\ttotal: 12.3s\tremaining: 8.12s\n",
+      "100:\ttotal: 4.32s\tremaining: 17.1s\n",
+      "400:\ttotal: 16.8s\tremaining: 4.14s\n",
+      "200:\ttotal: 8.22s\tremaining: 12.2s\n",
+      "400:\ttotal: 16.6s\tremaining: 4.11s\n",
+      "300:\ttotal: 12.5s\tremaining: 8.25s\n",
+      "200:\ttotal: 8.73s\tremaining: 13s\n",
+      "400:\ttotal: 16.3s\tremaining: 4.03s\n",
+      "400:\ttotal: 17s\tremaining: 4.2s\n",
+      "200:\ttotal: 8.65s\tremaining: 12.9s\n",
+      "499:\ttotal: 21.3s\tremaining: 0us\n",
+      "0:\ttotal: 31.8ms\tremaining: 15.9s\n",
+      "300:\ttotal: 12.4s\tremaining: 8.18s\n",
+      "499:\ttotal: 21s\tremaining: 0us\n",
+      "400:\ttotal: 16.5s\tremaining: 4.06s\n",
+      "0:\ttotal: 39ms\tremaining: 19.4s\n",
+      "499:\ttotal: 20.2s\tremaining: 0us\n",
+      "0:\ttotal: 34.9ms\tremaining: 17.4s\n",
+      "300:\ttotal: 13.1s\tremaining: 8.63s\n",
+      "499:\ttotal: 21.2s\tremaining: 0us\n",
+      "300:\ttotal: 12.6s\tremaining: 8.34s\n",
+      "0:\ttotal: 41ms\tremaining: 20.5s\n",
+      "100:\ttotal: 4.19s\tremaining: 16.5s\n",
+      "400:\ttotal: 16.6s\tremaining: 4.1s\n",
+      "499:\ttotal: 20.5s\tremaining: 0us\n",
+      "0:\ttotal: 47.4ms\tremaining: 23.6s\n",
+      "100:\ttotal: 4.21s\tremaining: 16.6s\n",
+      "100:\ttotal: 4.1s\tremaining: 16.2s\n",
+      "400:\ttotal: 17.1s\tremaining: 4.22s\n",
+      "400:\ttotal: 16.8s\tremaining: 4.15s\n",
+      "100:\ttotal: 4.46s\tremaining: 17.6s\n",
+      "200:\ttotal: 8.42s\tremaining: 12.5s\n",
+      "499:\ttotal: 20.6s\tremaining: 0us\n",
+      "0:\ttotal: 43.6ms\tremaining: 21.8s\n",
+      "100:\ttotal: 4.03s\tremaining: 15.9s\n",
+      "200:\ttotal: 8.21s\tremaining: 12.2s\n",
+      "200:\ttotal: 8s\tremaining: 11.9s\n",
+      "499:\ttotal: 21.1s\tremaining: 0us\n",
+      "0:\ttotal: 44ms\tremaining: 22s\n",
+      "499:\ttotal: 20.9s\tremaining: 0us\n",
+      "0:\ttotal: 42.8ms\tremaining: 21.4s\n",
+      "200:\ttotal: 8.51s\tremaining: 12.7s\n",
+      "300:\ttotal: 12.7s\tremaining: 8.42s\n",
+      "100:\ttotal: 4.12s\tremaining: 16.3s\n",
+      "200:\ttotal: 8.01s\tremaining: 11.9s\n",
+      "300:\ttotal: 12.1s\tremaining: 8.03s\n",
+      "300:\ttotal: 12.5s\tremaining: 8.23s\n",
+      "100:\ttotal: 4.12s\tremaining: 16.3s\n",
+      "100:\ttotal: 4.26s\tremaining: 16.8s\n",
+      "300:\ttotal: 12.8s\tremaining: 8.49s\n",
+      "400:\ttotal: 17.1s\tremaining: 4.21s\n",
+      "200:\ttotal: 8.18s\tremaining: 12.2s\n",
+      "300:\ttotal: 12.3s\tremaining: 8.11s\n",
+      "400:\ttotal: 16.5s\tremaining: 4.06s\n",
+      "400:\ttotal: 16.4s\tremaining: 4.04s\n",
+      "200:\ttotal: 8.29s\tremaining: 12.3s\n",
+      "200:\ttotal: 8.34s\tremaining: 12.4s\n",
+      "400:\ttotal: 17.2s\tremaining: 4.26s\n",
+      "499:\ttotal: 21.2s\tremaining: 0us\n",
+      "0:\ttotal: 23.3ms\tremaining: 11.6s\n",
+      "400:\ttotal: 16.2s\tremaining: 4s\n",
+      "300:\ttotal: 12.5s\tremaining: 8.24s\n",
+      "499:\ttotal: 20.4s\tremaining: 0us\n",
+      "499:\ttotal: 20.2s\tremaining: 0us\n",
+      "0:\ttotal: 49ms\tremaining: 24.5s\n",
+      "0:\ttotal: 63.2ms\tremaining: 31.5s\n",
+      "300:\ttotal: 12.4s\tremaining: 8.18s\n",
+      "300:\ttotal: 12.3s\tremaining: 8.13s\n",
+      "499:\ttotal: 21.9s\tremaining: 0us\n",
+      "0:\ttotal: 45.2ms\tremaining: 22.6s\n",
+      "100:\ttotal: 4.32s\tremaining: 17.1s\n",
+      "499:\ttotal: 20.4s\tremaining: 0us\n",
+      "0:\ttotal: 37ms\tremaining: 18.5s\n",
+      "400:\ttotal: 17s\tremaining: 4.18s\n",
+      "100:\ttotal: 4.5s\tremaining: 17.8s\n",
+      "100:\ttotal: 4.58s\tremaining: 18.1s\n",
+      "400:\ttotal: 16.8s\tremaining: 4.15s\n",
+      "400:\ttotal: 16.7s\tremaining: 4.12s\n",
+      "100:\ttotal: 4.18s\tremaining: 16.5s\n",
+      "200:\ttotal: 8.62s\tremaining: 12.8s\n",
+      "499:\ttotal: 21.1s\tremaining: 0us\n",
+      "100:\ttotal: 4.39s\tremaining: 17.4s\n",
+      "200:\ttotal: 8.72s\tremaining: 13s\n",
+      "0:\ttotal: 32ms\tremaining: 16s\n",
+      "200:\ttotal: 8.88s\tremaining: 13.2s\n",
+      "499:\ttotal: 21.2s\tremaining: 0us\n",
+      "499:\ttotal: 21s\tremaining: 0us\n",
+      "0:\ttotal: 35.7ms\tremaining: 17.8s\n",
+      "0:\ttotal: 45.3ms\tremaining: 22.6s\n",
+      "200:\ttotal: 8.47s\tremaining: 12.6s\n",
+      "300:\ttotal: 13s\tremaining: 8.61s\n",
+      "200:\ttotal: 8.6s\tremaining: 12.8s\n",
+      "300:\ttotal: 12.9s\tremaining: 8.55s\n",
+      "100:\ttotal: 4.25s\tremaining: 16.8s\n",
+      "300:\ttotal: 13.3s\tremaining: 8.81s\n",
+      "100:\ttotal: 4.17s\tremaining: 16.5s\n",
+      "100:\ttotal: 4.96s\tremaining: 19.6s\n",
+      "300:\ttotal: 12.7s\tremaining: 8.4s\n",
+      "400:\ttotal: 17s\tremaining: 4.19s\n",
+      "300:\ttotal: 12.9s\tremaining: 8.53s\n",
+      "400:\ttotal: 17.1s\tremaining: 4.22s\n",
+      "200:\ttotal: 8.48s\tremaining: 12.6s\n",
+      "200:\ttotal: 8.31s\tremaining: 12.4s\n",
+      "400:\ttotal: 17.9s\tremaining: 4.41s\n",
+      "400:\ttotal: 17s\tremaining: 4.19s\n",
+      "499:\ttotal: 21.1s\tremaining: 0us\n",
+      "0:\ttotal: 59.5ms\tremaining: 29.7s\n",
+      "200:\ttotal: 10.3s\tremaining: 15.3s\n",
+      "499:\ttotal: 21.3s\tremaining: 0us\n",
+      "400:\ttotal: 17.3s\tremaining: 4.28s\n",
+      "300:\ttotal: 12.6s\tremaining: 8.34s\n",
+      "0:\ttotal: 70.6ms\tremaining: 35.2s\n",
+      "300:\ttotal: 12.5s\tremaining: 8.28s\n",
+      "499:\ttotal: 22.1s\tremaining: 0us\n",
+      "0:\ttotal: 58.2ms\tremaining: 29s\n",
+      "499:\ttotal: 21.2s\tremaining: 0us\n",
+      "0:\ttotal: 55.8ms\tremaining: 27.8s\n",
+      "100:\ttotal: 4.89s\tremaining: 19.3s\n",
+      "300:\ttotal: 15.6s\tremaining: 10.3s\n",
+      "400:\ttotal: 17s\tremaining: 4.2s\n",
+      "499:\ttotal: 21.7s\tremaining: 0us\n",
+      "0:\ttotal: 41.4ms\tremaining: 20.7s\n",
+      "400:\ttotal: 16.7s\tremaining: 4.12s\n",
+      "100:\ttotal: 5.33s\tremaining: 21s\n",
+      "100:\ttotal: 4.97s\tremaining: 19.7s\n",
+      "100:\ttotal: 5.41s\tremaining: 21.4s\n",
+      "200:\ttotal: 9.8s\tremaining: 14.6s\n",
+      "499:\ttotal: 21.1s\tremaining: 0us\n",
+      "0:\ttotal: 61.8ms\tremaining: 30.8s\n",
+      "400:\ttotal: 20.7s\tremaining: 5.12s\n",
+      "499:\ttotal: 21s\tremaining: 0us\n",
+      "0:\ttotal: 60.4ms\tremaining: 30.2s\n",
+      "100:\ttotal: 5.44s\tremaining: 21.5s\n",
+      "200:\ttotal: 11.1s\tremaining: 16.6s\n",
+      "200:\ttotal: 10.9s\tremaining: 16.2s\n",
+      "200:\ttotal: 11.7s\tremaining: 17.4s\n",
+      "300:\ttotal: 16s\tremaining: 10.6s\n",
+      "100:\ttotal: 6.04s\tremaining: 23.9s\n",
+      "499:\ttotal: 27s\tremaining: 0us\n",
+      "0:\ttotal: 54.1ms\tremaining: 27s\n",
+      "100:\ttotal: 6.42s\tremaining: 25.4s\n",
+      "200:\ttotal: 11.5s\tremaining: 17.2s\n",
+      "300:\ttotal: 16.6s\tremaining: 10.9s\n",
+      "300:\ttotal: 16.3s\tremaining: 10.8s\n",
+      "400:\ttotal: 21.3s\tremaining: 5.26s\n",
+      "300:\ttotal: 17.2s\tremaining: 11.3s\n",
+      "200:\ttotal: 11.5s\tremaining: 17.1s\n",
+      "100:\ttotal: 5.66s\tremaining: 22.4s\n",
+      "200:\ttotal: 11.9s\tremaining: 17.7s\n",
+      "300:\ttotal: 17.2s\tremaining: 11.4s\n",
+      "400:\ttotal: 21.9s\tremaining: 5.41s\n",
+      "400:\ttotal: 21.7s\tremaining: 5.37s\n",
+      "499:\ttotal: 26.6s\tremaining: 0us\n",
+      "0:\ttotal: 48.3ms\tremaining: 24.1s\n",
+      "400:\ttotal: 22.7s\tremaining: 5.61s\n",
+      "300:\ttotal: 17.2s\tremaining: 11.4s\n",
+      "200:\ttotal: 11.2s\tremaining: 16.6s\n",
+      "300:\ttotal: 17.7s\tremaining: 11.7s\n",
+      "400:\ttotal: 23s\tremaining: 5.67s\n",
+      "499:\ttotal: 27.5s\tremaining: 0us\n",
+      "0:\ttotal: 49.4ms\tremaining: 24.7s\n",
+      "499:\ttotal: 27.3s\tremaining: 0us\n",
+      "0:\ttotal: 69.6ms\tremaining: 34.7s\n",
+      "499:\ttotal: 28.6s\tremaining: 0us\n",
+      "100:\ttotal: 6.11s\tremaining: 24.1s\n",
+      "0:\ttotal: 36.1ms\tremaining: 18s\n",
+      "400:\ttotal: 23.5s\tremaining: 5.81s\n",
+      "300:\ttotal: 17.3s\tremaining: 11.5s\n",
+      "499:\ttotal: 29.1s\tremaining: 0us\n",
+      "400:\ttotal: 24s\tremaining: 5.92s\n",
+      "100:\ttotal: 5.89s\tremaining: 23.3s\n",
+      "100:\ttotal: 5.29s\tremaining: 20.9s\n",
+      "0:\ttotal: 46.7ms\tremaining: 23.3s\n",
+      "100:\ttotal: 5.34s\tremaining: 21.1s\n",
+      "200:\ttotal: 11.6s\tremaining: 17.3s\n",
+      "499:\ttotal: 28.9s\tremaining: 0us\n",
+      "0:\ttotal: 71.1ms\tremaining: 35.5s\n",
+      "400:\ttotal: 22.8s\tremaining: 5.63s\n",
+      "499:\ttotal: 29.6s\tremaining: 0us\n",
+      "200:\ttotal: 11.8s\tremaining: 17.5s\n",
+      "100:\ttotal: 5.56s\tremaining: 22s\n",
+      "0:\ttotal: 102ms\tremaining: 51.1s\n",
+      "200:\ttotal: 11.2s\tremaining: 16.7s\n",
+      "200:\ttotal: 11.1s\tremaining: 16.6s\n",
+      "300:\ttotal: 17.6s\tremaining: 11.6s\n",
+      "100:\ttotal: 5.85s\tremaining: 23.1s\n",
+      "499:\ttotal: 28.8s\tremaining: 0us\n",
+      "0:\ttotal: 56.6ms\tremaining: 28.3s\n",
+      "100:\ttotal: 5.87s\tremaining: 23.2s\n",
+      "300:\ttotal: 18s\tremaining: 11.9s\n",
+      "200:\ttotal: 11.7s\tremaining: 17.3s\n",
+      "300:\ttotal: 17.2s\tremaining: 11.4s\n",
+      "300:\ttotal: 17s\tremaining: 11.3s\n",
+      "400:\ttotal: 23.3s\tremaining: 5.76s\n",
+      "200:\ttotal: 11.3s\tremaining: 16.8s\n",
+      "100:\ttotal: 5.85s\tremaining: 23.1s\n",
+      "200:\ttotal: 11.6s\tremaining: 17.2s\n",
+      "400:\ttotal: 23.8s\tremaining: 5.88s\n",
+      "300:\ttotal: 17.6s\tremaining: 11.6s\n",
+      "400:\ttotal: 23.1s\tremaining: 5.71s\n",
+      "499:\ttotal: 29.2s\tremaining: 0us\n",
+      "0:\ttotal: 118ms\tremaining: 58.8s\n",
+      "400:\ttotal: 23.5s\tremaining: 5.81s\n",
+      "300:\ttotal: 17.6s\tremaining: 11.6s\n",
+      "200:\ttotal: 12s\tremaining: 17.8s\n",
+      "300:\ttotal: 17.6s\tremaining: 11.6s\n",
+      "499:\ttotal: 30s\tremaining: 0us\n",
+      "400:\ttotal: 23.8s\tremaining: 5.88s\n",
+      "499:\ttotal: 29.2s\tremaining: 0us\n",
+      "0:\ttotal: 38.2ms\tremaining: 19s\n",
+      "0:\ttotal: 67.9ms\tremaining: 33.9s\n",
+      "499:\ttotal: 29.8s\tremaining: 0us\n",
+      "100:\ttotal: 6.69s\tremaining: 26.4s\n",
+      "400:\ttotal: 23.8s\tremaining: 5.87s\n",
+      "0:\ttotal: 54ms\tremaining: 26.9s\n",
+      "300:\ttotal: 18.4s\tremaining: 12.1s\n",
+      "400:\ttotal: 23.9s\tremaining: 5.9s\n",
+      "100:\ttotal: 5.95s\tremaining: 23.5s\n",
+      "499:\ttotal: 30.1s\tremaining: 0us\n",
+      "100:\ttotal: 5.96s\tremaining: 23.6s\n",
+      "0:\ttotal: 65ms\tremaining: 32.5s\n",
+      "100:\ttotal: 5.41s\tremaining: 21.4s\n",
+      "200:\ttotal: 12.9s\tremaining: 19.2s\n",
+      "499:\ttotal: 29.9s\tremaining: 0us\n",
+      "0:\ttotal: 78.8ms\tremaining: 39.3s\n",
+      "400:\ttotal: 24.4s\tremaining: 6.02s\n",
+      "499:\ttotal: 30.3s\tremaining: 0us\n",
+      "100:\ttotal: 5.7s\tremaining: 22.5s\n",
+      "0:\ttotal: 58.6ms\tremaining: 29.2s\n",
+      "200:\ttotal: 12.6s\tremaining: 18.7s\n",
+      "200:\ttotal: 12.8s\tremaining: 19s\n",
+      "200:\ttotal: 11.6s\tremaining: 17.2s\n",
+      "300:\ttotal: 19.3s\tremaining: 12.7s\n",
+      "100:\ttotal: 5.87s\tremaining: 23.2s\n",
+      "499:\ttotal: 30.7s\tremaining: 0us\n",
+      "200:\ttotal: 11.1s\tremaining: 16.5s\n",
+      "0:\ttotal: 60.4ms\tremaining: 30.2s\n",
+      "100:\ttotal: 5.62s\tremaining: 22.2s\n",
+      "300:\ttotal: 18.6s\tremaining: 12.3s\n",
+      "300:\ttotal: 18.6s\tremaining: 12.3s\n",
+      "300:\ttotal: 17.2s\tremaining: 11.3s\n",
+      "200:\ttotal: 11s\tremaining: 16.4s\n",
+      "400:\ttotal: 25.2s\tremaining: 6.22s\n",
+      "100:\ttotal: 5.01s\tremaining: 19.8s\n",
+      "300:\ttotal: 16.4s\tremaining: 10.8s\n",
+      "200:\ttotal: 10.7s\tremaining: 15.9s\n",
+      "400:\ttotal: 24.2s\tremaining: 5.97s\n",
+      "400:\ttotal: 24.5s\tremaining: 6.05s\n",
+      "400:\ttotal: 22.7s\tremaining: 5.6s\n",
+      "300:\ttotal: 16.4s\tremaining: 10.9s\n",
+      "499:\ttotal: 30.7s\tremaining: 0us\n",
+      "0:\ttotal: 50.4ms\tremaining: 25.1s\n",
+      "200:\ttotal: 10.3s\tremaining: 15.3s\n",
+      "400:\ttotal: 21.9s\tremaining: 5.4s\n",
+      "300:\ttotal: 16.4s\tremaining: 10.8s\n",
+      "499:\ttotal: 29.6s\tremaining: 0us\n",
+      "499:\ttotal: 30s\tremaining: 0us\n",
+      "0:\ttotal: 57.1ms\tremaining: 28.5s\n",
+      "0:\ttotal: 50.2ms\tremaining: 25s\n",
+      "499:\ttotal: 27.9s\tremaining: 0us\n",
+      "0:\ttotal: 42.5ms\tremaining: 21.2s\n",
+      "400:\ttotal: 22s\tremaining: 5.42s\n",
+      "100:\ttotal: 5.42s\tremaining: 21.4s\n",
+      "300:\ttotal: 15.5s\tremaining: 10.3s\n",
+      "499:\ttotal: 27.1s\tremaining: 0us\n",
+      "0:\ttotal: 43.1ms\tremaining: 21.5s\n",
+      "400:\ttotal: 22.2s\tremaining: 5.49s\n",
+      "100:\ttotal: 5.49s\tremaining: 21.7s\n",
+      "100:\ttotal: 5.46s\tremaining: 21.6s\n",
+      "100:\ttotal: 5.46s\tremaining: 21.6s\n",
+      "499:\ttotal: 27.3s\tremaining: 0us\n",
+      "0:\ttotal: 45.8ms\tremaining: 22.8s\n",
+      "200:\ttotal: 10.8s\tremaining: 16.1s\n",
+      "400:\ttotal: 21s\tremaining: 5.18s\n",
+      "100:\ttotal: 5.65s\tremaining: 22.3s\n",
+      "499:\ttotal: 27.6s\tremaining: 0us\n",
+      "0:\ttotal: 44.2ms\tremaining: 22.1s\n",
+      "200:\ttotal: 10.5s\tremaining: 15.7s\n",
+      "200:\ttotal: 11s\tremaining: 16.4s\n",
+      "200:\ttotal: 11.5s\tremaining: 17.1s\n",
+      "100:\ttotal: 5.76s\tremaining: 22.8s\n",
+      "499:\ttotal: 26.6s\tremaining: 0us\n",
+      "0:\ttotal: 59.2ms\tremaining: 29.5s\n",
+      "300:\ttotal: 17.3s\tremaining: 11.4s\n",
+      "200:\ttotal: 11.5s\tremaining: 17.1s\n",
+      "100:\ttotal: 5.96s\tremaining: 23.5s\n",
+      "300:\ttotal: 16.5s\tremaining: 10.9s\n",
+      "300:\ttotal: 17s\tremaining: 11.2s\n",
+      "300:\ttotal: 17.1s\tremaining: 11.3s\n",
+      "200:\ttotal: 11.5s\tremaining: 17s\n",
+      "100:\ttotal: 5.29s\tremaining: 20.9s\n",
+      "400:\ttotal: 22.7s\tremaining: 5.61s\n",
+      "300:\ttotal: 17.3s\tremaining: 11.4s\n",
+      "200:\ttotal: 11.5s\tremaining: 17.1s\n",
+      "400:\ttotal: 22.1s\tremaining: 5.46s\n",
+      "400:\ttotal: 22.6s\tremaining: 5.58s\n",
+      "300:\ttotal: 17s\tremaining: 11.2s\n",
+      "400:\ttotal: 22.9s\tremaining: 5.66s\n",
+      "200:\ttotal: 11s\tremaining: 16.4s\n",
+      "499:\ttotal: 28.3s\tremaining: 0us\n",
+      "0:\ttotal: 47.4ms\tremaining: 23.7s\n",
+      "400:\ttotal: 22.8s\tremaining: 5.63s\n",
+      "300:\ttotal: 17.2s\tremaining: 11.4s\n",
+      "499:\ttotal: 27.9s\tremaining: 0us\n",
+      "0:\ttotal: 61.7ms\tremaining: 30.8s\n",
+      "499:\ttotal: 28.8s\tremaining: 0us\n",
+      "0:\ttotal: 44.1ms\tremaining: 22s\n",
+      "400:\ttotal: 23s\tremaining: 5.67s\n",
+      "499:\ttotal: 28.8s\tremaining: 0us\n",
+      "0:\ttotal: 38.1ms\tremaining: 19s\n",
+      "300:\ttotal: 16.9s\tremaining: 11.2s\n",
+      "100:\ttotal: 5.78s\tremaining: 22.8s\n",
+      "499:\ttotal: 28.4s\tremaining: 0us\n",
+      "0:\ttotal: 57.3ms\tremaining: 28.6s\n",
+      "400:\ttotal: 22.9s\tremaining: 5.65s\n",
+      "100:\ttotal: 5.52s\tremaining: 21.8s\n",
+      "100:\ttotal: 6.02s\tremaining: 23.8s\n",
+      "499:\ttotal: 28.8s\tremaining: 0us\n",
+      "100:\ttotal: 5.66s\tremaining: 22.4s\n",
+      "0:\ttotal: 44.1ms\tremaining: 22s\n",
+      "400:\ttotal: 22.6s\tremaining: 5.58s\n",
+      "200:\ttotal: 11.4s\tremaining: 16.9s\n",
+      "100:\ttotal: 5.77s\tremaining: 22.8s\n",
+      "499:\ttotal: 28.5s\tremaining: 0us\n",
+      "0:\ttotal: 47.9ms\tremaining: 23.9s\n",
+      "200:\ttotal: 11.2s\tremaining: 16.6s\n",
+      "200:\ttotal: 11.7s\tremaining: 17.4s\n",
+      "200:\ttotal: 12s\tremaining: 17.8s\n",
+      "100:\ttotal: 5.99s\tremaining: 23.7s\n",
+      "499:\ttotal: 28.7s\tremaining: 0us\n",
+      "0:\ttotal: 49.6ms\tremaining: 24.8s\n",
+      "300:\ttotal: 17.6s\tremaining: 11.7s\n",
+      "200:\ttotal: 12.2s\tremaining: 18.2s\n",
+      "100:\ttotal: 5.99s\tremaining: 23.7s\n",
+      "300:\ttotal: 17.5s\tremaining: 11.6s\n",
+      "300:\ttotal: 18.1s\tremaining: 12s\n",
+      "200:\ttotal: 11.3s\tremaining: 16.9s\n",
+      "300:\ttotal: 17.5s\tremaining: 11.6s\n",
+      "100:\ttotal: 5.12s\tremaining: 20.2s\n",
+      "400:\ttotal: 23.2s\tremaining: 5.73s\n",
+      "300:\ttotal: 17.8s\tremaining: 11.7s\n",
+      "200:\ttotal: 11.6s\tremaining: 17.3s\n",
+      "400:\ttotal: 23.2s\tremaining: 5.72s\n",
+      "400:\ttotal: 23.5s\tremaining: 5.8s\n",
+      "400:\ttotal: 23s\tremaining: 5.69s\n",
+      "300:\ttotal: 17s\tremaining: 11.2s\n",
+      "200:\ttotal: 10.4s\tremaining: 15.5s\n",
+      "499:\ttotal: 28.8s\tremaining: 0us\n",
+      "0:\ttotal: 69.6ms\tremaining: 34.7s\n",
+      "400:\ttotal: 23.3s\tremaining: 5.76s\n",
+      "300:\ttotal: 17.3s\tremaining: 11.4s\n",
+      "499:\ttotal: 28.5s\tremaining: 0us\n",
+      "0:\ttotal: 59.5ms\tremaining: 29.7s\n",
+      "499:\ttotal: 29s\tremaining: 0us\n",
+      "0:\ttotal: 39.8ms\tremaining: 19.9s\n",
+      "499:\ttotal: 28.6s\tremaining: 0us\n",
+      "400:\ttotal: 22.6s\tremaining: 5.57s\n",
+      "300:\ttotal: 15.9s\tremaining: 10.5s\n",
+      "0:\ttotal: 63.2ms\tremaining: 31.5s\n",
+      "100:\ttotal: 5.14s\tremaining: 20.3s\n",
+      "499:\ttotal: 29s\tremaining: 0us\n",
+      "0:\ttotal: 49.4ms\tremaining: 24.7s\n",
+      "400:\ttotal: 23.1s\tremaining: 5.7s\n",
+      "100:\ttotal: 5.29s\tremaining: 20.9s\n",
+      "100:\ttotal: 4.81s\tremaining: 19s\n",
+      "400:\ttotal: 21.3s\tremaining: 5.25s\n",
+      "499:\ttotal: 28.3s\tremaining: 0us\n",
+      "100:\ttotal: 5.18s\tremaining: 20.5s\n",
+      "0:\ttotal: 44.5ms\tremaining: 22.2s\n",
+      "200:\ttotal: 10.4s\tremaining: 15.5s\n",
+      "100:\ttotal: 5.3s\tremaining: 20.9s\n",
+      "499:\ttotal: 28.9s\tremaining: 0us\n",
+      "200:\ttotal: 10.5s\tremaining: 15.7s\n",
+      "0:\ttotal: 74.7ms\tremaining: 37.3s\n",
+      "200:\ttotal: 9.83s\tremaining: 14.6s\n",
+      "499:\ttotal: 26.6s\tremaining: 0us\n",
+      "200:\ttotal: 10.3s\tremaining: 15.4s\n",
+      "0:\ttotal: 60.5ms\tremaining: 30.2s\n",
+      "100:\ttotal: 5.89s\tremaining: 23.3s\n",
+      "300:\ttotal: 16.8s\tremaining: 11.1s\n",
+      "200:\ttotal: 11.4s\tremaining: 16.9s\n",
+      "300:\ttotal: 17.1s\tremaining: 11.3s\n",
+      "100:\ttotal: 6.59s\tremaining: 26.1s\n",
+      "300:\ttotal: 16.6s\tremaining: 11s\n",
+      "300:\ttotal: 17.3s\tremaining: 11.4s\n",
+      "100:\ttotal: 7.16s\tremaining: 28.3s\n",
+      "200:\ttotal: 12.6s\tremaining: 18.7s\n",
+      "400:\ttotal: 23.1s\tremaining: 5.7s\n",
+      "300:\ttotal: 17.6s\tremaining: 11.6s\n",
+      "400:\ttotal: 23.2s\tremaining: 5.73s\n",
+      "200:\ttotal: 12.5s\tremaining: 18.6s\n",
+      "400:\ttotal: 22.4s\tremaining: 5.53s\n",
+      "400:\ttotal: 22.9s\tremaining: 5.65s\n",
+      "200:\ttotal: 12.7s\tremaining: 18.9s\n",
+      "300:\ttotal: 18.3s\tremaining: 12.1s\n",
+      "499:\ttotal: 28.3s\tremaining: 0us\n",
+      "0:\ttotal: 60.5ms\tremaining: 30.2s\n",
+      "400:\ttotal: 23.2s\tremaining: 5.72s\n",
+      "499:\ttotal: 28.5s\tremaining: 0us\n",
+      "0:\ttotal: 43.4ms\tremaining: 21.6s\n",
+      "499:\ttotal: 28.1s\tremaining: 0us\n",
+      "300:\ttotal: 18.4s\tremaining: 12.2s\n",
+      "0:\ttotal: 66ms\tremaining: 32.9s\n",
+      "499:\ttotal: 28.6s\tremaining: 0us\n",
+      "0:\ttotal: 70.9ms\tremaining: 35.4s\n",
+      "300:\ttotal: 19s\tremaining: 12.5s\n",
+      "400:\ttotal: 23.9s\tremaining: 5.9s\n",
+      "100:\ttotal: 5.95s\tremaining: 23.5s\n",
+      "499:\ttotal: 28.9s\tremaining: 0us\n",
+      "0:\ttotal: 64.5ms\tremaining: 32.2s\n",
+      "100:\ttotal: 5.91s\tremaining: 23.4s\n",
+      "400:\ttotal: 24.5s\tremaining: 6.04s\n",
+      "100:\ttotal: 5.82s\tremaining: 23s\n",
+      "100:\ttotal: 5.82s\tremaining: 23s\n",
+      "400:\ttotal: 24.8s\tremaining: 6.13s\n",
+      "499:\ttotal: 29.8s\tremaining: 0us\n",
+      "0:\ttotal: 48.8ms\tremaining: 24.4s\n",
+      "200:\ttotal: 11.7s\tremaining: 17.3s\n",
+      "100:\ttotal: 5.54s\tremaining: 21.9s\n",
+      "200:\ttotal: 11.6s\tremaining: 17.3s\n",
+      "200:\ttotal: 11.8s\tremaining: 17.5s\n",
+      "499:\ttotal: 30.5s\tremaining: 0us\n",
+      "0:\ttotal: 48.2ms\tremaining: 24s\n",
+      "200:\ttotal: 11.8s\tremaining: 17.6s\n",
+      "499:\ttotal: 30.7s\tremaining: 0us\n",
+      "0:\ttotal: 59.7ms\tremaining: 29.8s\n",
+      "300:\ttotal: 17.8s\tremaining: 11.7s\n",
+      "100:\ttotal: 6.23s\tremaining: 24.6s\n",
+      "200:\ttotal: 11.9s\tremaining: 17.7s\n",
+      "300:\ttotal: 18s\tremaining: 11.9s\n",
+      "300:\ttotal: 17.6s\tremaining: 11.6s\n",
+      "100:\ttotal: 5.89s\tremaining: 23.3s\n",
+      "300:\ttotal: 17.9s\tremaining: 11.8s\n",
+      "400:\ttotal: 23.1s\tremaining: 5.7s\n",
+      "100:\ttotal: 5.47s\tremaining: 21.6s\n",
+      "200:\ttotal: 11.6s\tremaining: 17.3s\n",
+      "300:\ttotal: 17.3s\tremaining: 11.5s\n",
+      "400:\ttotal: 23.4s\tremaining: 5.78s\n",
+      "400:\ttotal: 23.1s\tremaining: 5.7s\n",
+      "200:\ttotal: 11.4s\tremaining: 16.9s\n",
+      "400:\ttotal: 23.5s\tremaining: 5.79s\n",
+      "200:\ttotal: 10.8s\tremaining: 16s\n",
+      "499:\ttotal: 28.6s\tremaining: 0us\n",
+      "300:\ttotal: 17.1s\tremaining: 11.3s\n",
+      "0:\ttotal: 36ms\tremaining: 18s\n",
+      "400:\ttotal: 23s\tremaining: 5.67s\n",
+      "499:\ttotal: 28.9s\tremaining: 0us\n",
+      "0:\ttotal: 56.5ms\tremaining: 28.2s\n",
+      "499:\ttotal: 28.8s\tremaining: 0us\n",
+      "0:\ttotal: 53.1ms\tremaining: 26.5s\n",
+      "300:\ttotal: 17.2s\tremaining: 11.4s\n",
+      "499:\ttotal: 29s\tremaining: 0us\n",
+      "300:\ttotal: 16.1s\tremaining: 10.7s\n",
+      "400:\ttotal: 22.5s\tremaining: 5.56s\n",
+      "0:\ttotal: 68.4ms\tremaining: 34.1s\n",
+      "100:\ttotal: 5.53s\tremaining: 21.8s\n",
+      "499:\ttotal: 28.7s\tremaining: 0us\n",
+      "0:\ttotal: 51.8ms\tremaining: 25.9s\n",
+      "100:\ttotal: 5.47s\tremaining: 21.6s\n",
+      "100:\ttotal: 5.35s\tremaining: 21.1s\n",
+      "400:\ttotal: 22.8s\tremaining: 5.63s\n",
+      "100:\ttotal: 5.27s\tremaining: 20.8s\n",
+      "400:\ttotal: 21.8s\tremaining: 5.38s\n",
+      "499:\ttotal: 28.3s\tremaining: 0us\n",
+      "200:\ttotal: 11.1s\tremaining: 16.4s\n",
+      "0:\ttotal: 99.4ms\tremaining: 49.6s\n",
+      "100:\ttotal: 5.41s\tremaining: 21.4s\n",
+      "200:\ttotal: 11s\tremaining: 16.3s\n",
+      "200:\ttotal: 10.9s\tremaining: 16.3s\n",
+      "499:\ttotal: 28.7s\tremaining: 0us\n",
+      "200:\ttotal: 10.6s\tremaining: 15.7s\n",
+      "0:\ttotal: 61.5ms\tremaining: 30.7s\n",
+      "499:\ttotal: 27.4s\tremaining: 0us\n",
+      "300:\ttotal: 16.5s\tremaining: 10.9s\n",
+      "0:\ttotal: 43.3ms\tremaining: 21.6s\n",
+      "100:\ttotal: 5.25s\tremaining: 20.8s\n",
+      "200:\ttotal: 10.8s\tremaining: 16.1s\n",
+      "300:\ttotal: 16.7s\tremaining: 11.1s\n",
+      "300:\ttotal: 16.6s\tremaining: 11s\n",
+      "300:\ttotal: 16.3s\tremaining: 10.8s\n",
+      "100:\ttotal: 5.59s\tremaining: 22.1s\n",
+      "100:\ttotal: 5.18s\tremaining: 20.5s\n",
+      "400:\ttotal: 22.2s\tremaining: 5.48s\n",
+      "200:\ttotal: 11s\tremaining: 16.4s\n",
+      "300:\ttotal: 16.7s\tremaining: 11s\n",
+      "400:\ttotal: 22.3s\tremaining: 5.51s\n",
+      "400:\ttotal: 22.2s\tremaining: 5.47s\n",
+      "200:\ttotal: 10.8s\tremaining: 16s\n",
+      "400:\ttotal: 21.7s\tremaining: 5.37s\n",
+      "200:\ttotal: 10.8s\tremaining: 16s\n",
+      "499:\ttotal: 27.6s\tremaining: 0us\n",
+      "300:\ttotal: 16.3s\tremaining: 10.8s\n",
+      "0:\ttotal: 32.9ms\tremaining: 16.4s\n",
+      "400:\ttotal: 22s\tremaining: 5.44s\n",
+      "499:\ttotal: 28s\tremaining: 0us\n",
+      "499:\ttotal: 27.6s\tremaining: 0us\n",
+      "300:\ttotal: 15.8s\tremaining: 10.5s\n",
+      "0:\ttotal: 31.1ms\tremaining: 15.5s\n",
+      "0:\ttotal: 45ms\tremaining: 22.4s\n",
+      "499:\ttotal: 27s\tremaining: 0us\n",
+      "0:\ttotal: 45.6ms\tremaining: 22.8s\n",
+      "300:\ttotal: 16.1s\tremaining: 10.6s\n",
+      "400:\ttotal: 21.7s\tremaining: 5.35s\n",
+      "100:\ttotal: 5.15s\tremaining: 20.3s\n",
+      "499:\ttotal: 27.3s\tremaining: 0us\n",
+      "0:\ttotal: 53.3ms\tremaining: 26.6s\n",
+      "100:\ttotal: 5.48s\tremaining: 21.7s\n",
+      "100:\ttotal: 5.51s\tremaining: 21.8s\n",
+      "400:\ttotal: 21.5s\tremaining: 5.3s\n",
+      "100:\ttotal: 5.59s\tremaining: 22.1s\n",
+      "400:\ttotal: 22s\tremaining: 5.43s\n",
+      "200:\ttotal: 10.8s\tremaining: 16s\n",
+      "499:\ttotal: 27.5s\tremaining: 0us\n",
+      "0:\ttotal: 47.6ms\tremaining: 23.7s\n",
+      "100:\ttotal: 6.08s\tremaining: 24s\n",
+      "200:\ttotal: 11.1s\tremaining: 16.6s\n",
+      "200:\ttotal: 11.3s\tremaining: 16.8s\n",
+      "499:\ttotal: 27.5s\tremaining: 0us\n",
+      "0:\ttotal: 58.5ms\tremaining: 29.2s\n",
+      "200:\ttotal: 11.2s\tremaining: 16.7s\n",
+      "499:\ttotal: 27.8s\tremaining: 0us\n",
+      "0:\ttotal: 37.8ms\tremaining: 18.9s\n",
+      "300:\ttotal: 16.9s\tremaining: 11.2s\n",
+      "100:\ttotal: 5.85s\tremaining: 23.1s\n",
+      "200:\ttotal: 11.6s\tremaining: 17.3s\n",
+      "300:\ttotal: 17s\tremaining: 11.2s\n",
+      "300:\ttotal: 17.3s\tremaining: 11.4s\n",
+      "100:\ttotal: 5.61s\tremaining: 22.2s\n",
+      "300:\ttotal: 17.2s\tremaining: 11.4s\n",
+      "100:\ttotal: 5.75s\tremaining: 22.7s\n",
+      "200:\ttotal: 11.8s\tremaining: 17.6s\n",
+      "400:\ttotal: 23.4s\tremaining: 5.77s\n",
+      "300:\ttotal: 17.6s\tremaining: 11.6s\n",
+      "400:\ttotal: 22.6s\tremaining: 5.59s\n",
+      "400:\ttotal: 22.5s\tremaining: 5.56s\n",
+      "200:\ttotal: 10.9s\tremaining: 16.3s\n",
+      "400:\ttotal: 22.7s\tremaining: 5.6s\n",
+      "200:\ttotal: 11.4s\tremaining: 17s\n",
+      "300:\ttotal: 17.3s\tremaining: 11.5s\n",
+      "499:\ttotal: 28.9s\tremaining: 0us\n",
+      "0:\ttotal: 41.7ms\tremaining: 20.8s\n",
+      "400:\ttotal: 23.1s\tremaining: 5.71s\n",
+      "499:\ttotal: 28.1s\tremaining: 0us\n",
+      "499:\ttotal: 28.1s\tremaining: 0us\n",
+      "300:\ttotal: 16.5s\tremaining: 10.9s\n",
+      "0:\ttotal: 46.1ms\tremaining: 23s\n",
+      "0:\ttotal: 48.8ms\tremaining: 24.3s\n",
+      "499:\ttotal: 28.2s\tremaining: 0us\n",
+      "0:\ttotal: 51.8ms\tremaining: 25.9s\n",
+      "300:\ttotal: 17.1s\tremaining: 11.3s\n",
+      "400:\ttotal: 23.2s\tremaining: 5.72s\n",
+      "100:\ttotal: 5.81s\tremaining: 22.9s\n",
+      "499:\ttotal: 28.7s\tremaining: 0us\n",
+      "0:\ttotal: 97.1ms\tremaining: 48.5s\n",
+      "100:\ttotal: 5.55s\tremaining: 21.9s\n",
+      "400:\ttotal: 22.4s\tremaining: 5.54s\n",
+      "100:\ttotal: 5.89s\tremaining: 23.3s\n",
+      "100:\ttotal: 5.37s\tremaining: 21.2s\n",
+      "400:\ttotal: 22.8s\tremaining: 5.63s\n",
+      "499:\ttotal: 28.9s\tremaining: 0us\n",
+      "0:\ttotal: 76.6ms\tremaining: 38.2s\n",
+      "200:\ttotal: 11.5s\tremaining: 17.1s\n",
+      "100:\ttotal: 5.69s\tremaining: 22.5s\n",
+      "200:\ttotal: 11.4s\tremaining: 17s\n",
+      "499:\ttotal: 28.1s\tremaining: 0us\n",
+      "200:\ttotal: 11.5s\tremaining: 17.2s\n",
+      "200:\ttotal: 10.9s\tremaining: 16.2s\n",
+      "0:\ttotal: 68.7ms\tremaining: 34.3s\n",
+      "499:\ttotal: 28.3s\tremaining: 0us\n",
+      "0:\ttotal: 79ms\tremaining: 39.4s\n",
+      "100:\ttotal: 5.6s\tremaining: 22.1s\n",
+      "300:\ttotal: 17s\tremaining: 11.2s\n",
+      "200:\ttotal: 11.2s\tremaining: 16.6s\n",
+      "300:\ttotal: 16.8s\tremaining: 11.1s\n",
+      "300:\ttotal: 17s\tremaining: 11.3s\n",
+      "300:\ttotal: 16.4s\tremaining: 10.9s\n",
+      "100:\ttotal: 5.63s\tremaining: 22.3s\n",
+      "200:\ttotal: 11.5s\tremaining: 17s\n",
+      "100:\ttotal: 7.41s\tremaining: 29.3s\n",
+      "400:\ttotal: 23.2s\tremaining: 5.73s\n",
+      "300:\ttotal: 17.3s\tremaining: 11.4s\n",
+      "400:\ttotal: 22.9s\tremaining: 5.66s\n",
+      "400:\ttotal: 23.3s\tremaining: 5.76s\n",
+      "200:\ttotal: 11.9s\tremaining: 17.7s\n",
+      "400:\ttotal: 22.8s\tremaining: 5.64s\n",
+      "300:\ttotal: 17.3s\tremaining: 11.4s\n",
+      "499:\ttotal: 28.7s\tremaining: 0us\n",
+      "0:\ttotal: 85.9ms\tremaining: 42.8s\n",
+      "400:\ttotal: 23.1s\tremaining: 5.7s\n",
+      "200:\ttotal: 14.2s\tremaining: 21.1s\n",
+      "499:\ttotal: 29s\tremaining: 0us\n",
+      "499:\ttotal: 29.2s\tremaining: 0us\n",
+      "0:\ttotal: 74.7ms\tremaining: 37.3s\n",
+      "300:\ttotal: 17.6s\tremaining: 11.6s\n",
+      "499:\ttotal: 28.5s\tremaining: 0us\n",
+      "0:\ttotal: 61.6ms\tremaining: 30.7s\n",
+      "0:\ttotal: 76ms\tremaining: 37.9s\n",
+      "400:\ttotal: 23.2s\tremaining: 5.74s\n",
+      "499:\ttotal: 29.1s\tremaining: 0us\n",
+      "0:\ttotal: 85ms\tremaining: 42.4s\n",
+      "100:\ttotal: 7.17s\tremaining: 28.3s\n",
+      "300:\ttotal: 22s\tremaining: 14.5s\n",
+      "400:\ttotal: 23.5s\tremaining: 5.8s\n",
+      "100:\ttotal: 7.28s\tremaining: 28.8s\n",
+      "100:\ttotal: 7.17s\tremaining: 28.3s\n",
+      "100:\ttotal: 7.16s\tremaining: 28.3s\n",
+      "499:\ttotal: 29.4s\tremaining: 0us\n",
+      "0:\ttotal: 69.3ms\tremaining: 34.6s\n",
+      "100:\ttotal: 7.52s\tremaining: 29.7s\n",
+      "200:\ttotal: 14.6s\tremaining: 21.7s\n",
+      "499:\ttotal: 29.4s\tremaining: 0us\n",
+      "0:\ttotal: 79.6ms\tremaining: 39.7s\n",
+      "400:\ttotal: 29.6s\tremaining: 7.32s\n",
+      "200:\ttotal: 14.9s\tremaining: 22.2s\n",
+      "200:\ttotal: 14.8s\tremaining: 22.1s\n",
+      "200:\ttotal: 14.9s\tremaining: 22.1s\n",
+      "100:\ttotal: 7.47s\tremaining: 29.5s\n",
+      "200:\ttotal: 15.5s\tremaining: 23s\n",
+      "300:\ttotal: 22.6s\tremaining: 15s\n",
+      "100:\ttotal: 8.23s\tremaining: 32.5s\n",
+      "499:\ttotal: 37.7s\tremaining: 0us\n",
+      "0:\ttotal: 143ms\tremaining: 1m 11s\n",
+      "300:\ttotal: 23.4s\tremaining: 15.5s\n",
+      "300:\ttotal: 23.2s\tremaining: 15.4s\n",
+      "300:\ttotal: 23.4s\tremaining: 15.4s\n",
+      "200:\ttotal: 15.6s\tremaining: 23.2s\n",
+      "400:\ttotal: 30.5s\tremaining: 7.53s\n",
+      "300:\ttotal: 24.1s\tremaining: 15.9s\n",
+      "200:\ttotal: 15.8s\tremaining: 23.5s\n",
+      "100:\ttotal: 7.56s\tremaining: 29.9s\n",
+      "400:\ttotal: 31s\tremaining: 7.66s\n",
+      "400:\ttotal: 30.8s\tremaining: 7.6s\n",
+      "400:\ttotal: 30.9s\tremaining: 7.62s\n",
+      "300:\ttotal: 23.9s\tremaining: 15.8s\n",
+      "499:\ttotal: 37.9s\tremaining: 0us\n",
+      "400:\ttotal: 31.9s\tremaining: 7.86s\n",
+      "0:\ttotal: 65.9ms\tremaining: 32.9s\n",
+      "300:\ttotal: 23.7s\tremaining: 15.7s\n",
+      "200:\ttotal: 14.9s\tremaining: 22.2s\n",
+      "499:\ttotal: 38.5s\tremaining: 0us\n",
+      "499:\ttotal: 38.3s\tremaining: 0us\n",
+      "0:\ttotal: 60.1ms\tremaining: 30s\n",
+      "499:\ttotal: 38.2s\tremaining: 0us\n",
+      "0:\ttotal: 149ms\tremaining: 1m 14s\n",
+      "0:\ttotal: 63.2ms\tremaining: 31.5s\n",
+      "400:\ttotal: 32.1s\tremaining: 7.94s\n",
+      "100:\ttotal: 7.54s\tremaining: 29.8s\n",
+      "499:\ttotal: 40s\tremaining: 0us\n",
+      "0:\ttotal: 95.6ms\tremaining: 47.7s\n",
+      "400:\ttotal: 31.6s\tremaining: 7.81s\n",
+      "300:\ttotal: 22.9s\tremaining: 15.2s\n",
+      "100:\ttotal: 7.46s\tremaining: 29.5s\n",
+      "100:\ttotal: 7.72s\tremaining: 30.5s\n",
+      "100:\ttotal: 7.58s\tremaining: 29.9s\n",
+      "499:\ttotal: 39.9s\tremaining: 0us\n",
+      "0:\ttotal: 58.3ms\tremaining: 29.1s\n",
+      "200:\ttotal: 15.7s\tremaining: 23.4s\n",
+      "100:\ttotal: 7.98s\tremaining: 31.5s\n",
+      "499:\ttotal: 40.3s\tremaining: 0us\n",
+      "400:\ttotal: 31.4s\tremaining: 7.76s\n",
+      "0:\ttotal: 80.4ms\tremaining: 40.1s\n",
+      "200:\ttotal: 16.1s\tremaining: 23.9s\n",
+      "200:\ttotal: 16.3s\tremaining: 24.3s\n",
+      "200:\ttotal: 16.5s\tremaining: 24.5s\n",
+      "100:\ttotal: 7.57s\tremaining: 29.9s\n",
+      "300:\ttotal: 24s\tremaining: 15.8s\n",
+      "200:\ttotal: 16.4s\tremaining: 24.4s\n",
+      "499:\ttotal: 39.5s\tremaining: 0us\n",
+      "100:\ttotal: 8.06s\tremaining: 31.9s\n",
+      "0:\ttotal: 92.2ms\tremaining: 46s\n",
+      "300:\ttotal: 24.3s\tremaining: 16.1s\n",
+      "300:\ttotal: 24.8s\tremaining: 16.4s\n",
+      "300:\ttotal: 24.6s\tremaining: 16.3s\n",
+      "200:\ttotal: 16s\tremaining: 23.8s\n",
+      "400:\ttotal: 32.2s\tremaining: 7.96s\n",
+      "300:\ttotal: 24.5s\tremaining: 16.2s\n",
+      "100:\ttotal: 8.16s\tremaining: 32.2s\n",
+      "200:\ttotal: 16.6s\tremaining: 24.7s\n",
+      "400:\ttotal: 32.5s\tremaining: 8.02s\n",
+      "400:\ttotal: 33.1s\tremaining: 8.18s\n",
+      "400:\ttotal: 33s\tremaining: 8.14s\n",
+      "300:\ttotal: 24.2s\tremaining: 16s\n",
+      "499:\ttotal: 40.5s\tremaining: 0us\n",
+      "0:\ttotal: 74ms\tremaining: 36.9s\n",
+      "400:\ttotal: 32.9s\tremaining: 8.13s\n",
+      "200:\ttotal: 16.9s\tremaining: 25.1s\n",
+      "300:\ttotal: 25.7s\tremaining: 17s\n",
+      "499:\ttotal: 41.3s\tremaining: 0us\n",
+      "0:\ttotal: 103ms\tremaining: 51.3s\n",
+      "499:\ttotal: 42.5s\tremaining: 0us\n",
+      "499:\ttotal: 42.3s\tremaining: 0us\n",
+      "0:\ttotal: 106ms\tremaining: 52.8s\n",
+      "0:\ttotal: 85.7ms\tremaining: 42.7s\n",
+      "400:\ttotal: 33.8s\tremaining: 8.33s\n",
+      "100:\ttotal: 9.28s\tremaining: 36.7s\n",
+      "499:\ttotal: 42.6s\tremaining: 0us\n",
+      "0:\ttotal: 79.5ms\tremaining: 39.7s\n",
+      "300:\ttotal: 25.9s\tremaining: 17.1s\n",
+      "400:\ttotal: 34.3s\tremaining: 8.47s\n",
+      "100:\ttotal: 8.41s\tremaining: 33.2s\n",
+      "100:\ttotal: 7.96s\tremaining: 31.5s\n",
+      "100:\ttotal: 8.23s\tremaining: 32.5s\n",
+      "499:\ttotal: 42.2s\tremaining: 0us\n",
+      "0:\ttotal: 60.9ms\tremaining: 30.4s\n",
+      "200:\ttotal: 18.5s\tremaining: 27.5s\n",
+      "100:\ttotal: 8.31s\tremaining: 32.8s\n",
+      "499:\ttotal: 43.5s\tremaining: 0us\n",
+      "400:\ttotal: 35.3s\tremaining: 8.71s\n",
+      "0:\ttotal: 81.6ms\tremaining: 40.7s\n",
+      "200:\ttotal: 17.8s\tremaining: 26.5s\n",
+      "200:\ttotal: 16.9s\tremaining: 25.2s\n",
+      "200:\ttotal: 17.8s\tremaining: 26.6s\n",
+      "100:\ttotal: 8.14s\tremaining: 32.2s\n",
+      "200:\ttotal: 16.4s\tremaining: 24.3s\n",
+      "300:\ttotal: 27.7s\tremaining: 18.3s\n",
+      "100:\ttotal: 8.36s\tremaining: 33s\n",
+      "499:\ttotal: 44.5s\tremaining: 0us\n",
+      "0:\ttotal: 79.4ms\tremaining: 39.6s\n",
+      "300:\ttotal: 25.3s\tremaining: 16.7s\n",
+      "300:\ttotal: 27.6s\tremaining: 18.2s\n",
+      "200:\ttotal: 16.9s\tremaining: 25.1s\n",
+      "300:\ttotal: 27.3s\tremaining: 18.1s\n",
+      "300:\ttotal: 25.7s\tremaining: 17s\n",
+      "400:\ttotal: 37.4s\tremaining: 9.24s\n",
+      "200:\ttotal: 17.2s\tremaining: 25.7s\n",
+      "100:\ttotal: 8.5s\tremaining: 33.6s\n",
+      "400:\ttotal: 34.1s\tremaining: 8.43s\n",
+      "300:\ttotal: 25.2s\tremaining: 16.7s\n",
+      "400:\ttotal: 37.2s\tremaining: 9.18s\n",
+      "400:\ttotal: 36.4s\tremaining: 8.99s\n",
+      "400:\ttotal: 34.2s\tremaining: 8.43s\n",
+      "499:\ttotal: 46.2s\tremaining: 0us\n",
+      "300:\ttotal: 25.6s\tremaining: 16.9s\n",
+      "0:\ttotal: 44.8ms\tremaining: 22.3s\n",
+      "200:\ttotal: 16.4s\tremaining: 24.3s\n",
+      "499:\ttotal: 42.1s\tremaining: 0us\n",
+      "0:\ttotal: 96.9ms\tremaining: 48.4s\n",
+      "400:\ttotal: 33.5s\tremaining: 8.27s\n",
+      "499:\ttotal: 45.9s\tremaining: 0us\n",
+      "499:\ttotal: 45s\tremaining: 0us\n",
+      "0:\ttotal: 77.7ms\tremaining: 38.8s\n",
+      "0:\ttotal: 86.4ms\tremaining: 43.1s\n",
+      "499:\ttotal: 42s\tremaining: 0us\n",
+      "0:\ttotal: 145ms\tremaining: 1m 12s\n",
+      "400:\ttotal: 33.7s\tremaining: 8.32s\n",
+      "100:\ttotal: 8.15s\tremaining: 32.2s\n",
+      "300:\ttotal: 24.8s\tremaining: 16.4s\n",
+      "499:\ttotal: 41.6s\tremaining: 0us\n",
+      "100:\ttotal: 8.35s\tremaining: 33s\n",
+      "0:\ttotal: 55ms\tremaining: 27.5s\n",
+      "100:\ttotal: 7.7s\tremaining: 30.4s\n",
+      "100:\ttotal: 8.09s\tremaining: 32s\n",
+      "100:\ttotal: 8.02s\tremaining: 31.7s\n",
+      "499:\ttotal: 42.1s\tremaining: 0us\n",
+      "200:\ttotal: 16.5s\tremaining: 24.6s\n",
+      "0:\ttotal: 107ms\tremaining: 53.5s\n",
+      "400:\ttotal: 33.4s\tremaining: 8.23s\n",
+      "200:\ttotal: 17.2s\tremaining: 25.6s\n",
+      "100:\ttotal: 8.99s\tremaining: 35.5s\n",
+      "200:\ttotal: 16.6s\tremaining: 24.6s\n",
+      "200:\ttotal: 17.4s\tremaining: 25.9s\n",
+      "200:\ttotal: 17.2s\tremaining: 25.5s\n",
+      "100:\ttotal: 8.46s\tremaining: 33.4s\n",
+      "300:\ttotal: 25.7s\tremaining: 17s\n",
+      "499:\ttotal: 41.8s\tremaining: 0us\n",
+      "0:\ttotal: 72.4ms\tremaining: 36.1s\n",
+      "300:\ttotal: 25.7s\tremaining: 17s\n",
+      "200:\ttotal: 17.4s\tremaining: 25.9s\n",
+      "300:\ttotal: 24.8s\tremaining: 16.4s\n",
+      "300:\ttotal: 26s\tremaining: 17.2s\n",
+      "300:\ttotal: 25.6s\tremaining: 16.9s\n",
+      "200:\ttotal: 16.7s\tremaining: 24.9s\n",
+      "400:\ttotal: 34s\tremaining: 8.39s\n",
+      "100:\ttotal: 8.13s\tremaining: 32.1s\n",
+      "400:\ttotal: 34.1s\tremaining: 8.43s\n",
+      "300:\ttotal: 25.4s\tremaining: 16.8s\n",
+      "400:\ttotal: 33.2s\tremaining: 8.2s\n",
+      "400:\ttotal: 34.5s\tremaining: 8.53s\n",
+      "400:\ttotal: 34.5s\tremaining: 8.51s\n",
+      "300:\ttotal: 25.6s\tremaining: 16.9s\n",
+      "499:\ttotal: 42.6s\tremaining: 0us\n",
+      "200:\ttotal: 16.7s\tremaining: 24.8s\n",
+      "0:\ttotal: 66.3ms\tremaining: 33.1s\n",
+      "499:\ttotal: 42.4s\tremaining: 0us\n",
+      "400:\ttotal: 34s\tremaining: 8.4s\n",
+      "0:\ttotal: 146ms\tremaining: 1m 13s\n",
+      "499:\ttotal: 41.7s\tremaining: 0us\n",
+      "0:\ttotal: 75.8ms\tremaining: 37.8s\n",
+      "499:\ttotal: 43.4s\tremaining: 0us\n",
+      "0:\ttotal: 63.5ms\tremaining: 31.7s\n",
+      "499:\ttotal: 43s\tremaining: 0us\n",
+      "0:\ttotal: 111ms\tremaining: 55.4s\n",
+      "400:\ttotal: 34.1s\tremaining: 8.43s\n",
+      "100:\ttotal: 8.2s\tremaining: 32.4s\n",
+      "300:\ttotal: 25.5s\tremaining: 16.9s\n",
+      "100:\ttotal: 8.21s\tremaining: 32.5s\n",
+      "499:\ttotal: 42.9s\tremaining: 0us\n",
+      "100:\ttotal: 8.36s\tremaining: 33s\n",
+      "0:\ttotal: 69ms\tremaining: 34.5s\n",
+      "100:\ttotal: 8.06s\tremaining: 31.8s\n",
+      "100:\ttotal: 8.35s\tremaining: 33s\n",
+      "499:\ttotal: 42.6s\tremaining: 0us\n",
+      "200:\ttotal: 16.2s\tremaining: 24.1s\n",
+      "400:\ttotal: 33.3s\tremaining: 8.22s\n",
+      "0:\ttotal: 61ms\tremaining: 30.4s\n",
+      "200:\ttotal: 16.3s\tremaining: 24.3s\n",
+      "200:\ttotal: 16.3s\tremaining: 24.2s\n",
+      "100:\ttotal: 7.68s\tremaining: 30.3s\n",
+      "200:\ttotal: 16.1s\tremaining: 23.9s\n",
+      "200:\ttotal: 16.3s\tremaining: 24.2s\n",
+      "300:\ttotal: 24.2s\tremaining: 16s\n",
+      "100:\ttotal: 7.75s\tremaining: 30.6s\n",
+      "499:\ttotal: 41.4s\tremaining: 0us\n",
+      "0:\ttotal: 54.6ms\tremaining: 27.2s\n",
+      "300:\ttotal: 24.5s\tremaining: 16.2s\n",
+      "300:\ttotal: 24.3s\tremaining: 16.1s\n",
+      "200:\ttotal: 15.8s\tremaining: 23.5s\n",
+      "300:\ttotal: 24.1s\tremaining: 15.9s\n",
+      "300:\ttotal: 25s\tremaining: 16.5s\n",
+      "400:\ttotal: 32.4s\tremaining: 8.01s\n",
+      "100:\ttotal: 7.49s\tremaining: 29.6s\n",
+      "200:\ttotal: 16.4s\tremaining: 24.4s\n",
+      "400:\ttotal: 33s\tremaining: 8.14s\n",
+      "300:\ttotal: 24.4s\tremaining: 16.1s\n",
+      "400:\ttotal: 33.1s\tremaining: 8.18s\n",
+      "400:\ttotal: 32.8s\tremaining: 8.09s\n",
+      "499:\ttotal: 40.4s\tremaining: 0us\n",
+      "400:\ttotal: 33.7s\tremaining: 8.31s\n",
+      "200:\ttotal: 15.2s\tremaining: 22.7s\n",
+      "0:\ttotal: 196ms\tremaining: 1m 37s\n",
+      "300:\ttotal: 24.7s\tremaining: 16.3s\n",
+      "499:\ttotal: 41.4s\tremaining: 0us\n",
+      "0:\ttotal: 73.2ms\tremaining: 36.5s\n",
+      "400:\ttotal: 32.8s\tremaining: 8.11s\n",
+      "499:\ttotal: 41.6s\tremaining: 0us\n",
+      "0:\ttotal: 80.6ms\tremaining: 40.2s\n",
+      "499:\ttotal: 41.3s\tremaining: 0us\n",
+      "0:\ttotal: 76.2ms\tremaining: 38s\n",
+      "100:\ttotal: 7.21s\tremaining: 28.5s\n",
+      "300:\ttotal: 23.1s\tremaining: 15.2s\n",
+      "499:\ttotal: 42s\tremaining: 0us\n",
+      "400:\ttotal: 32.6s\tremaining: 8.05s\n",
+      "0:\ttotal: 94.5ms\tremaining: 47.2s\n",
+      "100:\ttotal: 7.21s\tremaining: 28.5s\n",
+      "499:\ttotal: 40.7s\tremaining: 0us\n",
+      "100:\ttotal: 7.26s\tremaining: 28.7s\n",
+      "0:\ttotal: 88.9ms\tremaining: 44.3s\n",
+      "100:\ttotal: 7.41s\tremaining: 29.3s\n",
+      "200:\ttotal: 14.9s\tremaining: 22.1s\n",
+      "400:\ttotal: 31s\tremaining: 7.66s\n",
+      "100:\ttotal: 7.91s\tremaining: 31.2s\n",
+      "499:\ttotal: 41s\tremaining: 0us\n",
+      "200:\ttotal: 14.5s\tremaining: 21.6s\n",
+      "0:\ttotal: 63.4ms\tremaining: 31.6s\n",
+      "200:\ttotal: 14.7s\tremaining: 21.9s\n",
+      "100:\ttotal: 7.38s\tremaining: 29.2s\n",
+      "200:\ttotal: 15.7s\tremaining: 23.4s\n",
+      "300:\ttotal: 23s\tremaining: 15.2s\n",
+      "499:\ttotal: 39s\tremaining: 0us\n",
+      "0:\ttotal: 90.5ms\tremaining: 45.2s\n",
+      "200:\ttotal: 16.1s\tremaining: 23.9s\n",
+      "300:\ttotal: 23.3s\tremaining: 15.4s\n",
+      "100:\ttotal: 8.77s\tremaining: 34.6s\n",
+      "300:\ttotal: 23.2s\tremaining: 15.3s\n",
+      "200:\ttotal: 15.7s\tremaining: 23.3s\n",
+      "400:\ttotal: 30.9s\tremaining: 7.64s\n",
+      "300:\ttotal: 24.2s\tremaining: 16s\n",
+      "100:\ttotal: 8.12s\tremaining: 32.1s\n",
+      "300:\ttotal: 24.6s\tremaining: 16.2s\n",
+      "400:\ttotal: 31.1s\tremaining: 7.68s\n",
+      "200:\ttotal: 16.7s\tremaining: 24.8s\n",
+      "400:\ttotal: 31.1s\tremaining: 7.68s\n",
+      "300:\ttotal: 24.4s\tremaining: 16.1s\n",
+      "499:\ttotal: 38.6s\tremaining: 0us\n",
+      "400:\ttotal: 32.1s\tremaining: 7.92s\n",
+      "0:\ttotal: 80.8ms\tremaining: 40.3s\n",
+      "200:\ttotal: 15.7s\tremaining: 23.4s\n",
+      "499:\ttotal: 38.6s\tremaining: 0us\n",
+      "400:\ttotal: 32.6s\tremaining: 8.05s\n",
+      "0:\ttotal: 61.2ms\tremaining: 30.5s\n",
+      "300:\ttotal: 24.8s\tremaining: 16.4s\n",
+      "499:\ttotal: 38.6s\tremaining: 0us\n",
+      "0:\ttotal: 87.2ms\tremaining: 43.5s\n",
+      "400:\ttotal: 32.3s\tremaining: 7.96s\n",
+      "499:\ttotal: 39.5s\tremaining: 0us\n",
+      "0:\ttotal: 59ms\tremaining: 29.5s\n",
+      "100:\ttotal: 7.62s\tremaining: 30.1s\n",
+      "300:\ttotal: 23.6s\tremaining: 15.6s\n",
+      "100:\ttotal: 7.46s\tremaining: 29.5s\n",
+      "499:\ttotal: 40.7s\tremaining: 0us\n",
+      "0:\ttotal: 99.8ms\tremaining: 49.8s\n",
+      "400:\ttotal: 33.4s\tremaining: 8.25s\n",
+      "100:\ttotal: 8.5s\tremaining: 33.6s\n",
+      "499:\ttotal: 40.8s\tremaining: 0us\n",
+      "0:\ttotal: 76.1ms\tremaining: 38s\n",
+      "100:\ttotal: 8.33s\tremaining: 32.9s\n",
+      "200:\ttotal: 15.9s\tremaining: 23.7s\n",
+      "400:\ttotal: 32.6s\tremaining: 8.04s\n",
+      "200:\ttotal: 16.5s\tremaining: 24.5s\n",
+      "100:\ttotal: 8.17s\tremaining: 32.3s\n",
+      "499:\ttotal: 41.3s\tremaining: 0us\n",
+      "0:\ttotal: 88.7ms\tremaining: 44.2s\n",
+      "200:\ttotal: 16.5s\tremaining: 24.6s\n",
+      "100:\ttotal: 7.8s\tremaining: 30.8s\n",
+      "200:\ttotal: 16.9s\tremaining: 25.2s\n",
+      "300:\ttotal: 24.5s\tremaining: 16.2s\n",
+      "499:\ttotal: 41.5s\tremaining: 0us\n",
+      "0:\ttotal: 82.6ms\tremaining: 41.2s\n",
+      "300:\ttotal: 25.1s\tremaining: 16.6s\n",
+      "200:\ttotal: 17.1s\tremaining: 25.4s\n",
+      "100:\ttotal: 8.93s\tremaining: 35.3s\n",
+      "300:\ttotal: 25.2s\tremaining: 16.7s\n",
+      "200:\ttotal: 16.2s\tremaining: 24.2s\n",
+      "300:\ttotal: 25.2s\tremaining: 16.7s\n",
+      "400:\ttotal: 32.5s\tremaining: 8.03s\n",
+      "100:\ttotal: 7.84s\tremaining: 31s\n",
+      "400:\ttotal: 33.2s\tremaining: 8.19s\n",
+      "300:\ttotal: 24.9s\tremaining: 16.5s\n",
+      "400:\ttotal: 32.8s\tremaining: 8.1s\n",
+      "200:\ttotal: 17.3s\tremaining: 25.7s\n",
+      "300:\ttotal: 24.5s\tremaining: 16.2s\n",
+      "499:\ttotal: 40.6s\tremaining: 0us\n",
+      "400:\ttotal: 33.5s\tremaining: 8.27s\n",
+      "0:\ttotal: 56.4ms\tremaining: 28.2s\n",
+      "200:\ttotal: 16.5s\tremaining: 24.6s\n",
+      "499:\ttotal: 41.7s\tremaining: 0us\n",
+      "400:\ttotal: 33.7s\tremaining: 8.32s\n",
+      "0:\ttotal: 98.3ms\tremaining: 49.1s\n",
+      "499:\ttotal: 41.3s\tremaining: 0us\n",
+      "300:\ttotal: 25.7s\tremaining: 17s\n",
+      "0:\ttotal: 68.6ms\tremaining: 34.2s\n",
+      "400:\ttotal: 33.3s\tremaining: 8.22s\n",
+      "100:\ttotal: 8.5s\tremaining: 33.6s\n",
+      "499:\ttotal: 42.3s\tremaining: 0us\n",
+      "0:\ttotal: 88ms\tremaining: 43.9s\n",
+      "300:\ttotal: 25.2s\tremaining: 16.7s\n",
+      "100:\ttotal: 7.87s\tremaining: 31.1s\n",
+      "499:\ttotal: 41.9s\tremaining: 0us\n",
+      "0:\ttotal: 66.7ms\tremaining: 33.3s\n",
+      "400:\ttotal: 33.4s\tremaining: 8.25s\n",
+      "100:\ttotal: 8.21s\tremaining: 32.4s\n",
+      "499:\ttotal: 41.2s\tremaining: 0us\n",
+      "0:\ttotal: 71ms\tremaining: 35.4s\n",
+      "200:\ttotal: 16.9s\tremaining: 25.1s\n",
+      "100:\ttotal: 7.75s\tremaining: 30.6s\n",
+      "400:\ttotal: 33.4s\tremaining: 8.24s\n",
+      "200:\ttotal: 16.2s\tremaining: 24.1s\n",
+      "100:\ttotal: 7.67s\tremaining: 30.3s\n",
+      "499:\ttotal: 41.8s\tremaining: 0us\n",
+      "200:\ttotal: 16.4s\tremaining: 24.4s\n",
+      "0:\ttotal: 128ms\tremaining: 1m 4s\n",
+      "100:\ttotal: 7.93s\tremaining: 31.4s\n",
+      "200:\ttotal: 15.4s\tremaining: 23s\n",
+      "300:\ttotal: 25.6s\tremaining: 16.9s\n",
+      "499:\ttotal: 41.7s\tremaining: 0us\n",
+      "300:\ttotal: 24.3s\tremaining: 16.1s\n",
+      "200:\ttotal: 15.6s\tremaining: 23.1s\n",
+      "0:\ttotal: 58.9ms\tremaining: 29.4s\n",
+      "100:\ttotal: 7.33s\tremaining: 29s\n",
+      "300:\ttotal: 24.7s\tremaining: 16.4s\n",
+      "200:\ttotal: 15.9s\tremaining: 23.6s\n",
+      "300:\ttotal: 24s\tremaining: 15.9s\n",
+      "400:\ttotal: 34.5s\tremaining: 8.53s\n",
+      "300:\ttotal: 23.9s\tremaining: 15.8s\n",
+      "400:\ttotal: 33.1s\tremaining: 8.16s\n",
+      "100:\ttotal: 8.74s\tremaining: 34.5s\n",
+      "200:\ttotal: 15.9s\tremaining: 23.6s\n",
+      "400:\ttotal: 33.7s\tremaining: 8.32s\n",
+      "300:\ttotal: 24.1s\tremaining: 15.9s\n",
+      "400:\ttotal: 32s\tremaining: 7.89s\n",
+      "499:\ttotal: 42.6s\tremaining: 0us\n",
+      "0:\ttotal: 74.9ms\tremaining: 37.4s\n",
+      "400:\ttotal: 31.7s\tremaining: 7.83s\n",
+      "200:\ttotal: 16.5s\tremaining: 24.6s\n",
+      "499:\ttotal: 41.3s\tremaining: 0us\n",
+      "0:\ttotal: 129ms\tremaining: 1m 4s\n",
+      "300:\ttotal: 24.1s\tremaining: 15.9s\n",
+      "499:\ttotal: 42.1s\tremaining: 0us\n",
+      "400:\ttotal: 32.5s\tremaining: 8.01s\n",
+      "0:\ttotal: 73.4ms\tremaining: 36.6s\n",
+      "499:\ttotal: 40.4s\tremaining: 0us\n",
+      "0:\ttotal: 76.5ms\tremaining: 38.2s\n",
+      "100:\ttotal: 8.4s\tremaining: 33.2s\n",
+      "499:\ttotal: 39.8s\tremaining: 0us\n",
+      "0:\ttotal: 68.8ms\tremaining: 34.3s\n",
+      "100:\ttotal: 7.9s\tremaining: 31.2s\n",
+      "300:\ttotal: 25s\tremaining: 16.6s\n",
+      "400:\ttotal: 32.3s\tremaining: 7.97s\n",
+      "499:\ttotal: 39.9s\tremaining: 0us\n",
+      "100:\ttotal: 7.69s\tremaining: 30.4s\n",
+      "0:\ttotal: 92.9ms\tremaining: 46.3s\n",
+      "100:\ttotal: 7.43s\tremaining: 29.3s\n",
+      "200:\ttotal: 15.8s\tremaining: 23.5s\n",
+      "100:\ttotal: 8.07s\tremaining: 31.9s\n",
+      "200:\ttotal: 16s\tremaining: 23.8s\n",
+      "400:\ttotal: 33.5s\tremaining: 8.27s\n",
+      "499:\ttotal: 40.7s\tremaining: 0us\n",
+      "0:\ttotal: 69ms\tremaining: 34.4s\n",
+      "200:\ttotal: 16.1s\tremaining: 24s\n",
+      "100:\ttotal: 8.47s\tremaining: 33.5s\n",
+      "200:\ttotal: 15.7s\tremaining: 23.3s\n",
+      "300:\ttotal: 24.3s\tremaining: 16.1s\n",
+      "200:\ttotal: 15.4s\tremaining: 22.9s\n",
+      "499:\ttotal: 40.9s\tremaining: 0us\n",
+      "300:\ttotal: 24.1s\tremaining: 15.9s\n",
+      "0:\ttotal: 57.8ms\tremaining: 28.8s\n",
+      "100:\ttotal: 7.8s\tremaining: 30.8s\n",
+      "300:\ttotal: 24.3s\tremaining: 16.1s\n",
+      "200:\ttotal: 16.7s\tremaining: 24.8s\n",
+      "300:\ttotal: 23.9s\tremaining: 15.8s\n",
+      "400:\ttotal: 32.4s\tremaining: 8s\n",
+      "300:\ttotal: 23.3s\tremaining: 15.4s\n",
+      "100:\ttotal: 7.59s\tremaining: 30s\n",
+      "400:\ttotal: 32.4s\tremaining: 7.99s\n",
+      "200:\ttotal: 15.7s\tremaining: 23.3s\n",
+      "300:\ttotal: 24.5s\tremaining: 16.2s\n",
+      "400:\ttotal: 32.3s\tremaining: 7.97s\n",
+      "400:\ttotal: 31.9s\tremaining: 7.87s\n",
+      "499:\ttotal: 40.4s\tremaining: 0us\n",
+      "400:\ttotal: 31.5s\tremaining: 7.77s\n",
+      "0:\ttotal: 92.2ms\tremaining: 46s\n",
+      "200:\ttotal: 15.6s\tremaining: 23.2s\n",
+      "499:\ttotal: 40.1s\tremaining: 0us\n",
+      "0:\ttotal: 99.2ms\tremaining: 49.5s\n",
+      "300:\ttotal: 23.6s\tremaining: 15.6s\n",
+      "499:\ttotal: 40.1s\tremaining: 0us\n",
+      "400:\ttotal: 32.7s\tremaining: 8.07s\n",
+      "0:\ttotal: 91.6ms\tremaining: 45.7s\n",
+      "499:\ttotal: 39.7s\tremaining: 0us\n",
+      "0:\ttotal: 123ms\tremaining: 1m 1s\n",
+      "100:\ttotal: 7.85s\tremaining: 31s\n",
+      "499:\ttotal: 39.7s\tremaining: 0us\n",
+      "0:\ttotal: 59.3ms\tremaining: 29.6s\n",
+      "300:\ttotal: 23.7s\tremaining: 15.6s\n",
+      "100:\ttotal: 8.11s\tremaining: 32s\n",
+      "400:\ttotal: 31.9s\tremaining: 7.87s\n",
+      "100:\ttotal: 8.25s\tremaining: 32.6s\n",
+      "499:\ttotal: 41.3s\tremaining: 0us\n",
+      "0:\ttotal: 63.2ms\tremaining: 31.5s\n",
+      "100:\ttotal: 8.02s\tremaining: 31.7s\n",
+      "200:\ttotal: 15.9s\tremaining: 23.7s\n",
+      "100:\ttotal: 7.65s\tremaining: 30.2s\n",
+      "400:\ttotal: 31.9s\tremaining: 7.87s\n",
+      "200:\ttotal: 16s\tremaining: 23.9s\n",
+      "499:\ttotal: 39.7s\tremaining: 0us\n",
+      "0:\ttotal: 59.5ms\tremaining: 29.7s\n",
+      "200:\ttotal: 16s\tremaining: 23.8s\n",
+      "100:\ttotal: 8.06s\tremaining: 31.8s\n",
+      "200:\ttotal: 16.1s\tremaining: 24s\n",
+      "300:\ttotal: 23.9s\tremaining: 15.8s\n",
+      "200:\ttotal: 15.8s\tremaining: 23.5s\n",
+      "499:\ttotal: 39.9s\tremaining: 0us\n",
+      "0:\ttotal: 137ms\tremaining: 1m 8s\n",
+      "300:\ttotal: 24.2s\tremaining: 16s\n",
+      "100:\ttotal: 7.94s\tremaining: 31.4s\n",
+      "300:\ttotal: 24.4s\tremaining: 16.1s\n",
+      "200:\ttotal: 16.5s\tremaining: 24.6s\n",
+      "300:\ttotal: 24.5s\tremaining: 16.2s\n",
+      "400:\ttotal: 32.8s\tremaining: 8.1s\n",
+      "300:\ttotal: 24.5s\tremaining: 16.2s\n",
+      "400:\ttotal: 32.4s\tremaining: 8s\n",
+      "200:\ttotal: 16.6s\tremaining: 24.7s\n",
+      "400:\ttotal: 32.7s\tremaining: 8.07s\n",
+      "100:\ttotal: 11.8s\tremaining: 46.5s\n",
+      "300:\ttotal: 25.5s\tremaining: 16.9s\n",
+      "400:\ttotal: 33.4s\tremaining: 8.24s\n",
+      "499:\ttotal: 41.6s\tremaining: 0us\n",
+      "400:\ttotal: 33.6s\tremaining: 8.29s\n",
+      "0:\ttotal: 156ms\tremaining: 1m 18s\n",
+      "499:\ttotal: 41.3s\tremaining: 0us\n",
+      "0:\ttotal: 75.1ms\tremaining: 37.5s\n",
+      "300:\ttotal: 25.1s\tremaining: 16.6s\n",
+      "499:\ttotal: 41.4s\tremaining: 0us\n",
+      "0:\ttotal: 88.6ms\tremaining: 44.2s\n",
+      "400:\ttotal: 33.7s\tremaining: 8.32s\n",
+      "499:\ttotal: 41.4s\tremaining: 0us\n",
+      "0:\ttotal: 150ms\tremaining: 1m 14s\n",
+      "200:\ttotal: 24.2s\tremaining: 35.9s\n",
+      "499:\ttotal: 42.4s\tremaining: 0us\n",
+      "0:\ttotal: 203ms\tremaining: 1m 41s\n",
+      "400:\ttotal: 34.4s\tremaining: 8.49s\n",
+      "100:\ttotal: 12.7s\tremaining: 50.2s\n",
+      "100:\ttotal: 12.3s\tremaining: 48.6s\n",
+      "499:\ttotal: 43.4s\tremaining: 0us\n",
+      "0:\ttotal: 101ms\tremaining: 50.2s\n",
+      "100:\ttotal: 13.1s\tremaining: 51.6s\n",
+      "100:\ttotal: 13.2s\tremaining: 52.1s\n",
+      "499:\ttotal: 43.6s\tremaining: 0us\n",
+      "0:\ttotal: 107ms\tremaining: 53.3s\n",
+      "300:\ttotal: 37.9s\tremaining: 25.1s\n",
+      "0:\ttotal: 75.8ms\tremaining: 37.8s\n",
+      "0:\ttotal: 121ms\tremaining: 1m\n"
+     ]
+    },
+    {
+     "ename": "KeyboardInterrupt",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+      "\u001b[31mKeyboardInterrupt\u001b[39m                         Traceback (most recent call last)",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[93]\u001b[39m\u001b[32m, line 33\u001b[39m\n\u001b[32m     23\u001b[39m grid_search = GridSearchCV(\n\u001b[32m     24\u001b[39m     estimator=catboost,\n\u001b[32m     25\u001b[39m     param_grid=param_grid,\n\u001b[32m   (...)\u001b[39m\u001b[32m     29\u001b[39m     n_jobs=-\u001b[32m1\u001b[39m,\n\u001b[32m     30\u001b[39m )\n\u001b[32m     32\u001b[39m \u001b[38;5;66;03m# Exécution de la recherche sur grille\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m33\u001b[39m \u001b[43mgrid_search\u001b[49m\u001b[43m.\u001b[49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcat_features\u001b[49m\u001b[43m=\u001b[49m\u001b[43mcat_features\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m     35\u001b[39m \u001b[38;5;66;03m# Afficher les meilleurs hyperparamètres\u001b[39;00m\n\u001b[32m     36\u001b[39m best_params = grid_search.best_params_\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/Workspace/studies/.venv/lib/python3.13/site-packages/sklearn/base.py:1389\u001b[39m, in \u001b[36m_fit_context.<locals>.decorator.<locals>.wrapper\u001b[39m\u001b[34m(estimator, *args, **kwargs)\u001b[39m\n\u001b[32m   1382\u001b[39m     estimator._validate_params()\n\u001b[32m   1384\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m config_context(\n\u001b[32m   1385\u001b[39m     skip_parameter_validation=(\n\u001b[32m   1386\u001b[39m         prefer_skip_nested_validation \u001b[38;5;129;01mor\u001b[39;00m global_skip_validation\n\u001b[32m   1387\u001b[39m     )\n\u001b[32m   1388\u001b[39m ):\n\u001b[32m-> \u001b[39m\u001b[32m1389\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfit_method\u001b[49m\u001b[43m(\u001b[49m\u001b[43mestimator\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/Workspace/studies/.venv/lib/python3.13/site-packages/sklearn/model_selection/_search.py:1024\u001b[39m, in \u001b[36mBaseSearchCV.fit\u001b[39m\u001b[34m(self, X, y, **params)\u001b[39m\n\u001b[32m   1018\u001b[39m     results = \u001b[38;5;28mself\u001b[39m._format_results(\n\u001b[32m   1019\u001b[39m         all_candidate_params, n_splits, all_out, all_more_results\n\u001b[32m   1020\u001b[39m     )\n\u001b[32m   1022\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m results\n\u001b[32m-> \u001b[39m\u001b[32m1024\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_run_search\u001b[49m\u001b[43m(\u001b[49m\u001b[43mevaluate_candidates\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m   1026\u001b[39m \u001b[38;5;66;03m# multimetric is determined here because in the case of a callable\u001b[39;00m\n\u001b[32m   1027\u001b[39m \u001b[38;5;66;03m# self.scoring the return type is only known after calling\u001b[39;00m\n\u001b[32m   1028\u001b[39m first_test_score = all_out[\u001b[32m0\u001b[39m][\u001b[33m\"\u001b[39m\u001b[33mtest_scores\u001b[39m\u001b[33m\"\u001b[39m]\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/Workspace/studies/.venv/lib/python3.13/site-packages/sklearn/model_selection/_search.py:1571\u001b[39m, in \u001b[36mGridSearchCV._run_search\u001b[39m\u001b[34m(self, evaluate_candidates)\u001b[39m\n\u001b[32m   1569\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m_run_search\u001b[39m(\u001b[38;5;28mself\u001b[39m, evaluate_candidates):\n\u001b[32m   1570\u001b[39m \u001b[38;5;250m    \u001b[39m\u001b[33;03m\"\"\"Search all candidates in param_grid\"\"\"\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m1571\u001b[39m     \u001b[43mevaluate_candidates\u001b[49m\u001b[43m(\u001b[49m\u001b[43mParameterGrid\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mparam_grid\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/Workspace/studies/.venv/lib/python3.13/site-packages/sklearn/model_selection/_search.py:970\u001b[39m, in \u001b[36mBaseSearchCV.fit.<locals>.evaluate_candidates\u001b[39m\u001b[34m(candidate_params, cv, more_results)\u001b[39m\n\u001b[32m    962\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.verbose > \u001b[32m0\u001b[39m:\n\u001b[32m    963\u001b[39m     \u001b[38;5;28mprint\u001b[39m(\n\u001b[32m    964\u001b[39m         \u001b[33m\"\u001b[39m\u001b[33mFitting \u001b[39m\u001b[38;5;132;01m{0}\u001b[39;00m\u001b[33m folds for each of \u001b[39m\u001b[38;5;132;01m{1}\u001b[39;00m\u001b[33m candidates,\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m    965\u001b[39m         \u001b[33m\"\u001b[39m\u001b[33m totalling \u001b[39m\u001b[38;5;132;01m{2}\u001b[39;00m\u001b[33m fits\u001b[39m\u001b[33m\"\u001b[39m.format(\n\u001b[32m    966\u001b[39m             n_splits, n_candidates, n_candidates * n_splits\n\u001b[32m    967\u001b[39m         )\n\u001b[32m    968\u001b[39m     )\n\u001b[32m--> \u001b[39m\u001b[32m970\u001b[39m out = \u001b[43mparallel\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m    971\u001b[39m \u001b[43m    \u001b[49m\u001b[43mdelayed\u001b[49m\u001b[43m(\u001b[49m\u001b[43m_fit_and_score\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m    972\u001b[39m \u001b[43m        \u001b[49m\u001b[43mclone\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbase_estimator\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    973\u001b[39m \u001b[43m        \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    974\u001b[39m \u001b[43m        \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    975\u001b[39m \u001b[43m        \u001b[49m\u001b[43mtrain\u001b[49m\u001b[43m=\u001b[49m\u001b[43mtrain\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    976\u001b[39m \u001b[43m        \u001b[49m\u001b[43mtest\u001b[49m\u001b[43m=\u001b[49m\u001b[43mtest\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    977\u001b[39m \u001b[43m        \u001b[49m\u001b[43mparameters\u001b[49m\u001b[43m=\u001b[49m\u001b[43mparameters\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    978\u001b[39m \u001b[43m        \u001b[49m\u001b[43msplit_progress\u001b[49m\u001b[43m=\u001b[49m\u001b[43m(\u001b[49m\u001b[43msplit_idx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mn_splits\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    979\u001b[39m \u001b[43m        \u001b[49m\u001b[43mcandidate_progress\u001b[49m\u001b[43m=\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcand_idx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mn_candidates\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    980\u001b[39m \u001b[43m        \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mfit_and_score_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    981\u001b[39m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    982\u001b[39m \u001b[43m    \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43mcand_idx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparameters\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43msplit_idx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrain\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtest\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mproduct\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m    983\u001b[39m \u001b[43m        \u001b[49m\u001b[38;5;28;43menumerate\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mcandidate_params\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    984\u001b[39m \u001b[43m        \u001b[49m\u001b[38;5;28;43menumerate\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mcv\u001b[49m\u001b[43m.\u001b[49m\u001b[43msplit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mrouted_params\u001b[49m\u001b[43m.\u001b[49m\u001b[43msplitter\u001b[49m\u001b[43m.\u001b[49m\u001b[43msplit\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    985\u001b[39m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    986\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    988\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(out) < \u001b[32m1\u001b[39m:\n\u001b[32m    989\u001b[39m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[32m    990\u001b[39m         \u001b[33m\"\u001b[39m\u001b[33mNo fits were performed. \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m    991\u001b[39m         \u001b[33m\"\u001b[39m\u001b[33mWas the CV iterator empty? \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m    992\u001b[39m         \u001b[33m\"\u001b[39m\u001b[33mWere there no candidates?\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m    993\u001b[39m     )\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/Workspace/studies/.venv/lib/python3.13/site-packages/sklearn/utils/parallel.py:77\u001b[39m, in \u001b[36mParallel.__call__\u001b[39m\u001b[34m(self, iterable)\u001b[39m\n\u001b[32m     72\u001b[39m config = get_config()\n\u001b[32m     73\u001b[39m iterable_with_config = (\n\u001b[32m     74\u001b[39m     (_with_config(delayed_func, config), args, kwargs)\n\u001b[32m     75\u001b[39m     \u001b[38;5;28;01mfor\u001b[39;00m delayed_func, args, kwargs \u001b[38;5;129;01min\u001b[39;00m iterable\n\u001b[32m     76\u001b[39m )\n\u001b[32m---> \u001b[39m\u001b[32m77\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[34;43m__call__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43miterable_with_config\u001b[49m\u001b[43m)\u001b[49m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/Workspace/studies/.venv/lib/python3.13/site-packages/joblib/parallel.py:2007\u001b[39m, in \u001b[36mParallel.__call__\u001b[39m\u001b[34m(self, iterable)\u001b[39m\n\u001b[32m   2001\u001b[39m \u001b[38;5;66;03m# The first item from the output is blank, but it makes the interpreter\u001b[39;00m\n\u001b[32m   2002\u001b[39m \u001b[38;5;66;03m# progress until it enters the Try/Except block of the generator and\u001b[39;00m\n\u001b[32m   2003\u001b[39m \u001b[38;5;66;03m# reaches the first `yield` statement. This starts the asynchronous\u001b[39;00m\n\u001b[32m   2004\u001b[39m \u001b[38;5;66;03m# dispatch of the tasks to the workers.\u001b[39;00m\n\u001b[32m   2005\u001b[39m \u001b[38;5;28mnext\u001b[39m(output)\n\u001b[32m-> \u001b[39m\u001b[32m2007\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m output \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.return_generator \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43moutput\u001b[49m\u001b[43m)\u001b[49m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/Workspace/studies/.venv/lib/python3.13/site-packages/joblib/parallel.py:1650\u001b[39m, in \u001b[36mParallel._get_outputs\u001b[39m\u001b[34m(self, iterator, pre_dispatch)\u001b[39m\n\u001b[32m   1647\u001b[39m     \u001b[38;5;28;01myield\u001b[39;00m\n\u001b[32m   1649\u001b[39m     \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m._backend.retrieval_context():\n\u001b[32m-> \u001b[39m\u001b[32m1650\u001b[39m         \u001b[38;5;28;01myield from\u001b[39;00m \u001b[38;5;28mself\u001b[39m._retrieve()\n\u001b[32m   1652\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mGeneratorExit\u001b[39;00m:\n\u001b[32m   1653\u001b[39m     \u001b[38;5;66;03m# The generator has been garbage collected before being fully\u001b[39;00m\n\u001b[32m   1654\u001b[39m     \u001b[38;5;66;03m# consumed. This aborts the remaining tasks if possible and warn\u001b[39;00m\n\u001b[32m   1655\u001b[39m     \u001b[38;5;66;03m# the user if necessary.\u001b[39;00m\n\u001b[32m   1656\u001b[39m     \u001b[38;5;28mself\u001b[39m._exception = \u001b[38;5;28;01mTrue\u001b[39;00m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/Workspace/studies/.venv/lib/python3.13/site-packages/joblib/parallel.py:1762\u001b[39m, in \u001b[36mParallel._retrieve\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m   1757\u001b[39m \u001b[38;5;66;03m# If the next job is not ready for retrieval yet, we just wait for\u001b[39;00m\n\u001b[32m   1758\u001b[39m \u001b[38;5;66;03m# async callbacks to progress.\u001b[39;00m\n\u001b[32m   1759\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m ((\u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m._jobs) == \u001b[32m0\u001b[39m) \u001b[38;5;129;01mor\u001b[39;00m\n\u001b[32m   1760\u001b[39m     (\u001b[38;5;28mself\u001b[39m._jobs[\u001b[32m0\u001b[39m].get_status(\n\u001b[32m   1761\u001b[39m         timeout=\u001b[38;5;28mself\u001b[39m.timeout) == TASK_PENDING)):\n\u001b[32m-> \u001b[39m\u001b[32m1762\u001b[39m     \u001b[43mtime\u001b[49m\u001b[43m.\u001b[49m\u001b[43msleep\u001b[49m\u001b[43m(\u001b[49m\u001b[32;43m0.01\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[32m   1763\u001b[39m     \u001b[38;5;28;01mcontinue\u001b[39;00m\n\u001b[32m   1765\u001b[39m \u001b[38;5;66;03m# We need to be careful: the job list can be filling up as\u001b[39;00m\n\u001b[32m   1766\u001b[39m \u001b[38;5;66;03m# we empty it and Python list are not thread-safe by\u001b[39;00m\n\u001b[32m   1767\u001b[39m \u001b[38;5;66;03m# default hence the use of the lock\u001b[39;00m\n",
+      "\u001b[31mKeyboardInterrupt\u001b[39m: "
+     ]
+    }
+   ],
+   "source": [
+    "# Définir la grille d'hyperparamètres à rechercher\n",
+    "param_grid = {\n",
+    "    \"learning_rate\": [0.01, 0.05, 0.1, 0.2],\n",
+    "    \"depth\": [4, 6, 8, 10],\n",
+    "    \"l2_leaf_reg\": [1, 3, 5, 7],\n",
+    "    \"bagging_temperature\": [0, 0.5, 1],\n",
+    "}\n",
+    "\n",
+    "# Nombre de folds pour la validation croisée\n",
+    "num_folds = 5\n",
+    "\n",
+    "# Initialisation du modèle CatBoostClassifier\n",
+    "catboost = CatBoostClassifier(\n",
+    "    iterations=500,\n",
+    "    loss_function=\"Logloss\",\n",
+    "    eval_metric=\"AUC\",\n",
+    "    random_seed=42,\n",
+    "    verbose=100,\n",
+    "    early_stopping_rounds=50,\n",
+    ")\n",
+    "\n",
+    "# Création de l'objet GridSearchCV pour la recherche sur grille avec validation croisée\n",
+    "grid_search = GridSearchCV(\n",
+    "    estimator=catboost,\n",
+    "    param_grid=param_grid,\n",
+    "    cv=KFold(\n",
+    "        n_splits=num_folds, shuffle=True, random_state=42\n",
+    "    ),\n",
+    "    n_jobs=-1,\n",
+    ")\n",
+    "\n",
+    "# Exécution de la recherche sur grille\n",
+    "grid_search.fit(X_train, y_train, cat_features=cat_features)\n",
+    "\n",
+    "# Afficher les meilleurs hyperparamètres\n",
+    "best_params = grid_search.best_params_\n",
+    "print(\"Meilleurs hyperparamètres : \", best_params)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "03e1ee55",
+   "metadata": {},
+   "source": [
+    "## Exercice 2 : Analyse approfondie"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "86594aca",
+   "metadata": {},
+   "source": [
+    "**Contexte : Vous êtes data scientist dans une banque. Le coût d'un faux négatif \n",
+    "(prêter à quelqu'un qui va faire défaut) est estimé à 10 000€. Le coût d'un \n",
+    "faux positif (refuser un bon client) est de 500€ (perte d'opportunité).**\n",
+    "\n",
+    "**Objectifs :**\n",
+    "1. Calculer le coût total pour différents seuils de classification (0.3, 0.5, 0.7)\n",
+    "2. Déterminer le seuil optimal qui minimise le coût total\n",
+    "3. Produire un rapport de recommandation\n",
+    "\n",
+    "Formule :\n",
+    "Coût total = (FN × 10000) + (FP × 500)\n",
+    "\n",
+    "Consignes :\n",
+    "- Utilisez y_pred_proba_baseline pour tester différents seuils\n",
+    "- Créez une fonction pour calculer le coût\n",
+    "- Visualisez le coût en fonction du seuil\n",
+    "- Recommandez le meilleur seuil avec justification"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 96,
+   "id": "65693a22",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0:\ttest: 0.8746563\tbest: 0.8746563 (0)\ttotal: 24.1ms\tremaining: 12s\n",
+      "100:\ttest: 0.9207882\tbest: 0.9207893 (99)\ttotal: 1.44s\tremaining: 5.68s\n",
+      "200:\ttest: 0.9248347\tbest: 0.9248575 (199)\ttotal: 3.1s\tremaining: 4.61s\n",
+      "Stopped by overfitting detector  (50 iterations wait)\n",
+      "\n",
+      "bestTest = 0.9249125201\n",
+      "bestIteration = 227\n",
+      "\n",
+      "Shrink model to first 228 iterations.\n",
+      "\n",
+      "=== Performance du modèle baseline ===\n",
+      "\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.89      0.94      0.91      4531\n",
+      "           1       0.78      0.65      0.71      1502\n",
+      "\n",
+      "    accuracy                           0.87      6033\n",
+      "   macro avg       0.83      0.79      0.81      6033\n",
+      "weighted avg       0.86      0.87      0.86      6033\n",
+      "\n",
+      "\n",
+      "AUC-ROC : 0.9249\n"
+     ]
+    }
+   ],
+   "source": [
+    "best_catboost = CatBoostClassifier(\n",
+    "    iterations=500,\n",
+    "    learning_rate=0.1,\n",
+    "    depth=6,\n",
+    "    loss_function=\"Logloss\",\n",
+    "    eval_metric=\"AUC\",\n",
+    "    random_seed=42,\n",
+    "    verbose=100,\n",
+    "    early_stopping_rounds=50,\n",
+    ")\n",
+    "\n",
+    "# Entrainement\n",
+    "best_catboost.fit(train_pool, eval_set=test_pool, plot=False)\n",
+    "\n",
+    "# Prédictions\n",
+    "y_pred_baseline = best_catboost.predict(X_test)\n",
+    "y_pred_proba_baseline = best_catboost.predict_proba(X_test)[:, 1]\n",
+    "\n",
+    "# Évaluation\n",
+    "print(\"\\n=== Performance du modèle baseline ===\\n\")\n",
+    "print(classification_report(y_test, y_pred_baseline))\n",
+    "print(f\"\\nAUC-ROC : {roc_auc_score(y_test, y_pred_proba_baseline):.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "af1cb8af",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[4254  277]\n",
+      " [ 529  973]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Matrice de confusion\n",
+    "cm = confusion_matrix(y_test, y_pred_baseline)\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "sns.heatmap(cm, annot=True, fmt=\"d\", cmap=\"Blues\")\n",
+    "plt.title(\"Matrice de confusion\")\n",
+    "plt.ylabel(\"Valeur réelle\")\n",
+    "plt.xlabel(\"Valeur prédite\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8fbbf84b",
+   "metadata": {},
+   "source": [
+    "## Exercice 3 : Prédiction du montant de défaut (régression)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0ba92dd4",
+   "metadata": {},
+   "source": [
+    "**Objectif : Transformer le problème en régression pour prédire le montant \n",
+    "du défaut potentiel (et pas seulement si/non).**\n",
+    "\n",
+    "Étapes :\n",
+    "1. Créer une nouvelle variable cible : 'montant_defaut' \n",
+    "   - Si défaut = 0 : montant_defaut = 0\n",
+    "   - Si défaut = 1 : montant_defaut = montant_credit * ratio_defaut_simule\n",
+    "   \n",
+    "2. Entraîner un CatBoostRegressor\n",
+    "\n",
+    "3. Évaluer avec MAE, RMSE, R²\n",
+    "\n",
+    "4. Comparer l'importance des features avec le modèle de classification"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e74f071f",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a54f79a5",
+   "metadata": {},
+   "source": [
+    "# Partie 4 : Techniques avancées (bonus)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8849fdbc",
+   "metadata": {},
+   "source": [
+    "## Gestion du déséquilibre des classes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 99,
+   "id": "c9bbd9a1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<catboost.core.CatBoostClassifier at 0x119cb3a40>"
+      ]
+     },
+     "execution_count": 99,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Option 1 : Pondération automatique\n",
+    "model_weighted = CatBoostClassifier(\n",
+    "    iterations=500,\n",
+    "    learning_rate=0.1,\n",
+    "    depth=6,\n",
+    "    random_seed=42,\n",
+    "    verbose=0,\n",
+    "    auto_class_weights='Balanced',\n",
+    "    eval_metric='AUC'\n",
+    ")\n",
+    "\n",
+    "model_weighted.fit(train_pool, eval_set=test_pool)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 100,
+   "id": "9f10f1a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_pred_weighted = model_weighted.predict(X_test)\n",
+    "y_pred_proba_weighted = model_weighted.predict_proba(X_test)[:, 1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 101,
+   "id": "89f57e71",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Performance avec class weights :\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.94      0.83      0.88      4531\n",
+      "           1       0.63      0.84      0.72      1502\n",
+      "\n",
+      "    accuracy                           0.84      6033\n",
+      "   macro avg       0.78      0.84      0.80      6033\n",
+      "weighted avg       0.86      0.84      0.84      6033\n",
+      "\n",
+      "AUC-ROC : 0.9253\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Performance avec class weights :\")\n",
+    "print(classification_report(y_test, y_pred_weighted))\n",
+    "print(f\"AUC-ROC : {roc_auc_score(y_test, y_pred_proba_weighted):.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 102,
+   "id": "dd70cf9c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Scale pos weight calculé : 3.02\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<catboost.core.CatBoostClassifier at 0x11ca39ac0>"
+      ]
+     },
+     "execution_count": 102,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Option 2 : scale_pos_weight (pour déséquilibre important)\n",
+    "scale = len(y_train[y_train == 0]) / len(y_train[y_train == 1])\n",
+    "print(f\"\\nScale pos weight calculé : {scale:.2f}\")\n",
+    "\n",
+    "model_scaled = CatBoostClassifier(\n",
+    "    iterations=500,\n",
+    "    learning_rate=0.1,\n",
+    "    depth=6,\n",
+    "    random_seed=42,\n",
+    "    verbose=0,\n",
+    "    scale_pos_weight=scale,\n",
+    "    eval_metric='AUC'\n",
+    ")\n",
+    "\n",
+    "model_scaled.fit(train_pool, eval_set=test_pool)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "81526670",
+   "metadata": {},
+   "source": [
+    "## SHAP Values pour l'interprétabilité"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 103,
+   "id": "c9a3f8ae",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# CatBoost a un support natif pour SHAP\n",
+    "shap_values = model_baseline.get_feature_importance(\n",
+    "    train_pool,\n",
+    "    type='ShapValues'\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 104,
+   "id": "8c29907f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Shape des SHAP values : (24129, 15)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Les shap_values ont la forme (n_samples, n_features + 1)\n",
+    "# La dernière colonne est la valeur de base\n",
+    "\n",
+    "print(f\"Shape des SHAP values : {shap_values.shape}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 105,
+   "id": "d638560d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Importance SHAP moyenne :\n",
+      "           feature  shap_importance\n",
+      "7     relationship         0.833481\n",
+      "0              age         0.763489\n",
+      "10    capital_gain         0.484163\n",
+      "5   marital_status         0.426608\n",
+      "6       occupation         0.415689\n",
+      "12  hours_per_week         0.378604\n",
+      "3        education         0.281114\n",
+      "4    education_num         0.271613\n",
+      "9              sex         0.144403\n",
+      "11    capital_loss         0.133650\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Importance SHAP moyenne\n",
+    "shap_importance = np.abs(shap_values[:, :-1]).mean(axis=0)\n",
+    "shap_df = pd.DataFrame({\n",
+    "    'feature': X_train.columns,\n",
+    "    'shap_importance': shap_importance\n",
+    "}).sort_values('shap_importance', ascending=False)\n",
+    "\n",
+    "print(\"\\nImportance SHAP moyenne :\")\n",
+    "print(shap_df.head(10))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 106,
+   "id": "79488875",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Visualisation\n",
+    "plt.figure(figsize=(10, 8))\n",
+    "plt.barh(shap_df['feature'][:15], shap_df['shap_importance'][:15])\n",
+    "plt.xlabel('|SHAP value| moyen')\n",
+    "plt.title('Importance des features (SHAP)')\n",
+    "plt.gca().invert_yaxis()\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "studies",
+   "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.13.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/pyproject.toml b/pyproject.toml
index f812b91..e2c48df 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -5,6 +5,7 @@ description = "A curated collection of mathematics and data science projects dev
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
+    "catboost>=1.2.8",
     "imblearn>=0.0",
     "ipykernel>=6.29.5",
     "keras>=3.11.3",
diff --git a/uv.lock b/uv.lock
index cac13a1..d95319f 100644
--- a/uv.lock
+++ b/uv.lock
@@ -72,6 +72,31 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/94/fe/3aed5d0be4d404d12d36ab97e2f1791424d9ca39c2f754a6285d59a3b01d/beautifulsoup4-4.14.2-py3-none-any.whl", hash = "sha256:5ef6fa3a8cbece8488d66985560f97ed091e22bbc4e9c2338508a9d5de6d4515", size = 106392, upload-time = "2025-09-29T10:05:43.771Z" },
 ]
 
+[[package]]
+name = "catboost"
+version = "1.2.8"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "graphviz" },
+    { name = "matplotlib" },
+    { name = "numpy" },
+    { name = "pandas" },
+    { name = "plotly" },
+    { name = "scipy" },
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0c/ee/8f146ee0b5c6321d4699edd90a036fe68b2c5fad910fa2b369f14043c192/catboost-1.2.8.tar.gz", hash = "sha256:4a1d1aca5caecd919ec476f72c7abd98a704c24fda35506d4d7d71f77f07cb29", size = 58080776, upload-time = "2025-04-13T10:14:19.057Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/88/ebc0a95d92b9090e6b17a55ceda950d3cbd1ee545286798e8355590501a6/catboost-1.2.8-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:29f93b4a89ef807e74c16882623c89f1fb781346e1f4fafb29b6949ab4603e14", size = 27843240, upload-time = "2025-04-13T10:12:52.6Z" },
+    { url = "https://files.pythonhosted.org/packages/be/d1/06142eecc68405b1ded7691fedc6639c6ae35b1d1d9e322ed45f6ee1ded3/catboost-1.2.8-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:932542f8b416b43ee07f912a9a964635ccca7397da16b61475c76ae4ae96a1df", size = 98726147, upload-time = "2025-04-13T10:12:57.038Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/39/22643f61f2b6526f5fe5985b4e3ea1596fc5c8dbe635cd88e8ebbd2dfcb7/catboost-1.2.8-cp312-cp312-manylinux2014_x86_64.whl", hash = "sha256:35a70d32809a21d06dc0ba161bafdd0450ea71fe176a12ee85d7535883b22624", size = 99167436, upload-time = "2025-04-13T10:13:05.31Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/9e/feae59f6226f742fa3fa30ae126e0941f443d460e7c0fa9f79cdf3ee488f/catboost-1.2.8-cp312-cp312-win_amd64.whl", hash = "sha256:319086796084fee5e4254300dc81aad1ae0b201cb576a9e87e6c7d030483be7e", size = 102425363, upload-time = "2025-04-13T10:13:10.826Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/5a/077dd8f35de4f10c934da703bd186b2e85223372886d285edae8f42f75d1/catboost-1.2.8-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:777987e1483824f93b9cb904860ef46dfb3cd184f879e47413bc7163b9514830", size = 27789594, upload-time = "2025-04-13T10:13:15.704Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/73/06959c42d797c3e207c352f6050180b2217c6709d261e5f4a3d77dcdd067/catboost-1.2.8-cp313-cp313-manylinux2014_aarch64.whl", hash = "sha256:a72681c50cbfe2fa4a6f85934bc707e0f7ff50a10a51801317418adf09d57cef", size = 98718946, upload-time = "2025-04-13T10:13:19.714Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/4b/d04e067df4401902cb2249df241bc1502bf90e990c6a3da5f82ba7de60fa/catboost-1.2.8-cp313-cp313-manylinux2014_x86_64.whl", hash = "sha256:8d2b58781c7ff2f974bde857da0d10d867366979193a4e7052746330a8b76b55", size = 99162049, upload-time = "2025-04-13T10:13:26.249Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/bc/35f50d1c6d898eb05d3ad3001b479cc6a837f6829a0ed68e6993e31da16e/catboost-1.2.8-cp313-cp313-win_amd64.whl", hash = "sha256:9c04ab1df71501d75cad80757f33d60bab2704b2450401d2c8cf3f3bcb6bd9f8", size = 102416981, upload-time = "2025-04-13T10:13:31.721Z" },
+]
+
 [[package]]
 name = "certifi"
 version = "2025.8.3"
@@ -358,6 +383,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a3/de/c648ef6835192e6e2cc03f40b19eeda4382c49b5bafb43d88b931c4c74ac/google_pasta-0.2.0-py3-none-any.whl", hash = "sha256:b32482794a366b5366a32c92a9a9201b107821889935a02b3e51f6b432ea84ed", size = 57471, upload-time = "2020-03-13T18:57:48.872Z" },
 ]
 
+[[package]]
+name = "graphviz"
+version = "0.21"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f8/b3/3ac91e9be6b761a4b30d66ff165e54439dcd48b83f4e20d644867215f6ca/graphviz-0.21.tar.gz", hash = "sha256:20743e7183be82aaaa8ad6c93f8893c923bd6658a04c32ee115edb3c8a835f78", size = 200434, upload-time = "2025-06-15T09:35:05.824Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/91/4c/e0ce1ef95d4000ebc1c11801f9b944fa5910ecc15b5e351865763d8657f8/graphviz-0.21-py3-none-any.whl", hash = "sha256:54f33de9f4f911d7e84e4191749cac8cc5653f815b06738c54db9a15ab8b1e42", size = 47300, upload-time = "2025-06-15T09:35:04.433Z" },
+]
+
 [[package]]
 name = "grpcio"
 version = "1.74.0"
@@ -1546,6 +1580,7 @@ name = "studies"
 version = "0.1.0"
 source = { virtual = "." }
 dependencies = [
+    { name = "catboost" },
     { name = "imblearn" },
     { name = "ipykernel" },
     { name = "keras" },
@@ -1571,6 +1606,7 @@ dev = [
 
 [package.metadata]
 requires-dist = [
+    { name = "catboost", specifier = ">=1.2.8" },
     { name = "imblearn", specifier = ">=0.0" },
     { name = "ipykernel", specifier = ">=6.29.5" },
     { name = "keras", specifier = ">=3.11.3" },