diff --git a/model_training/CNN/CNN_crossVal_EarlyFusion_Test_Eval.ipynb b/model_training/CNN/CNN_crossVal_EarlyFusion_Test_Eval.ipynb
new file mode 100644
index 0000000..4ef2cb8
--- /dev/null
+++ b/model_training/CNN/CNN_crossVal_EarlyFusion_Test_Eval.ipynb
@@ -0,0 +1,529 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "47f6de7b",
+   "metadata": {},
+   "source": [
+    "Bibliotheken importieren"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "99294260",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd \n",
+    "import numpy as np \n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns \n",
+    "import random \n",
+    "import joblib \n",
+    "from pathlib import Path \n",
+    "\n",
+    "from sklearn.model_selection import GroupKFold, GroupShuffleSplit\n",
+    "from sklearn.preprocessing import StandardScaler \n",
+    "from sklearn.metrics import ( \n",
+    "    precision_score, recall_score,\n",
+    "    confusion_matrix, roc_curve, auc, \n",
+    "    precision_recall_curve, f1_score, \n",
+    "    balanced_accuracy_score, accuracy_score\n",
+    ") \n",
+    "\n",
+    "import tensorflow as tf \n",
+    "from tensorflow.keras import Input, layers, models, regularizers"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "52b4ca8c",
+   "metadata": {},
+   "source": [
+    "Seed festlegen"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6e49d281",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "SEED = 42 \n",
+    "np.random.seed(SEED) \n",
+    "tf.random.set_seed(SEED) \n",
+    "random.seed(SEED)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae1a715f",
+   "metadata": {},
+   "source": [
+    "Daten laden"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "870f01c3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_path = Path(r\"~/data-paulusjafahrsimulator-gpu/new_datasets/50s_25Hz_dataset.parquet\") \n",
+    "\n",
+    "data = pd.read_parquet(path=data_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bedbc23b",
+   "metadata": {},
+   "source": [
+    "Labels erstellen"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "38848515",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "low_all = data[((data[\"PHASE\"] == \"baseline\") | \n",
+    "                ((data[\"STUDY\"] == \"n-back\") & (data[\"PHASE\"] != \"baseline\") & (data[\"LEVEL\"].isin([1,4]))))].copy() \n",
+    "\n",
+    "high_all = pd.concat([ \n",
+    "    data[(data[\"STUDY\"]==\"n-back\") & (data[\"LEVEL\"].isin([2,3,5,6])) & (data[\"PHASE\"].isin([\"train\",\"test\"]))], \n",
+    "    data[(data[\"STUDY\"]==\"k-drive\") & (data[\"PHASE\"]!=\"baseline\")] \n",
+    "]).copy() \n",
+    "\n",
+    "low_all[\"label\"] = 0 \n",
+    "high_all[\"label\"] = 1 \n",
+    "data = pd.concat([low_all, high_all], ignore_index=True).drop_duplicates() "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0b282acf",
+   "metadata": {},
+   "source": [
+    "Features und Labels"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5edb00a0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Face AUs\n",
+    "au_columns = [col for col in data.columns if \"face\" in col.lower()] \n",
+    "\n",
+    "#Eye Features\n",
+    "eye_columns = [ \n",
+    "    'Fix_count_short_66_150', \n",
+    "    'Fix_count_medium_300_500', \n",
+    "    'Fix_count_long_gt_1000', \n",
+    "    'Fix_count_100', \n",
+    "    'Fix_mean_duration', \n",
+    "    'Fix_median_duration', \n",
+    "    'Sac_count', \n",
+    "    'Sac_mean_amp', \n",
+    "    'Sac_mean_dur', \n",
+    "    'Sac_median_dur', \n",
+    "    'Blink_count', \n",
+    "    'Blink_mean_dur', \n",
+    "    'Blink_median_dur', \n",
+    "    'Pupil_mean', \n",
+    "    'Pupil_IPA' \n",
+    "]\n",
+    "\n",
+    "#Early Fusion\n",
+    "feature_columns = au_columns + eye_columns\n",
+    "\n",
+    "#NaNs entfernen \n",
+    "data = data.dropna(subset=feature_columns + [\"label\"])\n",
+    "\n",
+    "X = data[feature_columns].values[..., np.newaxis] \n",
+    "y = data[\"label\"].values \n",
+    "\n",
+    "groups = data[\"subjectID\"].values\n",
+    "print(data.columns.tolist())\n",
+    "\n",
+    "print(\"Gefundene FACE_AU-Spalten:\", au_columns)\n",
+    "print(\"Gefundene Eye Features:\" , eye_columns)\n",
+    "\n",
+    "print(\"Anzahl FACE_AUs:\", len(au_columns)) \n",
+    "print(\"Anzahl EYE Features:\", len(eye_columns)) \n",
+    "print(\"Gesamtzahl Features:\", len(feature_columns))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d8689679",
+   "metadata": {},
+   "source": [
+    "Train-Test-Split"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b5cf88c3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gss = GroupShuffleSplit(n_splits=1, test_size=0.2, random_state=42)\n",
+    "train_idx, test_idx = next(gss.split(X, y, groups))\n",
+    "\n",
+    "feature_columns_train, feature_columns_test = X[train_idx], X[test_idx]\n",
+    "y_train, y_test = y[train_idx], y[test_idx]\n",
+    "groups_train, groups_test = groups[train_idx], groups[test_idx]\n",
+    "\n",
+    "print(\"Train:\", len(y_train), \" | Test:\", len(y_test))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a539b83b",
+   "metadata": {},
+   "source": [
+    "CNN-Modell"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e4a7f496",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def build_model(input_shape, lr=1e-4): \n",
+    "    model = models.Sequential([ \n",
+    "        Input(shape=input_shape), \n",
+    "        layers.Conv1D(32, kernel_size=3, activation=\"relu\", kernel_regularizer=regularizers.l2(0.001)), \n",
+    "        layers.BatchNormalization(), \n",
+    "        layers.MaxPooling1D(pool_size=2),\n",
+    "\n",
+    "        layers.Conv1D(64, kernel_size=3, activation=\"relu\", kernel_regularizer=regularizers.l2(0.001)), \n",
+    "        layers.BatchNormalization(), \n",
+    "        layers.GlobalAveragePooling1D(), \n",
+    "        \n",
+    "        layers.Dense(32, activation=\"relu\", kernel_regularizer=regularizers.l2(0.001)), \n",
+    "        layers.Dropout(0.5), \n",
+    "        layers.Dense(1, activation=\"sigmoid\") \n",
+    "    ]) \n",
+    "    \n",
+    "    model.compile( \n",
+    "        optimizer=tf.keras.optimizers.Adam(learning_rate=lr), \n",
+    "        loss=\"binary_crossentropy\", \n",
+    "        metrics=[\"accuracy\", tf.keras.metrics.AUC(name=\"auc\")] \n",
+    "    ) \n",
+    "    return model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5905871b",
+   "metadata": {},
+   "source": [
+    "Cross-Validation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "90658000",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gkf = GroupKFold(n_splits=5) \n",
+    "cv_histories = [] \n",
+    "cv_results = [] \n",
+    "fold_subjects = []\n",
+    "all_conf_matrices = []\n",
+    "\n",
+    "for fold, (train_idx, val_idx) in enumerate(gkf.split(X, y, groups)):\n",
+    "    train_subjects = np.unique(groups[train_idx]) \n",
+    "    val_subjects = np.unique(groups[val_idx]) \n",
+    "    fold_subjects.append({\"Fold\": fold+1, \n",
+    "                          \"Train_Subjects\": train_subjects, \n",
+    "                          \"Val_Subjects\": val_subjects}) \n",
+    "    \n",
+    "    print(f\"\\n--- Fold {fold+1} ---\") \n",
+    "    print(\"Train-Subjects:\", train_subjects) \n",
+    "    print(\"Val-Subjects:\", val_subjects) \n",
+    "\n",
+    "    #Split\n",
+    "    X_train, X_val = X[train_idx], X[val_idx] \n",
+    "    y_train, y_val = y[train_idx], y[val_idx] # Normalisierung pro Fold \n",
+    "\n",
+    "    #Normalisierung pro Fold\n",
+    "    scaler = StandardScaler() \n",
+    "    X_train = scaler.fit_transform(X_train.reshape(len(X_train), -1)).reshape(X_train.shape) \n",
+    "    X_val = scaler.transform(X_val.reshape(len(X_val), -1)).reshape(X_val.shape) \n",
+    "\n",
+    "    # Plausibilitäts-Check \n",
+    "    print(\"Train Mittelwerte (erste 5 Features):\", X_train.mean(axis=0)[:5]) \n",
+    "    print(\"Train Std (erste 5 Features):\", X_train.std(axis=0)[:5]) \n",
+    "    print(\"Val Mittelwerte (erste 5 Features):\", X_val.mean(axis=0)[:5]) \n",
+    "    print(\"Val Std (erste 5 Features):\", X_val.std(axis=0)[:5]) \n",
+    "\n",
+    "    # Modell \n",
+    "    model = build_model(input_shape=(len(feature_columns_train),1), lr=1e-4) \n",
+    "    model.summary()  \n",
+    "\n",
+    "    callbacks = [ \n",
+    "        tf.keras.callbacks.EarlyStopping(monitor=\"val_loss\", patience=10, restore_best_weights=True), \n",
+    "        tf.keras.callbacks.ReduceLROnPlateau(monitor=\"val_loss\", factor=0.5, patience=5, min_lr=1e-6) \n",
+    "    ] \n",
+    "\n",
+    "    history = model.fit( \n",
+    "        X_train, y_train, \n",
+    "        validation_data=(X_val, y_val), \n",
+    "        epochs=100, \n",
+    "        batch_size=16, \n",
+    "        callbacks=callbacks, \n",
+    "        verbose=0 \n",
+    "    ) \n",
+    "\n",
+    "    cv_histories.append(history.history) \n",
+    "    scores = model.evaluate(X_val, y_val, verbose=0) \n",
+    "    cv_results.append(scores) \n",
+    "    print(f\"Fold {fold+1} - Val Loss: {scores[0]:.4f}, Val Acc: {scores[1]:.4f}, Val AUC: {scores[2]:.4f}\")\n",
+    "\n",
+    "\n",
+    "    #Konfusionsmatrix \n",
+    "    y_pred = (model.predict(X_val) > 0.5).astype(int) \n",
+    "    cm = confusion_matrix(y_val, y_pred) \n",
+    "    all_conf_matrices.append(cm) \n",
+    "    \n",
+    "    print(f\"Konfusionsmatrix Fold {fold+1}:\\n{cm}\\n\") \n",
+    "    \n",
+    "# Aggregierte Matrix \n",
+    "agg_cm = sum(all_conf_matrices) \n",
+    "print(\"Aggregierte Konfusionsmatrix über alle Folds:\") \n",
+    "print(agg_cm)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d10b7e78",
+   "metadata": {},
+   "source": [
+    "Results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9aeba7f4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#results\n",
+    "cv_results = np.array(cv_results) \n",
+    "print(\"\\n=== Cross-Validation Ergebnisse ===\") \n",
+    "print(f\"Durchschnittlicher Val-Loss: {cv_results[:,0].mean():.4f}\") \n",
+    "print(f\"Durchschnittliche Val-Accuracy: {cv_results[:,1].mean():.4f}\") \n",
+    "print(f\"Durchschnittliche Val-AUC: {cv_results[:,2].mean():.4f}\")\n",
+    "\n",
+    "#Ergebnis-Tabelle erstellen\n",
+    "results_table = pd.DataFrame({ \n",
+    "    \"Fold\": np.arange(1, len(cv_results)+1), \n",
+    "    \"Val Loss\": cv_results[:,0], \n",
+    "    \"Val Accuracy\": cv_results[:,1], \n",
+    "    \"Val AUC\": cv_results[:,2] }) \n",
+    "\n",
+    "# Durchschnittszeile hinzufügen \n",
+    "avg_row = pd.DataFrame({ \n",
+    "    \"Fold\": [\"Ø\"], \n",
+    "    \"Val Loss\": [cv_results[:,0].mean()], \n",
+    "    \"Val Accuracy\": [cv_results[:,1].mean()], \n",
+    "    \"Val AUC\": [cv_results[:,2].mean()] \n",
+    "}) \n",
+    "\n",
+    "results_table = pd.concat([results_table, avg_row], ignore_index=True) \n",
+    "\n",
+    "print(\"\\n=== Ergebnis-Tabelle ===\") \n",
+    "print(results_table) \n",
+    "\n",
+    "#Tabelle speichern \n",
+    "results_table.to_csv(\"cnn_crossVal_results.csv\", index=False) \n",
+    "print(\"Ergebnisse gespeichert als 'cnn_crossVal_results.csv'\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fae5df7a",
+   "metadata": {},
+   "source": [
+    "Finales Modell trainieren"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5b3eab61",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scaler_final = StandardScaler() \n",
+    "X_scaled = scaler_final.fit_transform(feature_columns_train.reshape(len(feature_columns_train), -1)).reshape(feature_columns_train.shape) \n",
+    "\n",
+    "final_model = build_model(input_shape=(len(feature_columns_train),1), lr=1e-4) \n",
+    "final_model.summary() \n",
+    "\n",
+    "final_model.fit( \n",
+    "    X_scaled, y_train, \n",
+    "    epochs=150, \n",
+    "    batch_size=16, \n",
+    "    verbose=1 \n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7c7f9cc4",
+   "metadata": {},
+   "source": [
+    "Speichern des Modells"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2d3af5be",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# final_model.save(\"cnn_crossVal_EarlyFusion_V2.keras\") \n",
+    "# joblib.dump(scaler_final, \"scaler_crossVal_EarlyFusion_V2.joblib\") \n",
+    "\n",
+    "# print(\"Finales Modell und Scaler gespeichert als 'cnn_crossVal_EarlyFusion_V2.keras' und 'scaler_crossVal_EarlyFusion_V2.joblib'\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c11891e0",
+   "metadata": {},
+   "source": [
+    "Plots"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9f6a8584",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#plots\n",
+    "def plot_cv_histories(cv_histories, metric): \n",
+    "    plt.figure(figsize=(10,6)) \n",
+    "    \n",
+    "    for i, hist in enumerate(cv_histories): \n",
+    "        plt.plot(hist[metric], label=f\"Fold {i+1} Train\", alpha=0.7) \n",
+    "        plt.plot(hist[f\"val_{metric}\"], label=f\"Fold {i+1} Val\", linestyle=\"--\", alpha=0.7) \n",
+    "    plt.xlabel(\"Epochs\") \n",
+    "    plt.ylabel(metric.capitalize()) \n",
+    "    plt.title(f\"Cross-Validation {metric.capitalize()} Verläufe\") \n",
+    "    plt.legend() \n",
+    "    plt.grid(True) \n",
+    "    plt.show()\n",
+    "    \n",
+    "plot_cv_histories(cv_histories, \"loss\") \n",
+    "plot_cv_histories(cv_histories, \"accuracy\") \n",
+    "plot_cv_histories(cv_histories, \"auc\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4aebe6c6",
+   "metadata": {},
+   "source": [
+    "Test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0d34d6b7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Preprocessing Testdaten \n",
+    "X_test_scaled = scaler.transform( \n",
+    "    feature_columns_test.reshape(len(feature_columns_test), -1) \n",
+    ").reshape(feature_columns_test.shape) \n",
+    "\n",
+    "# Vorhersagen \n",
+    "y_prob_test = model.predict(X_test_scaled).flatten() \n",
+    "y_pred_test = (y_prob_test > 0.5).astype(int) \n",
+    "\n",
+    "# Konfusionsmatrix \n",
+    "cm_test = confusion_matrix(y_test, y_pred_test) \n",
+    "\n",
+    "plt.figure(figsize=(6,5)) \n",
+    "sns.heatmap(cm_test, annot=True, fmt=\"d\", cmap=\"Greens\", \n",
+    "            xticklabels=[\"Pred 0\", \"Pred 1\"], \n",
+    "            yticklabels=[\"True 0\", \"True 1\"]) \n",
+    "plt.title(\"Konfusionsmatrix - Testdaten\") \n",
+    "plt.show() \n",
+    "\n",
+    "# ROC \n",
+    "fpr, tpr, _ = roc_curve(y_test, y_prob_test) \n",
+    "roc_auc = auc(fpr, tpr) \n",
+    "\n",
+    "plt.figure(figsize=(7,6)) \n",
+    "plt.plot(fpr, tpr, label=f\"AUC = {roc_auc:.3f}\") \n",
+    "plt.plot([0,1], [0,1], \"k--\") \n",
+    "plt.title(\"ROC - Testdaten\") \n",
+    "plt.legend() \n",
+    "plt.grid(True) \n",
+    "plt.show() \n",
+    "\n",
+    "# Precision-Recall \n",
+    "precision, recall, _ = precision_recall_curve(y_test, y_prob_test) \n",
+    "plt.figure(figsize=(7,6)) \n",
+    "plt.plot(recall, precision) \n",
+    "plt.title(\"Precision-Recall - Testdaten\") \n",
+    "plt.grid(True) \n",
+    "plt.show() \n",
+    "\n",
+    "# Metriken \n",
+    "print(\"Accuracy:\", accuracy_score(y_test, y_pred_test))\n",
+    "print(\"F1-Score:\", f1_score(y_test, y_pred_test)) \n",
+    "print(\"Balanced Accuracy:\", balanced_accuracy_score(y_test, y_pred_test)) \n",
+    "print(\"Precision:\", precision_score(y_test, y_pred_test)) \n",
+    "print(\"Recall:\", recall_score(y_test, y_pred_test)) \n",
+    "print(\"AUC:\", roc_auc)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.12.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/model_training/CNN/CNN_crossVal_HybridFusion_Test_Eval.ipynb b/model_training/CNN/CNN_crossVal_HybridFusion_Test_Eval.ipynb
index 75dd894..07a7964 100644
--- a/model_training/CNN/CNN_crossVal_HybridFusion_Test_Eval.ipynb
+++ b/model_training/CNN/CNN_crossVal_HybridFusion_Test_Eval.ipynb
@@ -10,23 +10,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "530e70af",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2026-02-24 16:57:49.034186: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
-      "2026-02-24 16:57:49.047136: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
-      "2026-02-24 16:57:49.050974: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
-      "2026-02-24 16:57:49.062835: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
-      "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
-      "2026-02-24 16:57:49.832762: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import pandas as pd \n",
     "import numpy as np \n",
@@ -36,13 +23,13 @@
     "import joblib \n",
     "from pathlib import Path \n",
     "\n",
-    "from sklearn.model_selection import GroupKFold, train_test_split \n",
+    "from sklearn.model_selection import GroupKFold, GroupShuffleSplit \n",
     "from sklearn.preprocessing import StandardScaler \n",
     "from sklearn.metrics import ( \n",
     "    precision_score, recall_score,\n",
     "    confusion_matrix, roc_curve, auc, \n",
     "    precision_recall_curve, f1_score, \n",
-    "    balanced_accuracy_score \n",
+    "    balanced_accuracy_score, accuracy_score\n",
     ") \n",
     "\n",
     "import tensorflow as tf \n",
@@ -59,7 +46,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "67aaf56e",
    "metadata": {},
    "outputs": [],
@@ -80,7 +67,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "73a34b69",
    "metadata": {},
    "outputs": [],
@@ -99,7 +86,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "id": "a5ad3126",
    "metadata": {},
    "outputs": [],
@@ -134,7 +121,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "id": "5f10e6ca",
    "metadata": {},
    "outputs": [],
@@ -169,25 +156,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "id": "52d3b7cf",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Train: 6377  | Test: 1595\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "X_au_train, X_au_test, X_eye_train, X_eye_test, y_train, y_test, groups_train, groups_test = train_test_split( \n",
-    "    X_au, X_eye, y, \n",
-    "    groups, test_size=0.2, \n",
-    "    random_state=42, \n",
-    "    stratify=y \n",
-    ") \n",
+    "gss = GroupShuffleSplit(n_splits=1, test_size=0.2, random_state=42)\n",
+    "train_idx, test_idx = next(gss.split(X_au, y, groups))\n",
+    "\n",
+    "X_au_train, X_au_test = X_au[train_idx], X_au[test_idx]\n",
+    "X_eye_train, X_eye_test = X_eye[train_idx], X_eye[test_idx]\n",
+    "y_train, y_test = y[train_idx], y[test_idx]\n",
+    "groups_train, groups_test = groups[train_idx], groups[test_idx]\n",
     "\n",
     "print(\"Train:\", len(y_train), \" | Test:\", len(y_test))"
    ]
@@ -202,7 +182,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "id": "41cc1b30",
    "metadata": {},
    "outputs": [],
@@ -246,151 +226,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "id": "9c390b46",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "===== FOLD 1 =====\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
-      "I0000 00:00:1771948671.077495  347703 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
-      "I0000 00:00:1771948671.117462  347703 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
-      "I0000 00:00:1771948671.119081  347703 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
-      "I0000 00:00:1771948671.125047  347703 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
-      "I0000 00:00:1771948671.126507  347703 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
-      "I0000 00:00:1771948671.127885  347703 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
-      "I0000 00:00:1771948671.321528  347703 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
-      "I0000 00:00:1771948671.323000  347703 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
-      "2026-02-24 16:57:51.324225: W tensorflow/core/common_runtime/gpu/gpu_bfc_allocator.cc:47] Overriding orig_value setting because the TF_FORCE_GPU_ALLOW_GROWTH environment variable is set. Original config value was 0.\n",
-      "I0000 00:00:1771948671.324317  347703 cuda_executor.cc:1015] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
-      "2026-02-24 16:57:51.325558: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2021] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 35614 MB memory:  -> device: 0, name: NVIDIA A100 80GB PCIe MIG 3g.40gb, pci bus id: 0000:1e:00.0, compute capability: 8.0\n",
-      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
-      "I0000 00:00:1771948673.622665  347894 service.cc:146] XLA service 0x7fcbc40111e0 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n",
-      "I0000 00:00:1771948673.622720  347894 service.cc:154]   StreamExecutor device (0): NVIDIA A100 80GB PCIe MIG 3g.40gb, Compute Capability 8.0\n",
-      "2026-02-24 16:57:53.667316: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:268] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n",
-      "2026-02-24 16:57:53.897373: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:531] Loaded cuDNN version 8907\n",
-      "I0000 00:00:1771948676.141382  347894 device_compiler.h:188] Compiled cluster using XLA!  This line is logged at most once for the lifetime of the process.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Val Loss=0.0339 | Val Acc=0.9836 | Val AUC=0.9994\n",
-      "\u001b[1m41/41\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 7ms/step \n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAe4AAAHBCAYAAACv7Vi1AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAPeJJREFUeJzt3XtclHX6//H3yGEEROQ8UIZYZLnoRliktqHhIUtd1y0ty2zVVtMsUtTILXG3oNxSKjd30zykX7WDqe2WplaysWoh6XrosB1QY2PCA6IoDgj3749+zjaCOoODeNvruY/78Wg+92c+c80028V1zWfusRiGYQgAAJhCs6YOAAAAuI/EDQCAiZC4AQAwERI3AAAmQuIGAMBESNwAAJgIiRsAABMhcQMAYCIkbgAATITEfRFZsGCBLBaLtmzZ4jK+f/9+derUSS1atNC6desa5bGrqqo0evRoxcTEyMfHR9dcc43XH+O+++5TmzZtvL7uherYsWPKysrShg0bPLpfVlaWLBZL4wR1Fhs2bJDFYqn3uP322xu0ljvP3933Rn5+vkaOHKnk5GRZrVZZLBbt3r3bo7iApubb1AGgcRUXF6tnz5764YcftH79et1www2N8jizZ8/W3/72N7344otKTk5WixYtvP4Yjz/+uB5++GGvr3uhOnbsmKZNmyZJ6tatm9v3GzlypG655ZZGiso92dnZ6t69u8tYeHh4E0XzP++//77Wr1+vpKQktWzZ0uM/ioALAYn7IvbVV1+pR48eqq6uVl5enjp06NBoj7Vz504FBATowQcfbLTHuPzyyxtt7YvBsWPHFBgYqEsvvVSXXnppk8aSkJDQaH8knovHH39cU6dOlSQ9++yzJG6YEq3yi9S2bdt04403ytfXV/n5+XWSdn5+vtLS0hQcHKzAwEB16dJF77zzjsuck633Dz/8UA888IAiIiIUHh6ugQMH6vvvv3fOs1gsmjt3riorK51t0QULFmj37t3Ofz6VxWJRVlaW8/a+ffv0+9//Xq1bt5bValVkZKS6du2q9evXO+fU1w49fvy4MjMzFR8fL39/f11yySUaO3asDh065DKvTZs26tu3r9asWaNrr71WAQEBuuqqqzRv3jyXeceOHVNGRobi4+PVvHlzhYWFqVOnTlq6dKlLHC1atNAXX3yh3r17KygoSDExMXr66aclSZs3b9aNN96ooKAgXXnllVq4cKHLY+zbt09jxoxR+/bt1aJFC0VFRenmm2/WRx995Jyze/duRUZGSpKmTZvmfF3vu+8+Sf9rh3/66ae6/fbbFRoa6vzD5tRWeX5+vvz8/JSRkeESx8l/v6+88kqdfz+NzZ333+ksWLBA7dq1k9Vq1dVXX61XX33V7cdt1oz/5MH8eBdfhPLz89WtWzdFRUUpPz9fbdu2dTmfl5enm2++WeXl5XrllVe0dOlSBQcHq1+/fnrttdfqrDdy5Ej5+flpyZIlmj59ujZs2KB77rnHeX7Tpk269dZbFRAQoE2bNmnTpk267bbbPIp56NChWrlypZ544gmtXbtWc+fOVY8ePXTgwIHT3scwDA0YMEDPPvushg4dqnfeeUfjx4/XwoULdfPNN8vhcLjM//e//60JEybokUce0apVq9SxY0eNGDFC//znP51zxo8fr9mzZ+uhhx7SmjVrtGjRIt1xxx114qiurtbAgQN12223adWqVerTp48yMzP12GOPadiwYRo+fLhWrFihdu3a6b777lNhYaHzvgcPHpQkTZ06Ve+8847mz5+vtm3bqlu3bs4KMCYmRmvWrJEkjRgxwvm6Pv744y5xDBw4UFdccYXeeOMN/fWvf633dbrxxhv15JNP6rnnntPbb78tSdq1a5fGjh2re+65RyNGjDjTv5oGqa2t1YkTJ1yOkzx9//3UggUL9Lvf/U5XX321li9frj/84Q/605/+pA8++MDrzwG4YBm4aMyfP9+QZEgyQkJCjNLS0nrn3XDDDUZUVJRx5MgR59iJEyeMxMRE49JLLzVqa2td1hszZozL/adPn25IMkpKSpxjw4YNM4KCglzmFRUVGZKM+fPn14lBkjF16lTn7RYtWhjp6elnfH7Dhg0z4uLinLfXrFljSDKmT5/uMu+1114zJBkvv/yycywuLs5o3ry5sWfPHudYZWWlERYWZowaNco5lpiYaAwYMOCscUgyli9f7hyrrq42IiMjDUnGp59+6hw/cOCA4ePjY4wfP/606504ccKorq420tLSjN/85jfO8X379tV5nU6aOnWqIcl44oknTnvup2pra41bb73VaNWqlbFz506jffv2xlVXXWVUVFSc8bl66sMPP3S+B089vvrqK8Mw3H//nVzrww8/NAzDMGpqaozY2Fjj2muvdc4xDMPYvXu34efn5/LecMef//xnQ5JRVFR0Ts8ZON+ouC9C/fv3V3l5udLT01VTU+Ny7ujRo/r44491++23u2wg8/Hx0dChQ1VcXKwvv/yyzno/1bFjR0nSnj17vBbz9ddfrwULFujJJ5/U5s2bVV1dfdb7nKyyTraPT7rjjjsUFBSk999/32X8mmuu0WWXXea83bx5c1155ZUuz+P666/X6tWr9eijj2rDhg2qrKys97EtFotuvfVW521fX19dccUViomJUVJSknM8LCxMUVFRdV6rv/71r7r22mvVvHlz+fr6ys/PT++//74+//zzsz7vn/rtb3/r1jyLxaJXX31VwcHB6tSpk4qKivT6668rKCjojPczDOO0lfOZPPPMMyooKHA5Wrdu3aD330lffvmlvv/+ew0ZMsTlo4C4uDh16dLFrbiAiwGJ+yL0+OOP64knntCSJUt0zz33uCTvsrIyGYahmJiYOveLjY2VpDpt4VN3A1utVkk6bVJriNdee03Dhg3T3Llz1blzZ4WFhenee++V3W4/7X0OHDggX19f52fBJ1ksFtlstrM+D+nH5/LT5/HCCy9o8uTJWrlypbp3766wsDANGDBAX331lcv9AgMD1bx5c5cxf39/hYWF1XkMf39/HT9+3Hl7xowZeuCBB5SSkqLly5dr8+bNKigo0C233OLxa1rfv8fTCQ8PV//+/XX8+HHdcsstbm1WXLhwofz8/FwOd7Rt21adOnVyOaxWa4PefyedHLfZbHXO1TcGXKzYVX6ROrmhadq0aaqtrdX//d//ydfXV6GhoWrWrJlKSkrq3OfkhrOIiAivxHAysZ36WXN9/2GOiIhQbm6ucnNztXfvXr399tt69NFHVVpa6vys91Th4eE6ceKE9u3b55K8DcOQ3W7Xdddd53HMQUFBmjZtmqZNm6YffvjBWX3369dPX3zxhcfr1Wfx4sXq1q2bZs+e7TJ+5MgRj9fy5Pva69at0+zZs3X99ddrxYoVWr58+Vkr9n79+qmgoMDjuE7nXN5/J//wqu+PuTP9gQdcbKi4L2JZWVmaNm2aXn/9dQ0ZMkQnTpxQUFCQUlJS9NZbb7lUd7W1tVq8eLEuvfRSXXnllV55/OjoaDVv3lzbt293GV+1atUZ73fZZZfpwQcfVM+ePfXpp5+edl5aWpqkHxPhTy1fvlxHjx51nm+o6Oho3Xfffbrrrrv05Zdf6tixY+e03kkWi8XZtThp+/bt2rRpk8uYNzsbJSUluueee5SamqqNGzeqf//+GjFihIqKis54v/Dw8DqV87k4l/dfu3btFBMTo6VLl8owDOf4nj17tHHjxnOKCzATKu6L3BNPPKFmzZrp8ccfl2EYWrp0qXJyctSzZ091795dGRkZ8vf310svvaSdO3dq6dKlXrvqlsVi0T333KN58+bp8ssv1y9/+Ut98sknWrJkicu88vJyde/eXUOGDNFVV12l4OBgFRQUaM2aNRo4cOBp1+/Zs6d69+6tyZMn6/Dhw+ratau2b9+uqVOnKikpSUOHDvU45pSUFPXt21cdO3ZUaGioPv/8cy1atEidO3dWYGCgx+vVp2/fvvrTn/6kqVOnKjU1VV9++aX++Mc/Kj4+3uUz5ODgYMXFxWnVqlVKS0tTWFiYIiIiPL56XE1Nje666y5ZLBYtWbJEPj4+WrBgga655hoNHjxY+fn58vf398pzc0dD33/NmjXTn/70J40cOVK/+c1vdP/99+vQoUPKyspyu1W+b98+5eXlSZJ27NghSVq9erUiIyMVGRmp1NRU7zxJoDE15c44eNfJXeAFBQV1zj311FOGJGPgwIFGVVWV8dFHHxk333yzERQUZAQEBBg33HCD8fe//92t9U7d7WsY9e8qNwzDKC8vN0aOHGlER0cbQUFBRr9+/Yzdu3e77JY+fvy4MXr0aKNjx45Gy5YtjYCAAKNdu3bG1KlTjaNHj7o8xqk7hysrK43JkycbcXFxhp+fnxETE2M88MADRllZmcu8uLg447bbbqsTX2pqqpGamuq8/eijjxqdOnUyQkNDDavVarRt29Z45JFHjP3795/1uaamphq/+MUv6oyf+tgOh8PIyMgwLrnkEqN58+bGtddea6xcubLe57d+/XojKSnJsFqthiRj2LBhhmH8b+f4vn376jzeqbvKp0yZYjRr1sx4//33XeZt3LjR8PX1NR5++OE6azTUyffGG2+8ccZ57rz/6nufGYZhzJ0710hISDD8/f2NK6+80pg3b169r92Z4qvv+On7ALiQWQzjJz0nAABwQeMzbgAATITEDQCAiZC4AQAwERI3AAAmQuIGAMBESNwAAJgIiRsAABO5YK6c1v6xtU0dAtDoCqf1auoQgEYX4N5v0TRs7aQHvbZW5dZZXlvrfKLiBgDARC6YihsAgLOyUG+SuAEA5uGlH0EyM/50AQDARKi4AQDmQaucxA0AMBFa5bTKAQAwEypuAIB50ConcQMATIRWOa1yAADMhIobAGAetMqpuAEAJmKxeO/wQJs2bWSxWOocY8eOlSQZhqGsrCzFxsYqICBA3bp1065du1zWcDgcGjdunCIiIhQUFKT+/furuLjY45eAxA0AwFkUFBSopKTEeaxbt06SdMcdd0iSpk+frhkzZmjWrFkqKCiQzWZTz549deTIEeca6enpWrFihZYtW6b8/HxVVFSob9++qqmp8SgWEjcAwDwszbx3eCAyMlI2m815/OMf/9Dll1+u1NRUGYah3NxcTZkyRQMHDlRiYqIWLlyoY8eOacmSJZKk8vJyvfLKK3ruuefUo0cPJSUlafHixdqxY4fWr1/vUSwkbgCAeTRRq/ynqqqqtHjxYg0fPlwWi0VFRUWy2+3q1et/P9trtVqVmpqqjRs3SpIKCwtVXV3tMic2NlaJiYnOOe5icxoA4GfJ4XDI4XC4jFmtVlmt1jPeb+XKlTp06JDuu+8+SZLdbpckRUdHu8yLjo7Wnj17nHP8/f0VGhpaZ87J+7uLihsAYB5ebJXn5OQoJCTE5cjJyTlrCK+88or69Omj2NhY19BOqeINw6gzdip35pyKihsAYB5evABLZmamxo8f7zJ2tmp7z549Wr9+vd566y3nmM1mk/RjVR0TE+McLy0tdVbhNptNVVVVKisrc6m6S0tL1aVLF4/ipuIGAPwsWa1WtWzZ0uU4W+KeP3++oqKidNtttznH4uPjZbPZnDvNpR8/B8/Ly3Mm5eTkZPn5+bnMKSkp0c6dOz1O3FTcAADzaMILsNTW1mr+/PkaNmyYfH3/lz4tFovS09OVnZ2thIQEJSQkKDs7W4GBgRoyZIgkKSQkRCNGjNCECRMUHh6usLAwZWRkqEOHDurRo4dHcZC4AQDm0YSJe/369dq7d6+GDx9e59ykSZNUWVmpMWPGqKysTCkpKVq7dq2Cg4Odc2bOnClfX18NGjRIlZWVSktL04IFC+Tj4+NRHBbDMIxzfjZe0P6xtU0dAtDoCqf1OvskwOQC/Bpx7dQ/em2tyrwnvLbW+UTFDQAwj2b8OhiJGwBgHvzICLvKAQAwEypuAIB5ePF73GZF4gYAmAetclrlAACYCRU3AMA8aJWTuAEAJkKrnFY5AABmQsUNADAPWuUkbgCAidAqp1UOAICZUHEDAMyDVjmJGwBgIrTKaZUDAGAmVNwAAPOgVU7iBgCYCK1yWuUAAJgJFTcAwDyouEncAAAT4TNuWuUAAJgJFTcAwDxolZO4AQAmQqucVjkAAGZCxQ0AMA9a5SRuAICJ0CqnVQ4AgJlQcQMATMNCxU3iBgCYB4mbVjkAAKZCxQ0AMA8KbhI3AMA8aJXTKgcAwFSouAEApkHFTeIGAJgIiZtWOQAApkLFDQAwDSpuEjcAwEzI27TKAQAwEypuAIBp0ConcQMATITETascAABToeIGAJgGFTcVNwDARCwWi9cOT/33v//VPffco/DwcAUGBuqaa65RYWGh87xhGMrKylJsbKwCAgLUrVs37dq1y2UNh8OhcePGKSIiQkFBQerfv7+Ki4s9ioPEDQDAWZSVlalr167y8/PT6tWr9dlnn+m5555Tq1atnHOmT5+uGTNmaNasWSooKJDNZlPPnj115MgR55z09HStWLFCy5YtU35+vioqKtS3b1/V1NS4HQutcgCAeTRRp/yZZ55R69atNX/+fOdYmzZtnP9sGIZyc3M1ZcoUDRw4UJK0cOFCRUdHa8mSJRo1apTKy8v1yiuvaNGiRerRo4ckafHixWrdurXWr1+v3r17uxULFTcAwDS82Sp3OBw6fPiwy+FwOOp93LfffludOnXSHXfcoaioKCUlJWnOnDnO80VFRbLb7erVq5dzzGq1KjU1VRs3bpQkFRYWqrq62mVObGysEhMTnXPcQeIGAPws5eTkKCQkxOXIycmpd+63336r2bNnKyEhQe+9955Gjx6thx56SK+++qokyW63S5Kio6Nd7hcdHe08Z7fb5e/vr9DQ0NPOcQetcgCAaXhzV3lmZqbGjx/vMma1WuudW1tbq06dOik7O1uSlJSUpF27dmn27Nm69957TxufYRhnjdmdOT9FxQ0AMA1vtsqtVqtatmzpcpwuccfExKh9+/YuY1dffbX27t0rSbLZbJJUp3IuLS11VuE2m01VVVUqKys77Rx3kLgBADiLrl276ssvv3QZ+89//qO4uDhJUnx8vGw2m9atW+c8X1VVpby8PHXp0kWSlJycLD8/P5c5JSUl2rlzp3OOO2iVAwDMo4l2lT/yyCPq0qWLsrOzNWjQIH3yySd6+eWX9fLLL/8YlsWi9PR0ZWdnKyEhQQkJCcrOzlZgYKCGDBkiSQoJCdGIESM0YcIEhYeHKywsTBkZGerQoYNzl7k7SNwAANNoqiunXXfddVqxYoUyMzP1xz/+UfHx8crNzdXdd9/tnDNp0iRVVlZqzJgxKisrU0pKitauXavg4GDnnJkzZ8rX11eDBg1SZWWl0tLStGDBAvn4+Lgdi8UwDMOrz66B2j+2tqlDABpd4bReZ58EmFyAX+OtHT3yDa+t9cPcO7y21vnkUcVdXFys2bNna+PGjbLb7bJYLIqOjlaXLl00evRotW7durHiBACAa5XLg8Sdn5+vPn36qHXr1urVq5d69eolwzBUWlqqlStX6sUXX9Tq1avVtWvXxowXAPAzRuL2IHE/8sgjGjlypGbOnHna8+np6SooKPBacAAAwJXbXwfbuXOnRo8efdrzo0aN0s6dO70SFAAA9WnKXwe7ULiduGNiYs54LdVNmzYpJibGK0EBAFAvixcPk3K7VZ6RkaHRo0ersLBQPXv2VHR0tCwWi+x2u9atW6e5c+cqNze3EUMFAABuJ+4xY8YoPDxcM2fO1N/+9jfnb4f6+PgoOTlZr776qgYNGtRogQIAYOYWt7d49HWwwYMHa/Dgwaqurtb+/fslSREREfLza8Qv7QEA8P+RuBt45TQ/Pz8+zwYAoAlwyVMAgGlQcfPrYAAAmAoVNwDAPCi4SdwAAPOgVd7AVvmiRYvUtWtXxcbGas+ePZKk3NxcrVq1yqvBAQAAVx5X3LNnz9YTTzyh9PR0PfXUU87vc7dq1Uq5ubn69a9/7fUgcXZj0y7X2LTLXcb2H3Hoppw85/k+HW2yhTRXdU2tPvvvYT2/9mttLy53zvfzsWjSre10a0ebrH4+2vzNAf1p1ef64bDjvD4XwBOFWwq0cP4r+vyzndq3b59mPP8X3ZzWQ5JUXV2tv7yYq/yP/qni4u8U3KKFUm7ooocemaCoqOgmjhwNQcXdgIr7xRdf1Jw5czRlyhSXH/7u1KmTduzY4dXg4JmvfqjQTdkbnMevX/jfJWp37z+qp97+XAOe36ihf/tE/y2r1Jzh1yo06H/fwc/se5XS2kcpY9l2Df3bJwr099Xse5PUjP+f4AJWWXlMV7Zrp0cfe6LOuePHj+vzzz7T/aMe0LLX39JzubO0Z89upT/4QBNECm/gWuUNqLiLioqUlJRUZ9xqtero0aNeCQoNU1NTq/0VVfWee+ffdpfbz7z7pW6/7lK1swVr8zcH1cLqq98mX6LJb+zQpm8OSpImv75DH0y+SZ2vCNe/vjrQ6PEDDXHjr1J1469S6z0XHBysv82d7zI2OfMPuueuO1RS8r1iYmLPR4iAV3mcuOPj47Vt2zbFxcW5jK9evVrt27f3WmDw3GURQdrw6E2qOmFoe/Eh5b73tYrLKuvM8/OxaNB1l+pwZbW+KDkiSfrFJS3l59tMG3+SoPcdceirHyqUdFkrEjcuGhUVFbJYLAoObtnUoaABzFwpe4vHiXvixIkaO3asjh8/LsMw9Mknn2jp0qXKycnR3LlzGyNGuGH7d+XKfGOHdu8/pogW/hrVva2WjL5e/XI3qryyWpKU2i5Cz93ZUc39fLTviEMj5xXq0LEfz0UE+6vqRK0OHz/hsu6BCocigv3P+/MBGoPD4dALM59Vn1v7qkWLFk0dDhqCvO154v7d736nEydOaNKkSTp27JiGDBmiSy65RM8//7zuvPNOt9ZwOBxyOFw3PNWeqFIzXxJEQ330n/3Of/7qB2nb3nK9l3GjBlwbq4X/+nHn/yfflmngi5vUKshfd1x3iWbc9UvdOftjHTxaf3tdkiyyyDAaPXyg0VVXV2vyxEdUaxh67PGspg4HaLAGfR3s/vvv1549e1RaWiq73a7vvvtOI0aMcPv+OTk5CgkJcTkObHqtIaHgNCqra/Qfe4XiIgJdxvYerNT278r1+Fufqaa2Vr/tdIkkaf+RKvn7NlPL5q5/y4W18NeB03xuDphFdXW1Jk1I1/fFxfrrnHlU2ybG5rRzvORpRESEoqKiPL5fZmamysvLXY7wzoPPJRScws/HorZRQdp35PRf5bJYLPL3/fEtsOu/h1V9olZdEsKd5yOC/ZUQ3UJb9x5q7HCBRnMyae/du0d/nbtArVqFNnVIOAck7gZuTjvTE/7222/PuobVapXVanUZo01+bib2uVIffrFPJYeOKzzox8+4W1h9terT7xXg56NR3eP1wef7tP+IQyGBfrorpbWiW1r13o4fd5tXOE5oeeF/NbFPOx06Vq3yY9WaeOuV+sp+RJu+ZmMaLlzHjh3V3r17nbf/+99iffHF5woJCVFkZJQmjn9In3/2mV74y99UW1uj/fv3SZJCQkLk58d/d2A+Hifu9PR0l9vV1dXaunWr1qxZo4kTJ3orLngoOsSqZwd3UGigvw4erdK/vyvXXX/9WN8fOi5/32aKjwzS80mxCg3y16FjVdpZfFhDXy7Q16X/+wrf0+98qZpaQzPu6iirr482f3NQj725VbV8xo0L2K6dO3X/8Hudt5+bniNJ6vfr32j0mAe14cMPJEmDb3e9ONScea/quutTzl+g8AoTF8peYzEM72w9+stf/qItW7Zo/vz5Z59cj/aPrfVGGMAFrXBar6YOAWh0AX5nn9NQCRPXeG2tr/58i9fWOp+89rOeffr00fLly721HAAAqIfXfh3szTffVFhYmLeWAwCgDlrlDUjcSUlJLpvTDMOQ3W7Xvn379NJLL3k1OAAAfsrMu8G9xePEPWDAAJfbzZo1U2RkpLp166arrrrKW3EBAIB6eJS4T5w4oTZt2qh3796y2WyNFRMAAPWi4PZwc5qvr68eeOCBOpcrBQDgfGjWzOK1w6w83lWekpKirVu3NkYsAADgLDz+jHvMmDGaMGGCiouLlZycrKCgIJfzHTt29FpwAAD8FK1yDxL38OHDlZubq8GDf7ym+EMPPeQ8Z7FYZBiGLBaLampqvB8lAABiV7nkQeJeuHChnn76aRUVFTVmPAAA4AzcTtwnr4waFxfXaMEAAHAmFNwefsZNiwIA0JTIQx4m7iuvvPKsL9rBgwfPKSAAAHB6HiXuadOmKSQkpLFiAQDgjKi4PUzcd955p6KiohorFgAAzoi87cEFWPgrBwCApufxrnIAAJoKRaQHFXdtbS1tcgBAk7JYvHd4IisrSxaLxeX46Y9tGYahrKwsxcbGKiAgQN26ddOuXbtc1nA4HBo3bpwiIiIUFBSk/v37q7i42OPXwONrlQMA8HP0i1/8QiUlJc5jx44dznPTp0/XjBkzNGvWLBUUFMhms6lnz546cuSIc056erpWrFihZcuWKT8/XxUVFerbt6/HVxz1+FrlAAA0laZslfv6+tb7k9aGYSg3N1dTpkzRwIEDJf14tdHo6GgtWbJEo0aNUnl5uV555RUtWrRIPXr0kCQtXrxYrVu31vr169W7d2+346DiBgCYhjdb5Q6HQ4cPH3Y5zvSz1V999ZViY2MVHx+vO++8U99++60kqaioSHa7Xb169XLOtVqtSk1N1caNGyVJhYWFqq6udpkTGxurxMRE5xx3kbgBAD9LOTk5CgkJcTlycnLqnZuSkqJXX31V7733nubMmSO73a4uXbrowIEDstvtkqTo6GiX+0RHRzvP2e12+fv7KzQ09LRz3EWrHABgGt5slWdmZmr8+PEuY1artd65ffr0cf5zhw4d1LlzZ11++eVauHChbrjhhnpjO/mrmWfizpxTUXEDAEzDm61yq9Wqli1buhynS9ynCgoKUocOHfTVV185P/c+tXIuLS11VuE2m01VVVUqKys77Rx3kbgBAPCQw+HQ559/rpiYGMXHx8tms2ndunXO81VVVcrLy1OXLl0kScnJyfLz83OZU1JSop07dzrnuItWOQDANJpqV3lGRob69eunyy67TKWlpXryySd1+PBhDRs2TBaLRenp6crOzlZCQoISEhKUnZ2twMBADRkyRJIUEhKiESNGaMKECQoPD1dYWJgyMjLUoUMH5y5zd5G4AQCm0VTfBisuLtZdd92l/fv3KzIyUjfccIM2b96suLg4SdKkSZNUWVmpMWPGqKysTCkpKVq7dq2Cg4Oda8ycOVO+vr4aNGiQKisrlZaWpgULFsjHx8ejWCzGBXIt0/aPrW3qEIBGVzit19knASYX4Nd4a9/wdJ7X1tr8aKrX1jqfqLgBAKbBtcpJ3AAAEyFvs6scAABToeIGAJgGrXISNwDARMjbtMoBADAVKm4AgGnQKidxAwBMhMRNqxwAAFOh4gYAmAYFN4kbAGAitMpplQMAYCpU3AAA06DgJnEDAEyEVjmtcgAATIWKGwBgGhTcJG4AgIk0I3PTKgcAwEyouAEApkHBTeIGAJgIu8pplQMAYCpU3AAA02hGwU3iBgCYB61yWuUAAJgKFTcAwDQouEncAAATsYjMTascAAAToeIGAJgGu8pJ3AAAE2FXOa1yAABMhYobAGAaFNwkbgCAifCznrTKAQAwFSpuAIBpUHCTuAEAJsKuclrlAACYChU3AMA0KLhJ3AAAE2FXOa1yAABMhYobAGAa1NskbgCAibCrnFY5AACmQuIGAJhGM4v3jnORk5Mji8Wi9PR055hhGMrKylJsbKwCAgLUrVs37dq1y+V+DodD48aNU0REhIKCgtS/f38VFxd79hqcW+gAAJw/FovFa0dDFRQU6OWXX1bHjh1dxqdPn64ZM2Zo1qxZKigokM1mU8+ePXXkyBHnnPT0dK1YsULLli1Tfn6+Kioq1LdvX9XU1Lj9+CRuAADcVFFRobvvvltz5sxRaGioc9wwDOXm5mrKlCkaOHCgEhMTtXDhQh07dkxLliyRJJWXl+uVV17Rc889px49eigpKUmLFy/Wjh07tH79erdjIHEDAEzDYvHe0RBjx47Vbbfdph49eriMFxUVyW63q1evXs4xq9Wq1NRUbdy4UZJUWFio6upqlzmxsbFKTEx0znEHu8oBAKbhzV3lDodDDofDZcxqtcpqtdY7f9myZfr0009VUFBQ55zdbpckRUdHu4xHR0drz549zjn+/v4ulfrJOSfv7w4qbgDAz1JOTo5CQkJcjpycnHrnfvfdd3r44Ye1ePFiNW/e/LRrnvqHhWEYZ/1jw505P0XiBgCYhjd3lWdmZqq8vNzlyMzMrPdxCwsLVVpaquTkZPn6+srX11d5eXl64YUX5Ovr66y0T62cS0tLnedsNpuqqqpUVlZ22jluvQaevGAAADQlb+4qt1qtatmypctxujZ5WlqaduzYoW3btjmPTp066e6779a2bdvUtm1b2Ww2rVu3znmfqqoq5eXlqUuXLpKk5ORk+fn5ucwpKSnRzp07nXPcwWfcAACcRXBwsBITE13GgoKCFB4e7hxPT09Xdna2EhISlJCQoOzsbAUGBmrIkCGSpJCQEI0YMUITJkxQeHi4wsLClJGRoQ4dOtTZ7HYmJG4AgGlcyBc8nTRpkiorKzVmzBiVlZUpJSVFa9euVXBwsHPOzJkz5evrq0GDBqmyslJpaWlasGCBfHx83H4ci2EYRmM8AU+1f2xtU4cANLrCab3OPgkwuQC/xlt75Gs7vbbW3MGJZ590AeIzbgAATIRWOQDANPhxMBI3AMBE+FlPWuUAAJgKFTcAwDQouEncAAATaUbmplUOAICZUHEDAEyDgpvEDQAwEXaV0yoHAMBULpiK+9M/cilIXPxCr3uwqUMAGl3l1lmNtjbV5gWUuAEAOBta5fzxAgCAqVBxAwBMoxkFN4kbAGAeJG5a5QAAmAoVNwDANNicRuIGAJgIrXJa5QAAmAoVNwDANOiUk7gBACbCz3rSKgcAwFSouAEApkG1SeIGAJgInXL+eAEAwFSouAEApsHmNBI3AMBEyNu0ygEAMBUqbgCAaXDJUxI3AMBE+IybVjkAAKZCxQ0AMA0KbhI3AMBE+IybVjkAAKZCxQ0AMA2LKLlJ3AAA06BVTqscAABToeIGAJgGFTeJGwBgIha+D0arHAAAM6HiBgCYBq1yEjcAwETolNMqBwDAVEjcAADTaGaxeO3wxOzZs9WxY0e1bNlSLVu2VOfOnbV69WrnecMwlJWVpdjYWAUEBKhbt27atWuXyxoOh0Pjxo1TRESEgoKC1L9/fxUXF3v+Gnh8DwAAmkgzi/cOT1x66aV6+umntWXLFm3ZskU333yzfv3rXzuT8/Tp0zVjxgzNmjVLBQUFstls6tmzp44cOeJcIz09XStWrNCyZcuUn5+viooK9e3bVzU1NR7FYjEMw/As/MZx/ERTRwA0vtDrHmzqEIBGV7l1VqOt/UJ+kdfWeujG+HO6f1hYmP785z9r+PDhio2NVXp6uiZPnizpx+o6OjpazzzzjEaNGqXy8nJFRkZq0aJFGjx4sCTp+++/V+vWrfXuu++qd+/ebj8uFTcAwDQsFu8dDodDhw8fdjkcDsdZY6ipqdGyZct09OhRde7cWUVFRbLb7erVq5dzjtVqVWpqqjZu3ChJKiwsVHV1tcuc2NhYJSYmOue4i8QNADCNZrJ47cjJyVFISIjLkZOTc9rH3rFjh1q0aCGr1arRo0drxYoVat++vex2uyQpOjraZX50dLTznN1ul7+/v0JDQ087x118HQwA8LOUmZmp8ePHu4xZrdbTzm/Xrp22bdumQ4cOafny5Ro2bJjy8vKc50+9qpthGGe90ps7c05F4gYAmIY3v8dttVrPmKhP5e/vryuuuEKS1KlTJxUUFOj55593fq5tt9sVExPjnF9aWuqswm02m6qqqlRWVuZSdZeWlqpLly4exU2rHABgGk21q7w+hmHI4XAoPj5eNptN69atc56rqqpSXl6eMyknJyfLz8/PZU5JSYl27tzpceKm4gYA4Cwee+wx9enTR61bt9aRI0e0bNkybdiwQWvWrJHFYlF6erqys7OVkJCghIQEZWdnKzAwUEOGDJEkhYSEaMSIEZowYYLCw8MVFhamjIwMdejQQT169PAoFhI3AMA0PL1wirf88MMPGjp0qEpKShQSEqKOHTtqzZo16tmzpyRp0qRJqqys1JgxY1RWVqaUlBStXbtWwcHBzjVmzpwpX19fDRo0SJWVlUpLS9OCBQvk4+PjUSx8jxs4j/geN34OGvN73HM+3uO1te5PifPaWucTn3EDAGAitMoBAKbRVK3yCwmJGwBgGuRtWuUAAJgKFTcAwDSoNkncAAAT8fTyoBcj/ngBAMBEqLgBAKZBvU3iBgCYCF8Ho1UOAICpUHEDAEyDepvEDQAwETrltMoBADAVKm4AgGnwPW4SNwDARGgT8xoAAGAqVNwAANOgVU7iBgCYCGmbVjkAAKZCxQ0AMA1a5SRuAICJ0CbmNQAAwFSouAEApkGrnMQNADAR0jatcgAATIWKGwBgGnTKSdwAABNpRrOcVjkAAGZCxQ0AMA1a5SRuAICJWGiV0yoHAMBMqLgBAKZBq5zEDQAwEXaVe7FV/t1332n48OHeWg4AANTDa4n74MGDWrhwobeWAwCgDovFe4dZud0qf/vtt894/ttvvz3nYAAAOBMzJ1xvcTtxDxgwQBaLRYZhnHYOv9oCAEDjcrtVHhMTo+XLl6u2trbe49NPP23MOAEAkMWL/zMrtxN3cnLyGZPz2apxAADOVTOL9w6zcrtVPnHiRB09evS056+44gp9+OGHXgkKAADUz+3E/atf/eqM54OCgpSamnrOAQEAcDpmbnF7C5c8BQDAREjcAADTaKrvcefk5Oi6665TcHCwoqKiNGDAAH355ZcucwzDUFZWlmJjYxUQEKBu3bpp165dLnMcDofGjRuniIgIBQUFqX///iouLvYoFhI3AMA0mmpXeV5ensaOHavNmzdr3bp1OnHihHr16uWy92v69OmaMWOGZs2apYKCAtlsNvXs2VNHjhxxzklPT9eKFSu0bNky5efnq6KiQn379lVNTY37r4FxgWwFP36iqSMAGl/odQ82dQhAo6vcOqvR1t7w5UGvrdWtXViD77tv3z5FRUUpLy9PN910kwzDUGxsrNLT0zV58mRJP1bX0dHReuaZZzRq1CiVl5crMjJSixYt0uDBgyVJ33//vVq3bq13331XvXv3duuxqbgBAKbhza+DORwOHT582OVwOBxuxVFeXi5JCgv7MfkXFRXJbrerV69ezjlWq1WpqanauHGjJKmwsFDV1dUuc2JjY5WYmOic49Zr4PbMn1i0aJG6du2q2NhY7dmzR5KUm5urVatWNWQ5nEdHj1Zoes5TuqVHd11/bUfde/ed2rlje1OHBbjti3emqXLrrDrHzEcHSZKmjLpV2976g/ZvfE7f503XO399UNclxrmsMXxgV70352H98NGfVbl1lkJaBDTFU0EDeLNVnpOTo5CQEJcjJyfnrDEYhqHx48frxhtvVGJioiTJbrdLkqKjo13mRkdHO8/Z7Xb5+/srNDT0tHPc4XHinj17tsaPH69bb71Vhw4dcvblW7VqpdzcXE+Xw3mW9cQftGnTRj319HS9ueLv6tylq0aN/J1++OGHpg4NcMuN9/xZbXpkOo9bR78oSXpr3VZJ0td7SvXIM2+o0x3ZSvvdDO35/qD+/tKDight4VwjsLmf1m38TH+et7ZJngMuDJmZmSovL3c5MjMzz3q/Bx98UNu3b9fSpUvrnDv10t+GYZz1cuDuzPkpjxP3iy++qDlz5mjKlCny8fFxjnfq1Ek7duzwdDmcR8ePH9f769bqkQkTldzpOl0WF6cHxo7TJZdcqjeWLWnq8AC37C+r0A8HjjiPW3+VqG/27tNHhV9Jkl5bs0Uffvyldv/3gD7/1q7Jz72lkOAAJSbEOteYtWSDnp2/Th9v391EzwIN5c1d5VarVS1btnQ5rFbrGR9/3Lhxevvtt/Xhhx/q0ksvdY7bbDZJqlM5l5aWOqtwm82mqqoqlZWVnXaOOzxO3EVFRUpKSqozbrVaz3hlNTS9mpoTqqmpqfPGtDZvrq1budY8zMfP10d33nqdFq7adNrzIwZ21aEjx7TjP/89z9GhMVi8eHjCMAw9+OCDeuutt/TBBx8oPj7e5Xx8fLxsNpvWrVvnHKuqqlJeXp66dOki6cdLh/v5+bnMKSkp0c6dO51z3OH2ldN+Gty2bdsUF+f6mdHq1avVvn17T5fDeRQU1EK/vCZJL//1JcW3bavw8Aitfvcf2rH937rslH+fgBn0795RrYIDtPjvH7uM9/lVol59+ncKbO4n+/7D6jt6lg4corBAw40dO1ZLlizRqlWrFBwc7KysQ0JCFBAQIIvFovT0dGVnZyshIUEJCQnKzs5WYGCghgwZ4pw7YsQITZgwQeHh4QoLC1NGRoY6dOigHj16uB2Lx4l74sSJGjt2rI4fPy7DMPTJJ59o6dKlysnJ0dy5c91aw+Fw1Nm5Z/hYz9qiwLl7Kme6pj7+mHp2v0k+Pj666ur26nNbX33x2WdNHRrgsWEDuui9f32mkn3lLuN5Bf9Ryp05imjVQr8b2EWLpw/XTUOf1b6yiiaKFN7SrIl+Pnr27NmSpG7durmMz58/X/fdd58kadKkSaqsrNSYMWNUVlamlJQUrV27VsHBwc75M2fOlK+vrwYNGqTKykqlpaVpwYIFLh89n02Dvsc9Z84cPfnkk/ruu+8kSZdccomysrI0YsQIt+6flZWladOmuYxNeXyq/vBElqehoIGOHTumo0crFBkZpYkT0lV57JhmzX65qcO66PE9bu+5LCZUn/19mu7MmKN/bDjz/podq57QwlWb9ewpm9F+lZygtXMflu1XE1VeUdmY4f6sNOb3uDd/fchra91wRSuvrXU+eVxxS9L999+v+++/X/v371dtba2ioqI8un9mZqbGjx/vMmb4UG2fT4GBgQoMDNTh8nJt+le+0sdPbOqQAI8M7d9ZpQePaPVHu8461yKLrH4N+s8dcME5p3dyREREg+5ntdZti3PltPPjX/kfSYahuPh4fbd3r2Y+O11xbeL1698MbOrQALdZLBbd++sb9H//+Fg1NbXO8cDm/po8srfeydsh+/5yhYUE6feDbtIl0a301rr/bcCMDg9WdHhLXX7Zj/8NS0yI1ZGjx/WdvUxlh4+d9+cDD/DjYA3bnHam75t9++235xQQGldFxRG9kDtDP9jtCglppbSevTTu4Ufk5+fX1KEBbrs5pZ0uiwnTwpWbXcZramvVrk207umXovBWQTpYfkxbdu1Rj+Ez9fm3//uazsjbf6U/jL7VeXv9vEckSfc/sajORjdcWPhZzwZ8xv3888+73K6urtbWrVu1Zs0aTZw4UY8++miDAqHixs8Bn3Hj56AxP+P++Jvys09yU8rlIV5b63zyuOJ++OGH6x3/y1/+oi1btpxzQAAAnE4TbSq/oHjtR0b69Omj5cuXe2s5AADqaKoLsFxIvJa433zzTeevpAAAgMbhcas8KSnJZXOaYRiy2+3at2+fXnrpJa8GBwCACzOXyl7iceIeMGCAy+1mzZopMjJS3bp101VXXeWtuAAAqINd5R4m7hMnTqhNmzbq3bu385dQAADA+ePRZ9y+vr564IEH6lxnHACA88GbP+tpVh5vTktJSdHWrVsbIxYAAM6IXeUN+Ix7zJgxmjBhgoqLi5WcnKygoCCX8x07dvRacAAAwJXbiXv48OHKzc3V4MGDJUkPPfSQ85zFYpFhGLJYLKqpqfF+lAAASOYulb3E7cS9cOFCPf300yoqKmrMeAAAOC12lXuQuE9e0jwuLq7RggEAAGfm0WfcZ/pVMAAAGhtpyMPEfeWVV541eR88ePCcAgIA4HTI2x4m7mnTpikkxJw/gwYAwMXAo8R95513KioqqrFiAQDgzCi53U/cfL4NAGhq7Cr34MppJ3eVAwCApuN2xV1bW9uYcQAAcFY0fxtwyVMAAJoKebsBPzICAACaDhU3AMA8KLlJ3AAA82BXOa1yAABMhYobAGAa7ConcQMATIS8TascAABToeIGAJgHJTeJGwBgHuwqp1UOAICpUHEDAEyDXeUkbgCAiZC3aZUDAGAqVNwAAPOg5CZxAwDMg13ltMoBADAVKm4AgGmwq5zEDQAwEfI2rXIAANzyz3/+U/369VNsbKwsFotWrlzpct4wDGVlZSk2NlYBAQHq1q2bdu3a5TLH4XBo3LhxioiIUFBQkPr376/i4mKP4iBxAwDMw+LFw0NHjx7VL3/5S82aNave89OnT9eMGTM0a9YsFRQUyGazqWfPnjpy5IhzTnp6ulasWKFly5YpPz9fFRUV6tu3r2pqatyOw2IYhuF5+N53/ERTRwA0vtDrHmzqEIBGV7m1/sTmDd/uO+61tdpGNm/wfS0Wi1asWKEBAwZI+rHajo2NVXp6uiZPnizpx+o6OjpazzzzjEaNGqXy8nJFRkZq0aJFGjx4sCTp+++/V+vWrfXuu++qd+/ebj02FTcAAOeoqKhIdrtdvXr1co5ZrValpqZq48aNkqTCwkJVV1e7zImNjVViYqJzjjvYnAYAMA1v7ip3OBxyOBwuY1arVVar1eO17Ha7JCk6OtplPDo6Wnv27HHO8ff3V2hoaJ05J+/vDipuAIBpePMj7pycHIWEhLgcOTk55xbfKX9ZGIZRZ+xU7sz5KRI3AOBnKTMzU+Xl5S5HZmZmg9ay2WySVKdyLi0tdVbhNptNVVVVKisrO+0cd5C4AQDm4cWS22q1qmXLli5HQ9rkkhQfHy+bzaZ169Y5x6qqqpSXl6cuXbpIkpKTk+Xn5+cyp6SkRDt37nTOcQefcQMATKMpr1VeUVGhr7/+2nm7qKhI27ZtU1hYmC677DKlp6crOztbCQkJSkhIUHZ2tgIDAzVkyBBJUkhIiEaMGKEJEyYoPDxcYWFhysjIUIcOHdSjRw+34yBxAwDghi1btqh79+7O2+PHj5ckDRs2TAsWLNCkSZNUWVmpMWPGqKysTCkpKVq7dq2Cg4Od95k5c6Z8fX01aNAgVVZWKi0tTQsWLJCPj4/bcfA9buA84nvc+DlozO9x7z3oOPskN10W1rC2eFOj4gYAmAbXKmdzGgAApkLFDQAwDX7Wk8QNADAVMjetcgAATISKGwBgGrTKSdwAABMhb9MqBwDAVKi4AQCmQaucxA0AMJGmvFb5hYJWOQAAJkLFDQAwDwpuEjcAwDzI27TKAQAwFSpuAIBpsKucxA0AMBF2ldMqBwDAVKi4AQDmQcFN4gYAmAd5m1Y5AACmQsUNADANdpWTuAEAJsKuclrlAACYChU3AMA0aJVTcQMAYCokbgAATIRWOQDANGiVk7gBACbCrnJa5QAAmAoVNwDANGiVk7gBACZC3qZVDgCAqVBxAwDMg5KbxA0AMA92ldMqBwDAVKi4AQCmwa5yEjcAwETI27TKAQAwFSpuAIB5UHKTuAEA5sGuclrlAACYChU3AMA02FUuWQzDMJo6CJx/DodDOTk5yszMlNVqbepwgEbB+xwXIxL3z9Thw4cVEhKi8vJytWzZsqnDARoF73NcjPiMGwAAEyFxAwBgIiRuAABMhMT9M2W1WjV16lQ27OCixvscFyM2pwEAYCJU3AAAmAiJGwAAEyFxAwBgIiRu1JGVlaVrrrmmqcMAGhXvc5gVidsk7rvvPlksFlksFvn5+alt27bKyMjQ0aNHmySevXv3ql+/fgoKClJERIQeeughVVVVNUksuHhcaO/zhx9+WMnJybJarSR5XDD4kRETueWWWzR//nxVV1fro48+0siRI3X06FHNnj27ztzq6mr5+fk1Shw1NTW67bbbFBkZqfz8fB04cEDDhg2TYRh68cUXG+Ux8fNxobzPJckwDA0fPlwff/yxtm/f3miPA3iCittErFarbDabWrdurSFDhujuu+/WypUrJf2v7Tdv3jy1bdtWVqtVhmGovLxcv//97xUVFaWWLVvq5ptv1r///W+XdZ9++mlFR0crODhYI0aM0PHjx88Yx9q1a/XZZ59p8eLFSkpKUo8ePfTcc89pzpw5Onz4cGM9ffxMXCjvc0l64YUXNHbsWLVt27YxnirQICRuEwsICFB1dbXz9tdff63XX39dy5cv17Zt2yRJt912m+x2u959910VFhbq2muvVVpamg4ePChJev311zV16lQ99dRT2rJli2JiYvTSSy+d8XE3bdqkxMRExcbGOsd69+4th8OhwsJC7z9R/Kw11fscuFDRKjepTz75REuWLFFaWppzrKqqSosWLVJkZKQk6YMPPtCOHTtUWlrqvHLUs88+q5UrV+rNN9/U73//e+Xm5mr48OEaOXKkJOnJJ5/U+vXrz1iN2O12RUdHu4yFhobK399fdrvd208VP2NN+T4HLlRU3Cbyj3/8Qy1atFDz5s3VuXNn3XTTTS6fKcfFxTn/YyZJhYWFqqioUHh4uFq0aOE8ioqK9M0330iSPv/8c3Xu3NnlcU69XR9LPb9mbxhGveOAJy6k9zlwIaLiNpHu3btr9uzZ8vPzU2xsbJ1NOUFBQS63a2trFRMTow0bNtRZq1WrVg2Ow2az6eOPP3YZKysrU3V1dZ1KHPDUhfI+By5UJG4TCQoK0hVXXOH2/GuvvVZ2u12+vr5q06ZNvXOuvvpqbd68Wffee69zbPPmzWdct3PnznrqqadUUlKimJgYST9uWLNarUpOTnY7PqA+F8r7HLhQ0Sq/iPXo0UOdO3fWgAED9N5772n37t3auHGj/vCHP2jLli2Sfvye6rx58zRv3jz95z//0dSpU7Vr164zrturVy+1b99eQ4cO1datW/X+++8rIyND999/v1q2bHk+nhrg1Fjvc+nHjXDbtm2T3W5XZWWltm3bpm3btnHNAjQpKu6LmMVi0bvvvqspU6Zo+PDh2rdvn2w2m2666SZnS3vw4MH65ptvNHnyZB0/fly//e1v9cADD+i999477bo+Pj565513NGbMGHXt2lUBAQEaMmSInn322fP11ACnxnqfS9LIkSOVl5fnvJ2UlCRJKioqOm11DzQ2ftYTAAAToVUOAICJkLgBADAREjcAACZC4gYAwERI3AAAmAiJGwAAEyFxAwBgIiRuAABMhMQNAICJkLgBADAREjcAACZC4gYAwET+Hxz/FQyBSIRPAAAAAElFTkSuQmCC",
-      "text/plain": [
-       "<Figure size 600x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "===== FOLD 2 =====\n",
-      "Val Loss=0.1241 | Val Acc=0.9591 | Val AUC=0.9861\n",
-      "\u001b[1m40/40\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 600x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "===== FOLD 3 =====\n",
-      "Val Loss=0.1050 | Val Acc=0.9772 | Val AUC=0.9900\n",
-      "\u001b[1m40/40\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 8ms/step \n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAe4AAAHBCAYAAACv7Vi1AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAP2FJREFUeJzt3XtclHX6//H3yGEEROSgDOQJEy1DS7Hw0AaeMw+57qZGlqaWpyxS0swtsQOYW0rlZgdNTFetzbR2K1M7WPzMQtJN7byixcaEB0JRHBDu3x9+nW0EdQYH8a7Xs8f9eMTn/tz3XEPz6OK67s/ct8UwDEMAAMAU6tV1AAAAwH0kbgAATITEDQCAiZC4AQAwERI3AAAmQuIGAMBESNwAAJgIiRsAABMhcQMAYCIk7t+QrKwsWSwWbdu2zWX8wIED6ty5sxo0aKCNGzfWymuXlZVpwoQJioqKko+Pj6666iqvv8bo0aPVsmVLr5/3YnXs2DGlpaXpww8/9Oi4tLQ0WSyW2gnqHD788ENZLJZqtz//+c81Opc779/dz8bTTz+tLl26KCIiQlarVc2bN9eIESO0e/duj2ID6pJvXQeA2pWfn68+ffro559/1qZNm9SlS5daeZ1Fixbp+eef1zPPPKP4+Hg1aNDA66/x4IMP6p577vH6eS9Wx44d05w5cyRJSUlJbh83btw4XX/99bUUlXvS09PVo0cPl7Hw8PA6iuZ/Dh48qP79++vKK69UaGio9uzZo7lz5yohIUG5ublq27ZtXYcInBOJ+zfsu+++U+/evVVeXq7Nmzerffv2tfZau3btUkBAgO66665ae41LL7201s79W3Ds2DEFBgaqadOmatq0aZ3GEhsbW2t/JJ6PU38InZKYmKguXbqoXbt2+vvf/66HH364jiID3Eer/Ddqx44duvbaa+Xr66vs7OwqSTs7O1u9evVScHCwAgMD1a1bN7311lsuc0613j/44ANNnDhRERERCg8P19ChQ/XTTz8551ksFi1evFilpaXOtmhWVpb27t3r/PfTWSwWpaWlOX/ev3+/7rzzTjVr1kxWq1WNGzdW9+7dtWnTJuec6tqhx48f18yZMxUTEyN/f39dcsklmjx5sn755ReXeS1bttTAgQO1fv16derUSQEBAbrsssv00ksvucw7duyYUlNTFRMTo/r16yssLEydO3fWqlWrXOJo0KCBvv76a/Xr109BQUGKiorS3LlzJUlbt27Vtddeq6CgILVp00bLli1zeY39+/dr0qRJateunRo0aKAmTZqoZ8+e+vjjj51z9u7dq8aNG0s6mWxO/V5Hjx4t6X/t8M8//1x//vOfFRoa6vzD5vRWeXZ2tvz8/JSamuoSx6n/vkuWLKny36e2ufP5O5OsrCy1bdtWVqtVl19+uV5++eXziuXU79nXlzoG5kDi/g3Kzs5WUlKSmjRpouzsbLVq1cpl/+bNm9WzZ08VFxdryZIlWrVqlYKDgzVo0CC98sorVc43btw4+fn5aeXKlZo3b54+/PBDjRw50rn/k08+0Q033KCAgAB98skn+uSTTzRgwACPYr711lu1bt06PfTQQ9qwYYMWL16s3r176+DBg2c8xjAMDRkyRE888YRuvfVWvfXWW5o6daqWLVumnj17yuFwuMz/97//rWnTpunee+/VG2+8oQ4dOmjs2LH66KOPnHOmTp2qRYsW6e6779b69eu1fPly3XTTTVXiKC8v19ChQzVgwAC98cYb6t+/v2bOnKkHHnhAo0aN0pgxY7R27Vq1bdtWo0ePVm5urvPYQ4cOSZJmz56tt956S0uXLlWrVq2UlJTkvJ4bFRWl9evXS5LGjh3r/L0++OCDLnEMHTpUrVu31j/+8Q8999xz1f6err32Wj366KN68skn9eabb0qSdu/ercmTJ2vkyJEaO3bs2f7T1EhlZaVOnDjhsp3i6efv17KysnT77bfr8ssv15o1a/SXv/xFjzzyiN5//32P4quoqJDD4dDXX3+tcePGqUmTJrr99ttr9F6BC87Ab8bSpUsNSYYkIyQkxCgsLKx2XpcuXYwmTZoYR44ccY6dOHHCiIuLM5o2bWpUVla6nG/SpEkux8+bN8+QZBQUFDjHRo0aZQQFBbnMy8vLMyQZS5curRKDJGP27NnOnxs0aGCkpKSc9f2NGjXKaNGihfPn9evXG5KMefPmucx75ZVXDEnGCy+84Bxr0aKFUb9+fWPfvn3OsdLSUiMsLMwYP368cywuLs4YMmTIOeOQZKxZs8Y5Vl5ebjRu3NiQZHz++efO8YMHDxo+Pj7G1KlTz3i+EydOGOXl5UavXr2MP/7xj87x/fv3V/k9nTJ79mxDkvHQQw+dcd+vVVZWGjfccIPRqFEjY9euXUa7du2Myy67zCgpKTnre/XUBx984PwMnr599913hmG4//k7da4PPvjAMAzDqKioMKKjo41OnTo55xiGYezdu9fw8/Nz+Wyci9VqdcbVpk0b48svvzz/Nw9cIFTcv0GDBw9WcXGxUlJSVFFR4bLv6NGj+vTTT/XnP//ZZQGZj4+Pbr31VuXn5+ubb76pcr5f69ChgyRp3759Xov5mmuuUVZWlh599FFt3bpV5eXl5zzmVJV1qn18yk033aSgoCC99957LuNXXXWVmjdv7vy5fv36atOmjcv7uOaaa/TOO+/o/vvv14cffqjS0tJqX9tiseiGG25w/uzr66vWrVsrKipKHTt2dI6HhYWpSZMmVX5Xzz33nDp16qT69evL19dXfn5+eu+99/TVV1+d833/2p/+9Ce35lksFr388ssKDg5W586dlZeXp1dffVVBQUFnPc4wjDNWzmfz+OOPKycnx2Vr1qxZjT5/p3zzzTf66aeflJyc7HIpoEWLFurWrZtbcZ2yZcsWffLJJ1qxYoWCg4PVo0cPVpbDNEjcv0EPPvigHnroIa1cuVIjR450Sd5FRUUyDENRUVFVjouOjpakKm3h01cDW61WSTpjUquJV155RaNGjdLixYvVtWtXhYWF6bbbbpPdbj/jMQcPHpSvr6/zGuUpFotFNpvtnO9DOvlefv0+nn76ac2YMUPr1q1Tjx49FBYWpiFDhui7775zOS4wMFD169d3GfP391dYWFiV1/D399fx48edP8+fP18TJ05UQkKC1qxZo61btyonJ0fXX3+9x7/T6v47nkl4eLgGDx6s48eP6/rrr3drseKyZcvk5+fnsrmjVatW6ty5s8tmtVpr9Pk75dS4zWarsq+6sbPp1KmTunTpoltuuUUffPCBDMPQAw884NE5gLrCaozfqFMLmubMmaPKykr9/e9/l6+vr0JDQ1WvXj0VFBRUOebUgrOIiAivxHAqsZ1+rbm6/zFHREQoMzNTmZmZ+uGHH/Tmm2/q/vvvV2FhofNa7+nCw8N14sQJ7d+/3yV5G4Yhu92uq6++2uOYg4KCNGfOHM2ZM0c///yzs/oeNGiQvv76a4/PV50VK1YoKSlJixYtchk/cuSIx+fy5PvaGzdu1KJFi3TNNddo7dq1WrNmzTkr9kGDBiknJ8fjuM7kfD5/p/7wqu6PubP9gXcuwcHBuuyyy/Ttt9/W+BzAhUTF/RuWlpamOXPm6NVXX1VycrJOnDihoKAgJSQk6PXXX3ep7iorK7VixQo1bdpUbdq08crrR0ZGqn79+vriiy9cxt94442zHte8eXPddddd6tOnjz7//PMzzuvVq5ekk4nw19asWaOjR48699dUZGSkRo8erZtvvlnffPONjh07dl7nO8VisTi7Fqd88cUX+uSTT1zGvNnZKCgo0MiRI5WYmKgtW7Zo8ODBGjt2rPLy8s56XHh4eJXK+Xycz+evbdu2ioqK0qpVq2QYhnN837592rJlS41jOnDggHbu3KnWrVvX+BzAhUTF/Rv30EMPqV69enrwwQdlGIZWrVqljIwM9enTRz169FBqaqr8/f317LPPateuXVq1apXX7rplsVg0cuRIvfTSS7r00kt15ZVX6rPPPtPKlStd5hUXF6tHjx5KTk7WZZddpuDgYOXk5Gj9+vUaOnToGc/fp08f9evXTzNmzNDhw4fVvXt3ffHFF5o9e7Y6duyoW2+91eOYExISNHDgQHXo0EGhoaH66quvtHz5cnXt2lWBgYEen686AwcO1COPPKLZs2crMTFR33zzjR5++GHFxMS4XEMODg5WixYt9MYbb6hXr14KCwtTRESEx3ePq6io0M033yyLxaKVK1fKx8dHWVlZuuqqqzR8+HBlZ2fL39/fK+/NHTX9/NWrV0+PPPKIxo0bpz/+8Y+644479MsvvygtLc2tVnlxcbH69Omj5ORkxcbGKiAgQN9++62eeuopORwOzZ4929tvFagddbgwDl52ahV4Tk5OlX2PPfaYIckYOnSoUVZWZnz88cdGz549jaCgICMgIMDo0qWL8c9//tOt852+2tcwql9VbhiGUVxcbIwbN86IjIw0goKCjEGDBhl79+51WS19/PhxY8KECUaHDh2Mhg0bGgEBAUbbtm2N2bNnG0ePHnV5jdNXDpeWlhozZswwWrRoYfj5+RlRUVHGxIkTjaKiIpd5LVq0MAYMGFAlvsTERCMxMdH58/3332907tzZCA0NNaxWq9GqVSvj3nvvNQ4cOHDO95qYmGhcccUVVcZPf22Hw2GkpqYal1xyiVG/fn2jU6dOxrp166p9f5s2bTI6duzoXAU9atQowzD+t3J8//79VV7v9FXls2bNMurVq2e89957LvO2bNli+Pr6Gvfcc0+Vc9TUqc/GP/7xj7POc+fzV93nzDAMY/HixUZsbKzh7+9vtGnTxnjppZeq/d2d7vjx48a4ceOMyy+/3GjQoIHh6+trNG3a1Bg5cqSxe/fumrxdoE5YDONXPScAAHBR4xo3AAAmQuIGAMBESNwAAJgIiRsAABMhcQMAYCIkbgAATITEDQCAiVw0d07r9LBnz9MFzOijGT3qOgSg1jWweufui9UJ6HiX185Vun2h1851IVFxAwBgIhdNxQ0AwDlZqDdJ3AAA8/DSQ5DMjD9dAAAwESpuAIB50ConcQMATIRWOa1yAADMhIobAGAetMpJ3AAAE6FVTqscAAAzoeIGAJgHrXISNwDARGiV0yoHAMBMSNwAAPOw1PPe5oGWLVvKYrFU2SZPnixJMgxDaWlpio6OVkBAgJKSkrR7926XczgcDk2ZMkUREREKCgrS4MGDlZ+f7/GvgMQNADAPi8V7mwdycnJUUFDg3DZu3ChJuummmyRJ8+bN0/z587Vw4ULl5OTIZrOpT58+OnLkiPMcKSkpWrt2rVavXq3s7GyVlJRo4MCBqqio8CgWEjcAAOfQuHFj2Ww25/avf/1Ll156qRITE2UYhjIzMzVr1iwNHTpUcXFxWrZsmY4dO6aVK1dKkoqLi7VkyRI9+eST6t27tzp27KgVK1Zo586d2rRpk0exkLgBAObhxVa5w+HQ4cOHXTaHw3HOEMrKyrRixQqNGTNGFotFeXl5stvt6tu3r3OO1WpVYmKitmzZIknKzc1VeXm5y5zo6GjFxcU557iLxA0AMA8vtsozMjIUEhLismVkZJwzhHXr1umXX37R6NGjJUl2u12SFBkZ6TIvMjLSuc9ut8vf31+hoaFnnOMuvg4GAPhdmjlzpqZOneoyZrVaz3nckiVL1L9/f0VHR7uMW067bm4YRpWx07kz53QkbgCAeXjxBixWq9WtRP1r+/bt06ZNm/T66687x2w2m6STVXVUVJRzvLCw0FmF22w2lZWVqaioyKXqLiwsVLdu3TyKgVY5AMA86ujrYKcsXbpUTZo00YABA5xjMTExstlszpXm0snr4Js3b3Ym5fj4ePn5+bnMKSgo0K5duzxO3FTcAAC4obKyUkuXLtWoUaPk6/u/9GmxWJSSkqL09HTFxsYqNjZW6enpCgwMVHJysiQpJCREY8eO1bRp0xQeHq6wsDClpqaqffv26t27t0dxkLgBAOZRr+5uebpp0yb98MMPGjNmTJV906dPV2lpqSZNmqSioiIlJCRow4YNCg4Ods5ZsGCBfH19NWzYMJWWlqpXr17KysqSj4+PR3FYDMMwzvvdeEGnh9+v6xCAWvfRjB51HQJQ6xpYay+5BvR8zGvnKn1/ltfOdSFxjRsAABOhVQ4AMA+eDkbiBgCYCM/jplUOAICZUHEDAMyDVjmJGwBgIrTKaZUDAGAmVNwAAPOgVU7iBgCYCK1yWuUAAJgJFTcAwDxolZO4AQAmQqucVjkAAGZCxQ0AMA9a5SRuAICJ0CqnVQ4AgJlQcQMAzIOKm8QNADARrnHTKgcAwEyouAEA5kGrnMQNADARWuW0ygEAMBMqbgCAedAqJ3EDAEyEVjmtcgAAzISKGwBgGhYqbhI3AMA8SNy0ygEAMBUqbgCAeVBwk7gBAOZBq5xWOQAApkLFDQAwDSpuEjcAwERI3LTKAQAwFSpuAIBpUHGTuAEAZkLeplUOAICZUHEDAEyDVjmJGwBgIiRuWuUAAJgKFTcAwDSouEncAAATIXHTKgcAwC3//e9/NXLkSIWHhyswMFBXXXWVcnNznfsNw1BaWpqio6MVEBCgpKQk7d692+UcDodDU6ZMUUREhIKCgjR48GDl5+d7FAeJGwBgHhYvbh4oKipS9+7d5efnp3feeUdffvmlnnzySTVq1Mg5Z968eZo/f74WLlyonJwc2Ww29enTR0eOHHHOSUlJ0dq1a7V69WplZ2erpKREAwcOVEVFhdux0CoHAJhGXbXKH3/8cTVr1kxLly51jrVs2dL574ZhKDMzU7NmzdLQoUMlScuWLVNkZKRWrlyp8ePHq7i4WEuWLNHy5cvVu3dvSdKKFSvUrFkzbdq0Sf369XMrFipuAMDvksPh0OHDh102h8NR7dw333xTnTt31k033aQmTZqoY8eOevHFF5378/LyZLfb1bdvX+eY1WpVYmKitmzZIknKzc1VeXm5y5zo6GjFxcU557iDxA0AMA2LxeK1LSMjQyEhIS5bRkZGta+7Z88eLVq0SLGxsXr33Xc1YcIE3X333Xr55ZclSXa7XZIUGRnpclxkZKRzn91ul7+/v0JDQ884xx20ygEApuHNVvnMmTM1depUlzGr1Vrt3MrKSnXu3Fnp6emSpI4dO2r37t1atGiRbrvttjPGZxjGOWN2Z86vUXEDAH6XrFarGjZs6LKdKXFHRUWpXbt2LmOXX365fvjhB0mSzWaTpCqVc2FhobMKt9lsKisrU1FR0RnnuIPEDQAwjzpaVd69e3d98803LmPffvutWrRoIUmKiYmRzWbTxo0bnfvLysq0efNmdevWTZIUHx8vPz8/lzkFBQXatWuXc447aJUDAEyjrlaV33vvverWrZvS09M1bNgwffbZZ3rhhRf0wgsvOONKSUlRenq6YmNjFRsbq/T0dAUGBio5OVmSFBISorFjx2ratGkKDw9XWFiYUlNT1b59e+cqc3eQuAEAOIerr75aa9eu1cyZM/Xwww8rJiZGmZmZuuWWW5xzpk+frtLSUk2aNElFRUVKSEjQhg0bFBwc7JyzYMEC+fr6atiwYSotLVWvXr2UlZUlHx8ft2OxGIZhuDs5Pz9fixYt0pYtW2S322WxWBQZGalu3bppwoQJatasmdsvfLpOD79f42MBs/hoRo+6DgGodQ2stVcV2+54zWvnsr/4Z6+d60Jyu+LOzs5W//791axZM/Xt21d9+/aVYRgqLCzUunXr9Mwzz+idd95R9+7dazNeAMDvGPcq9yBx33vvvRo3bpwWLFhwxv0pKSnKycnxWnAAAMCV26vKd+3apQkTJpxx//jx47Vr1y6vBAUAQHW8eQMWs3I7cUdFRZ31lmyffPKJoqKivBIUAADVqqOvg11M3G6Vp6amasKECcrNzVWfPn0UGRkpi8Uiu92ujRs3avHixcrMzKzFUAEAgNuJe9KkSQoPD9eCBQv0/PPPOx9B5uPjo/j4eL388ssaNmxYrQUKAICZW9ze4tH3uIcPH67hw4ervLxcBw4ckCRFRETIz8+vVoIDAODXSNw1vAGLn58f17MBAKgD3DkNAGAaVNw8ZAQAAFOh4gYAmAcFN4kbAGAetMpr2Cpfvny5unfvrujoaO3bt0+SlJmZqTfeeMOrwQEAAFceV9yLFi3SQw89pJSUFD322GPO73M3atRImZmZuvHGG70eJM5tfGKMxifGuIwdKHGo7/z/5zJnaKdoBdf31a7/Htbcd77Vnv1HnfvDg/yV0qe1ElqFKsjfV3sPHtNL2Xv13lf7L9j7ADz10uLn9cF7G7U3b4+s1vrqcFVH3Z0yTS1jWjnnPP/sM3p3/dv62W6Xn5+fLm93hSZNSVH7DlfWYeSoCSruGlTczzzzjF588UXNmjXL5fmhnTt31s6dO70aHDzzfWGJ+jyZ7dyGPfeZc9+obs11S5dmevydb3Xr4m06WFKmRSOvUqD///4bPvLHdmoRHqh7V3+hYc99qve/3q+5f4pTW1uDung7gFs+35ajm0YkK2vFK3r2hZdUUXFCkyeMU+mxY845zVu01IwHHtQrr7+pJcv+rqjoSzR5wlgVHTpUh5GjJrhXeQ0Sd15enjp27Fhl3Gq16ujRo9UcgQulotLQwaNlzu2XY+XOfckJzbTk4716/+v9+s/+o3rojS9V36+e+sdFOud0aNpQr3yWr90/HdF/fzmuJR/v1ZHjJ3SZLbi6lwMuCgufW6zBNw7Vpa1j1abtZUp7OEP2gp/01Ze7nXP6DxikhC7d1LRpM13aOlZT77tfR0tK9N2339Rh5EDNeJy4Y2JitGPHjirj77zzjtq1a+eNmFBDzcMC9e693fXPKV2VMfQKXdKoviTpkkb11TjYqq17/lddlFcYyt33izo0C3GO7fihWH2vaKKG9X1lkdT3iiby97Uod98vF/idADVXUnJEktQwJKTa/eXlZXr9tVfUIDhYsW0vu5ChwQuouGtwjfu+++7T5MmTdfz4cRmGoc8++0yrVq1SRkaGFi9eXBsxwg07/1usB9d9qR8OHVNYkL/G/aGllo6J102LPlV4A39J0sGSMpdjDpWUKer/krsk3b9ml+b+KU4fTr9O5RWVOl5eqWmv7lR+UekFfS9ATRmGofl/naurOsardWwbl30fbf5AD0yfpuPHSxXRuLGeff4lhYaG1lGkqDHz5luv8Thx33777Tpx4oSmT5+uY8eOKTk5WZdccomeeuopjRgxwq1zOBwOORwOl7HKE2Wq5+vvaTj4P1u+//W1uqP6Ir9Yb07pqoFXRmlnfnH1B1ksMoz//TipRysFB/hqwvLtKjpWrh5tIzTvz3Eam/W5vi/kMggufo+nP6LvvvtGS7JWVtl39dUJWvWPtfqlqEhrX/+H7k9N0bK/v6qw8PA6iBSouRp9HeyOO+7Qvn37VFhYKLvdrh9//FFjx451+/iMjAyFhIS4bD9/vKomoeAMjpdX6vvCo2oeFuCstE9V3qeEBfnp4NGT+5qGBmjENc00582v9Vlekb77uUQvfLRXX/50RMM6N73g8QOempfxiD768H09v/hlRdpsVfYHBAaqWfMWan/lVXpozmPy8fXVurWv1UGkOB+0ys/zlqcRERFq0qSJx8fNnDlTxcXFLlvkH24+n1BwGj8fi2IiAnWgpEz//eW49h9xqEurMOd+33oWxbdopC9+PFmN1/c7+VEwfl2CS6o0DNUz7+cbvwOGYejx9If1/nsb9dziLF3S1L0/NA3DUHlZ2bkn4qJC4q5BqzwmJuasb3jPnj3nPIfVapXVanUZo01+flL6tNZH3x6Qvfi48xp3kNVX//q3XZK08tMfNebaFvrh4DH9cKhUY65toePllXpn18+SpL0HjumHg8c0a8BlWrDxOxWXnlBS2wgltArTPau+qMu3BpzV3Mce1vp3/qX5T/1NgUFBOnDg5H0HGjQIVv369VV67JiWvPicEpN6KqJxY/3yyy/6xyurVPizXb37Xl/H0QOe8zhxp6SkuPxcXl6u7du3a/369brvvvu8FRc8FBlsVcbQK9Qo0E9FR8u187/FGrVkmwqKj0uSlm35QfX9fHT/DW3VMODkDVgmrdihY2Unb6BzotLQlFX/1t29LlXmiCsV6O+jHw8d0+x1X+n/fX+wLt8acFavvXryMtudY25zGZ/9SLoG3zhU9Xx8tHdvnv417W79UlSkkEaNdMUV7bU46++6tHVsXYSM82DiQtlrLMbpvdEa+tvf/qZt27Zp6dKlNTq+08PveyMM4KL20YwedR0CUOsaWGsvu8bet95r5/rur+bsuHjtsZ79+/fXmjVrvHU6AABQDa89Hey1115TWFjYuScCAFBDtMprkLg7duzosjjNMAzZ7Xbt379fzz77rFeDAwDg18y8GtxbPE7cQ4YMcfm5Xr16aty4sZKSknTZZdw+EACA2uRR4j5x4oRatmypfv36yVbNDQ4AAKhNFNweLk7z9fXVxIkTq9yuFACAC6FePYvXNrPyeFV5QkKCtm/fXhuxAACAc/D4GvekSZM0bdo05efnKz4+XkFBQS77O3To4LXgAAD4NVrlHiTuMWPGKDMzU8OHD5ck3X333c59FotFhmHIYrGooqLC+1ECACBWlUseJO5ly5Zp7ty5ysvLq814AADAWbiduE/dGbVFixa1FgwAAGdDwe3hNW5aFACAukQe8jBxt2nT5py/tEOHDp1XQAAA4Mw8Stxz5sxRSEhIbcUCAMBZUXF7mLhHjBihJk2a1FYsAACcFXnbgxuw8FcOAAB1z+NV5QAA1BWKSA8Sd2VlZW3GAQDAOZG3a3CvcgAAfm/S0tJksVhctl8/JdMwDKWlpSk6OloBAQFKSkrS7t27Xc7hcDg0ZcoURUREKCgoSIMHD1Z+fr7HsZC4AQCmcXryPJ/NU1dccYUKCgqc286dO5375s2bp/nz52vhwoXKycmRzWZTnz59dOTIEeeclJQUrV27VqtXr1Z2drZKSko0cOBAj28V7vFDRgAAqCt12Sr39fV1qbJPMQxDmZmZmjVrloYOHSrp5G3CIyMjtXLlSo0fP17FxcVasmSJli9frt69e0uSVqxYoWbNmmnTpk3q16+f23FQcQMAfpccDocOHz7ssjkcjjPO/+677xQdHa2YmBiNGDFCe/bskSTl5eXJbrerb9++zrlWq1WJiYnasmWLJCk3N1fl5eUuc6KjoxUXF+ec4y4SNwDANLzZKs/IyFBISIjLlpGRUe3rJiQk6OWXX9a7776rF198UXa7Xd26ddPBgwdlt9slSZGRkS7HREZGOvfZ7Xb5+/srNDT0jHPcRascAGAa3myVz5w5U1OnTnUZs1qt1c7t37+/89/bt2+vrl276tJLL9WyZcvUpUuX/4vNNbhTj7s+G3fmnI6KGwDwu2S1WtWwYUOX7UyJ+3RBQUFq3769vvvuO+d179Mr58LCQmcVbrPZVFZWpqKiojPOcReJGwBgGnW5qvzXHA6HvvrqK0VFRSkmJkY2m00bN2507i8rK9PmzZvVrVs3SVJ8fLz8/Pxc5hQUFGjXrl3OOe6iVQ4AMI26WlWempqqQYMGqXnz5iosLNSjjz6qw4cPa9SoUbJYLEpJSVF6erpiY2MVGxur9PR0BQYGKjk5WZIUEhKisWPHatq0aQoPD1dYWJhSU1PVvn175ypzd5G4AQA4h/z8fN188806cOCAGjdurC5dumjr1q1q0aKFJGn69OkqLS3VpEmTVFRUpISEBG3YsEHBwcHOcyxYsEC+vr4aNmyYSktL1atXL2VlZcnHx8ejWCzGRXIT8k4Pv1/XIQC17qMZPeo6BKDWNbDWXlnc9fGPvHauT2Zc57VzXUhU3AAA0+Be5SxOAwDAVKi4AQCmwWM9SdwAABMhb9MqBwDAVKi4AQCmQaucxA0AMBESN61yAABMhYobAGAaFNwkbgCAidAqp1UOAICpUHEDAEyDgpvEDQAwEVrltMoBADAVKm4AgGlQcJO4AQAmUo/MTascAAAzoeIGAJgGBTeJGwBgIqwqp1UOAICpUHEDAEyjHgU3iRsAYB60ymmVAwBgKlTcAADToOAmcQMATMQiMjetcgAATISKGwBgGqwqJ3EDAEyEVeW0ygEAMBUqbgCAaVBwk7gBACbCYz1plQMAYCpU3AAA06DgJnEDAEyEVeW0ygEAMBUqbgCAaVBwk7gBACbCqnJa5QAAmAoVNwDANKi3SdwAABNhVTmtcgAATIXEDQAwjXoW723nIyMjQxaLRSkpKc4xwzCUlpam6OhoBQQEKCkpSbt373Y5zuFwaMqUKYqIiFBQUJAGDx6s/Px8z34H5xc6AAAXjsVi8dpWUzk5OXrhhRfUoUMHl/F58+Zp/vz5WrhwoXJycmSz2dSnTx8dOXLEOSclJUVr167V6tWrlZ2drZKSEg0cOFAVFRVuvz6JGwAAN5WUlOiWW27Riy++qNDQUOe4YRjKzMzUrFmzNHToUMXFxWnZsmU6duyYVq5cKUkqLi7WkiVL9OSTT6p3797q2LGjVqxYoZ07d2rTpk1ux0DiBgCYhsXiva0mJk+erAEDBqh3794u43l5ebLb7erbt69zzGq1KjExUVu2bJEk5ebmqry83GVOdHS04uLinHPcwapyAIBpeHNVucPhkMPhcBmzWq2yWq3Vzl+9erU+//xz5eTkVNlnt9slSZGRkS7jkZGR2rdvn3OOv7+/S6V+as6p491BxQ0A+F3KyMhQSEiIy5aRkVHt3B9//FH33HOPVqxYofr165/xnKf/YWEYxjn/2HBnzq+RuAEApuHNVeUzZ85UcXGxyzZz5sxqXzc3N1eFhYWKj4+Xr6+vfH19tXnzZj399NPy9fV1VtqnV86FhYXOfTabTWVlZSoqKjrjHLd+B578wgAAqEveXFVutVrVsGFDl+1MbfJevXpp586d2rFjh3Pr3LmzbrnlFu3YsUOtWrWSzWbTxo0bnceUlZVp8+bN6tatmyQpPj5efn5+LnMKCgq0a9cu5xx3cI0bAIBzCA4OVlxcnMtYUFCQwsPDneMpKSlKT09XbGysYmNjlZ6ersDAQCUnJ0uSQkJCNHbsWE2bNk3h4eEKCwtTamqq2rdvX2Wx29mQuAEApnEx3/B0+vTpKi0t1aRJk1RUVKSEhARt2LBBwcHBzjkLFiyQr6+vhg0bptLSUvXq1UtZWVny8fFx+3UshmEYtfEGPNXp4ffrOgSg1n00o0ddhwDUugbW2kuv417Z5bVzLR4ed+5JFyGucQMAYCK0ygEApsHDwUjcAAAT4bGetMoBADAVKm4AgGlQcJO4AQAmUo/MTascAAAzoeIGAJgGBTeJGwBgIqwqp1UOAICpXDQV95YHetZ1CECtC736rroOAah1pdsX1tq5qTYvosQNAMC50CrnjxcAAEyFihsAYBr1KLhJ3AAA8yBx0yoHAMBUqLgBAKbB4jQSNwDARGiV0yoHAMBUqLgBAKZBp5zEDQAwER7rSascAABToeIGAJgG1SaJGwBgInTK+eMFAABToeIGAJgGi9NI3AAAEyFv0yoHAMBUqLgBAKbBLU9J3AAAE+EaN61yAABMhYobAGAaFNwkbgCAiXCNm1Y5AACmQsUNADANiyi5SdwAANOgVU6rHAAAU6HiBgCYBhU3iRsAYCIWvg9GqxwAADOh4gYAmAatchI3AMBE6JTTKgcA4JwWLVqkDh06qGHDhmrYsKG6du2qd955x7nfMAylpaUpOjpaAQEBSkpK0u7du13O4XA4NGXKFEVERCgoKEiDBw9Wfn6+x7GQuAEAplHPYvHa5ommTZtq7ty52rZtm7Zt26aePXvqxhtvdCbnefPmaf78+Vq4cKFycnJks9nUp08fHTlyxHmOlJQUrV27VqtXr1Z2drZKSko0cOBAVVRUeBSLxTAMw6MjasnxE3UdAVD7Qq++q65DAGpd6faFtXbup7PzvHauu6+NOa/jw8LC9Ne//lVjxoxRdHS0UlJSNGPGDEknq+vIyEg9/vjjGj9+vIqLi9W4cWMtX75cw4cPlyT99NNPatasmd5++23169fP7del4gYAwAMVFRVavXq1jh49qq5duyovL092u119+/Z1zrFarUpMTNSWLVskSbm5uSovL3eZEx0drbi4OOccd7E4DQBgGt5cnOZwOORwOFzGrFarrFZrtfN37typrl276vjx42rQoIHWrl2rdu3aORNvZGSky/zIyEjt27dPkmS32+Xv76/Q0NAqc+x2u0dxU3EDAEyjnixe2zIyMhQSEuKyZWRknPG127Ztqx07dmjr1q2aOHGiRo0apS+//NK5//SbwxiGcc4bxrgz53RU3ACA36WZM2dq6tSpLmNnqrYlyd/fX61bt5Ykde7cWTk5OXrqqaec17XtdruioqKc8wsLC51VuM1mU1lZmYqKilyq7sLCQnXr1s2juKm4AQCmYbF4b7Narc6vd53azpa4T2cYhhwOh2JiYmSz2bRx40bnvrKyMm3evNmZlOPj4+Xn5+cyp6CgQLt27fI4cVNxAwBMo67unPbAAw+of//+atasmY4cOaLVq1frww8/1Pr162WxWJSSkqL09HTFxsYqNjZW6enpCgwMVHJysiQpJCREY8eO1bRp0xQeHq6wsDClpqaqffv26t27t0exkLgBADiHn3/+WbfeeqsKCgoUEhKiDh06aP369erTp48kafr06SotLdWkSZNUVFSkhIQEbdiwQcHBwc5zLFiwQL6+vho2bJhKS0vVq1cvZWVlycfHx6NY+B43cAHxPW78HtTm97hf2LrPa+e6s0sLr53rQqLiBgCYBvcqZ3EaAACmQsUNADANT+8x/ltE4gYAmAZ5m1Y5AACmQsUNADANqk0SNwDARDy9r/dvEX+8AABgIlTcAADToN4mcQMATISvg9EqBwDAVKi4AQCmQb1N4gYAmAidclrlAACYChU3AMA0+B43iRsAYCK0ifkdAABgKlTcAADToFVO4gYAmAhpm1Y5AACmQsUNADANWuUkbgCAidAm5ncAAICpUHEDAEyDVjmJGwBgIqRtWuUAAJgKFTcAwDTolJO4AQAmUo9mOa1yAADMhIobAGAatMpJ3AAAE7HQKqdVDgCAmVBxAwBMg1Y5iRsAYCKsKvdiq/zHH3/UmDFjvHU6AABQDa8l7kOHDmnZsmXeOh0AAFVYLN7bzMrtVvmbb7551v179uw572AAADgbMydcb3E7cQ8ZMkQWi0WGYZxxDk9tAQCgdrndKo+KitKaNWtUWVlZ7fb555/XZpwAAMjixX/Myu3EHR8ff9bkfK5qHACA81XP4r3NrNxuld933306evToGfe3bt1aH3zwgVeCAgAA1XM7cf/hD3846/6goCAlJiaed0AAAJyJmVvc3sItTwEAOIeMjAxdffXVCg4OVpMmTTRkyBB98803LnMMw1BaWpqio6MVEBCgpKQk7d6922WOw+HQlClTFBERoaCgIA0ePFj5+fkexULiBgCYRl19j3vz5s2aPHmytm7dqo0bN+rEiRPq27evyyXkefPmaf78+Vq4cKFycnJks9nUp08fHTlyxDknJSVFa9eu1erVq5Wdna2SkhINHDhQFRUV7v8OjItkRdnxE3UdAVD7Qq++q65DAGpd6faFtXbuD7855LVzJbUNq/Gx+/fvV5MmTbR582Zdd911MgxD0dHRSklJ0YwZMySdrK4jIyP1+OOPa/z48SouLlbjxo21fPlyDR8+XJL0008/qVmzZnr77bfVr18/t16bihsAAA8VFxdLksLCTib/vLw82e129e3b1znHarUqMTFRW7ZskSTl5uaqvLzcZU50dLTi4uKcc9zBQ0YAAKbhza9xORwOORwOlzGr1Sqr1XrW4wzD0NSpU3XttdcqLi5OkmS32yVJkZGRLnMjIyO1b98+5xx/f3+FhoZWmXPqeHfUqOJevny5unfvrujoaGdAmZmZeuONN2pyOlxAP//8s2bOSNV13RKUEH+lhg29UV/u3lXXYQFu+/qtOSrdvrDKtuD+YZKkWeNv0I7X/6IDW57UT5vn6a3n7tLVcS3OeL51CyeqdPtCDUrqcKHeAs6DN2/AkpGRoZCQEJctIyPjnDHcdddd+uKLL7Rq1aqq8Z128dwwjHPeVdSdOb/mccW9aNEiPfTQQ0pJSdFjjz3mvKDeqFEjZWZm6sYbb/T0lLhADhcXa/TIm9X5mgT97bkXFRYepvwff1RwcMO6Dg1w27Uj/yqfX5Vd7VpH6+3npuj1jdslSd/vK9S9j/9DefkHFGD105SRPfXPZ+9S3I1zdKCoxOVcU27poYtjlQ/qwsyZMzV16lSXsXNV21OmTNGbb76pjz76SE2bNnWO22w2SSer6qioKOd4YWGhswq32WwqKytTUVGRS9VdWFiobt26uR23xxX3M888oxdffFGzZs2Sj4+Pc7xz587auXOnp6fDBfTSkhcVabPpkccy1L5DB11ySVMldOmqZs2b13VogNsOFJXo54NHnNsNf4jTf37Yr49zv5MkvbJ+mz749Bvt/e9BfbXHrhlPvq6Q4ADFxUa7nKd9m0t098iempC2oi7eBmrIm6vKrVarGjZs6LKdKXEbhqG77rpLr7/+ut5//33FxMS47I+JiZHNZtPGjRudY2VlZdq8ebMzKcfHx8vPz89lTkFBgXbt2uVR4va44s7Ly1PHjh2rjFut1rPeWQ11b/MH76tb92uVeu/d2rYtR02aRGr4iGT96aZhdR0aUCN+vj4accPVenrF+2fcP3Zod/1y5Jh2fvtf53hAfT8tyxitex9/VT8fPFLtsbg41dXtVyZPnqyVK1fqjTfeUHBwsPOadEhIiAICAmSxWJSSkqL09HTFxsYqNjZW6enpCgwMVHJysnPu2LFjNW3aNIWHhyssLEypqalq3769evfu7XYsHifumJgY7dixQy1auF4zeuedd9SuXTtPT4cLKD//R736yirdOup2jb1zgnbt/EKPZzwqf39/DbpxSF2HB3hscI8OahQcoBX//NRlvP8f4vTy3NsVWN9P9gOHNXDCQh385Vfft532J239d57+9SFdQrhn0aJFkqSkpCSX8aVLl2r06NGSpOnTp6u0tFSTJk1SUVGREhIStGHDBgUHBzvnL1iwQL6+vho2bJhKS0vVq1cvZWVluXSwz8XjxH3fffdp8uTJOn78uAzD0GeffaZVq1YpIyNDixcvdusc1a3kM3zOvZIP56ey0tAVcXG6O+XkNZ3LL2+n/3z/vV59ZRWJG6Y0akg3vfv/vlTB/mKX8c053yphRIYiGjXQ7UO7acW8Mbru1ie0v6hEAxLbK+maNuoyYm4dRY3zUa+OHh/tzi1PLBaL0tLSlJaWdsY59evX1zPPPKNnnnmmxrF4fI379ttv1+zZszV9+nQdO3ZMycnJeu655/TUU09pxIgRbp2jupV8f3383Cv5cH4aN26sVpde6jLWqlUrFRT8VEcRATXXPCpUPRPaKmtd1e+/Hjtepj0/HtBnO/dq4pyVOlFRqVF/PHkNMenqNmrVNEL2j/6qIzlP6UjOU5KkVU+M07sv3nNB3wM8Z/HiZlY1+h73HXfcoTvuuEMHDhxQZWWlmjRp4tHx1a3kM3yotmvbVR07aW9ensvYvr17FR19SR1FBNTcrYO7qvDQEb3z8e5zzrXIIqvfyf/dPbF0g5audU32ua/N0vQn1+itzXw1Ehe/87oBS0RERI2Oq+4L7tzytPaNvG2URo28WYtfeE59+/XXrp1f6LXXXtVDaQ/XdWiARywWi267sYv+/q9PVVFR6RwPrO+vGeP66a3NO2U/UKywkCDdOew6XRLZSK9v/FySnKvRT/djQZH2/XTwgr0H1JCZS2UvqdHitLN9UXzPnj3nFRBqT1z7Dpr/1EI9nTlfzy/6my5p2lTTZzygAQMH13VogEd6JrRV86gwLVu31WW8orJSbVtGauSgBIU3CtKh4mPatnufeo9ZoK/2uH9nKly8eKxnDR4y8tRTT7n8XF5eru3bt2v9+vW67777dP/999coECpu/B7wkBH8HtTmQ0Y+/U/xuSe5KeHSEK+d60LyuOK+557qF2/87W9/07Zt2847IAAAzqSOFpVfVLz2dLD+/ftrzZo13jodAABVsKrci4n7tddecz7eDAAA1A6PW+UdO3Z0WZxmGIbsdrv279+vZ5991qvBAQDgwsylspd4nLiHDBni8nO9evXUuHFjJSUl6bLLLvNWXAAAVMGqcg8T94kTJ9SyZUv169fP+QgzAABw4Xh0jdvX11cTJ06scp9xAAAuBG8+1tOsPF6clpCQoO3bt9dGLAAAnBWrymtwjXvSpEmaNm2a8vPzFR8fr6CgIJf9HTp08FpwAADAlduJe8yYMcrMzNTw4cMlSXfffbdzn8VikWEYslgsqqio8H6UAABI5i6VvcTtxL1s2TLNnTtXeac9XQoAgAuFVeUeJO5TtzRv0aJFrQUDAADOzqNr3Gd7KhgAALWNNORh4m7Tps05k/ehQ4fOKyAAAM6EvO1h4p4zZ45CQsz5GDQAAH4LPErcI0aMUJMmTWorFgAAzo6S2/3EzfVtAEBdY1W5B3dOO7WqHAAA1B23K+7KysrajAMAgHOi+VuDW54CAFBXyNs1eMgIAACoO1TcAADzoOQmcQMAzINV5bTKAQAwFSpuAIBpsKqcxA0AMBHyNq1yAABMhYobAGAelNwkbgCAebCqnFY5AACmQsUNADANVpWTuAEAJkLeplUOAICpUHEDAMyDkpvEDQAwD1aV0yoHAMBUqLgBAKbBqnIqbgCAiVi8uHnqo48+0qBBgxQdHS2LxaJ169a57DcMQ2lpaYqOjlZAQICSkpK0e/dulzkOh0NTpkxRRESEgoKCNHjwYOXn53sUB4kbAAA3HD16VFdeeaUWLlxY7f558+Zp/vz5WrhwoXJycmSz2dSnTx8dOXLEOSclJUVr167V6tWrlZ2drZKSEg0cOFAVFRVux2ExDMM473fjBcdP1HUEQO0Lvfquug4BqHWl26tPbN7wn/2lXjvXpY0DanysxWLR2rVrNWTIEEknq+3o6GilpKRoxowZkk5W15GRkXr88cc1fvx4FRcXq3Hjxlq+fLmGDx8uSfrpp5/UrFkzvf322+rXr59br03FDQAwDYsX//GmvLw82e129e3b1zlmtVqVmJioLVu2SJJyc3NVXl7uMic6OlpxcXHOOe5gcRoA4HfJ4XDI4XC4jFmtVlmtVo/PZbfbJUmRkZEu45GRkdq3b59zjr+/v0JDQ6vMOXW8O6i4AQCmYbF4b8vIyFBISIjLlpGRcZ7xuVbyhmFUGTudO3N+jcQNADANb64qnzlzpoqLi122mTNn1igum80mSVUq58LCQmcVbrPZVFZWpqKiojPOcQeJGwDwu2S1WtWwYUOXrSZtckmKiYmRzWbTxo0bnWNlZWXavHmzunXrJkmKj4+Xn5+fy5yCggLt2rXLOccdXOMGAJhHHd6ApaSkRN9//73z57y8PO3YsUNhYWFq3ry5UlJSlJ6ertjYWMXGxio9PV2BgYFKTk6WJIWEhGjs2LGaNm2awsPDFRYWptTUVLVv3169e/d2Ow4SNwDANOryXuXbtm1Tjx49nD9PnTpVkjRq1ChlZWVp+vTpKi0t1aRJk1RUVKSEhARt2LBBwcHBzmMWLFggX19fDRs2TKWlperVq5eysrLk4+Pjdhx8jxu4gPgeN34PavN73PsOOs49yU0twmvWFq9rVNwAANPgXuUkbgCAiZC3WVUOAICpUHEDAEyDVjmJGwBgKmRuWuUAAJgIFTcAwDRolZO4AQAmQt6mVQ4AgKlQcQMATINWOYkbAGAidXmv8osFrXIAAEyEihsAYB4U3CRuAIB5kLdplQMAYCpU3AAA02BVOYkbAGAirCqnVQ4AgKlQcQMAzIOCm8QNADAP8jatcgAATIWKGwBgGqwqJ3EDAEyEVeW0ygEAMBUqbgCAadAqp+IGAMBUSNwAAJgIrXIAgGnQKidxAwBMhFXltMoBADAVKm4AgGnQKidxAwBMhLxNqxwAAFOh4gYAmAclN4kbAGAerCqnVQ4AgKlQcQMATINV5SRuAICJkLdplQMAYCpU3AAA86DkJnEDAMyDVeW0ygEAMBUqbgCAabCqXLIYhmHUdRC48BwOhzIyMjRz5kxZrda6DgeoFXzO8VtE4v6dOnz4sEJCQlRcXKyGDRvWdThAreBzjt8irnEDAGAiJG4AAEyExA0AgImQuH+nrFarZs+ezYId/KbxOcdvEYvTAAAwESpuAABMhMQNAICJkLgBADAREjeqSEtL01VXXVXXYQC1is85zIrEbRKjR4+WxWKRxWKRn5+fWrVqpdTUVB09erRO4vnhhx80aNAgBQUFKSIiQnfffbfKysrqJBb8dlxsn/N77rlH8fHxslqtJHlcNHjIiIlcf/31Wrp0qcrLy/Xxxx9r3LhxOnr0qBYtWlRlbnl5ufz8/GoljoqKCg0YMECNGzdWdna2Dh48qFGjRskwDD3zzDO18pr4/bhYPueSZBiGxowZo08//VRffPFFrb0O4AkqbhOxWq2y2Wxq1qyZkpOTdcstt2jdunWS/tf2e+mll9SqVStZrVYZhqHi4mLdeeedatKkiRo2bKiePXvq3//+t8t5586dq8jISAUHB2vs2LE6fvz4WePYsGGDvvzyS61YsUIdO3ZU79699eSTT+rFF1/U4cOHa+vt43fiYvmcS9LTTz+tyZMnq1WrVrXxVoEaIXGbWEBAgMrLy50/f//993r11Ve1Zs0a7dixQ5I0YMAA2e12vf3228rNzVWnTp3Uq1cvHTp0SJL06quvavbs2Xrssce0bds2RUVF6dlnnz3r637yySeKi4tTdHS0c6xfv35yOBzKzc31/hvF71pdfc6BixWtcpP67LPPtHLlSvXq1cs5VlZWpuXLl6tx48aSpPfff187d+5UYWGh885RTzzxhNatW6fXXntNd955pzIzMzVmzBiNGzdOkvToo49q06ZNZ61G7Ha7IiMjXcZCQ0Pl7+8vu93u7beK37G6/JwDFysqbhP517/+pQYNGqh+/frq2rWrrrvuOpdryi1atHD+z0yScnNzVVJSovDwcDVo0MC55eXl6T//+Y8k6auvvlLXrl1dXuf0n6tjqeZp9oZhVDsOeOJi+pwDFyMqbhPp0aOHFi1aJD8/P0VHR1dZlBMUFOTyc2VlpaKiovThhx9WOVejRo1qHIfNZtOnn37qMlZUVKTy8vIqlTjgqYvlcw5crEjcJhIUFKTWrVu7Pb9Tp06y2+3y9fVVy5Ytq51z+eWXa+vWrbrtttucY1u3bj3rebt27arHHntMBQUFioqKknRywZrValV8fLzb8QHVuVg+58DFilb5b1jv3r3VtWtXDRkyRO+++6727t2rLVu26C9/+Yu2bdsm6eT3VF966SW99NJL+vbbbzV79mzt3r37rOft27ev2rVrp1tvvVXbt2/Xe++9p9TUVN1xxx1q2LDhhXhrgFNtfc6lkwvhduzYIbvdrtLSUu3YsUM7duzgngWoU1Tcv2EWi0Vvv/22Zs2apTFjxmj//v2y2Wy67rrrnC3t4cOH6z//+Y9mzJih48eP609/+pMmTpyod99994zn9fHx0VtvvaVJkyape/fuCggIUHJysp544okL9dYAp9r6nEvSuHHjtHnzZufPHTt2lCTl5eWdsboHahuP9QQAwERolQMAYCIkbgAATITEDQCAiZC4AQAwERI3AAAmQuIGAMBESNwAAJgIiRsAABMhcQMAYCIkbgAATITEDQCAiZC4AQAwkf8PZNtqcqkj7UoAAAAASUVORK5CYII=",
-      "text/plain": [
-       "<Figure size 600x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "===== FOLD 4 =====\n",
-      "Val Loss=0.1166 | Val Acc=0.9489 | Val AUC=0.9913\n",
-      "\u001b[1m40/40\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 600x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "===== FOLD 5 =====\n",
-      "Val Loss=0.1385 | Val Acc=0.9571 | Val AUC=0.9910\n",
-      "\u001b[1m41/41\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 6ms/step\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 600x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 600x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "gkf = GroupKFold(n_splits=5) \n",
     "cv_histories = [] \n",
@@ -460,6 +299,53 @@
     "plt.show()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "97df9df1",
+   "metadata": {},
+   "source": [
+    "Results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9eae5c0f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#results\n",
+    "cv_results = np.array(cv_results) \n",
+    "print(\"\\n=== Cross-Validation Ergebnisse ===\") \n",
+    "print(f\"Durchschnittlicher Val-Loss: {cv_results[:,0].mean():.4f}\") \n",
+    "print(f\"Durchschnittliche Val-Accuracy: {cv_results[:,1].mean():.4f}\") \n",
+    "print(f\"Durchschnittliche Val-AUC: {cv_results[:,2].mean():.4f}\")\n",
+    "\n",
+    "#Ergebnis-Tabelle erstellen\n",
+    "results_table = pd.DataFrame({ \n",
+    "    \"Fold\": np.arange(1, len(cv_results)+1), \n",
+    "    \"Val Loss\": cv_results[:,0], \n",
+    "    \"Val Accuracy\": cv_results[:,1], \n",
+    "    \"Val AUC\": cv_results[:,2] }) \n",
+    "\n",
+    "# Durchschnittszeile hinzufügen \n",
+    "avg_row = pd.DataFrame({ \n",
+    "    \"Fold\": [\"Ø\"], \n",
+    "    \"Val Loss\": [cv_results[:,0].mean()], \n",
+    "    \"Val Accuracy\": [cv_results[:,1].mean()], \n",
+    "    \"Val AUC\": [cv_results[:,2].mean()] \n",
+    "}) \n",
+    "\n",
+    "results_table = pd.concat([results_table, avg_row], ignore_index=True) \n",
+    "\n",
+    "print(\"\\n=== Ergebnis-Tabelle ===\") \n",
+    "print(results_table) \n",
+    "\n",
+    "#Tabelle speichern \n",
+    "results_table.to_csv(\"cnn_crossVal_results.csv\", index=False) \n",
+    "print(\"Ergebnisse gespeichert als 'cnn_crossVal_results.csv'\")"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "7e564308",
@@ -470,22 +356,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "id": "9afc926b",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Finales Modell gespeichert.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "model_cv.save(\"hybrid_fusion_model_Test.keras\") \n",
-    "joblib.dump(scaler_au, \"scaler_au_Test.joblib\") \n",
-    "joblib.dump(scaler_eye, \"scaler_eye_Test.joblib\") \n",
+    "model_cv.save(\"hybrid_fusion_model_Test_group_split.keras\") \n",
+    "joblib.dump(scaler_au, \"scaler_au_Test_group_split.joblib\") \n",
+    "joblib.dump(scaler_eye, \"scaler_eye_Test_group_split.joblib\") \n",
     "\n",
     "print(\"Finales Modell gespeichert.\")"
    ]
@@ -500,59 +378,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "id": "0bb8c14c",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[1m50/50\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 8ms/step\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 600x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 700x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 700x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "F1-Score: 0.9851222104144527\n",
-      "Balanced Accuracy: 0.9809860091542237\n",
-      "Precision: 0.9809523809523809\n",
-      "Recall: 0.9893276414087513\n",
-      "AUC: 0.997147009306686\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Preprocessing Testdaten \n",
     "X_au_test_scaled = scaler_au.transform( \n",
@@ -596,6 +425,7 @@
     "plt.show() \n",
     "\n",
     "# Metriken \n",
+    "print(\"Accuracy:\", accuracy_score(y_test, y_pred_test))\n",
     "print(\"F1-Score:\", f1_score(y_test, y_pred_test)) \n",
     "print(\"Balanced Accuracy:\", balanced_accuracy_score(y_test, y_pred_test)) \n",
     "print(\"Precision:\", precision_score(y_test, y_pred_test)) \n",