diff --git a/TrainBkg/CreateInference.C b/TrainBkg/CreateInference.C
new file mode 100644
index 0000000..74355d8
--- /dev/null
+++ b/TrainBkg/CreateInference.C
@@ -0,0 +1,17 @@
+using namespace TMVA::Experimental;
+
+void CreateInference(){
+    string modelname = "model/TrainBkgDiag.h5";
+    string infername = "model/TrainBkgDiag.hxx";
+    
+    std::cout << "Attempting to parse: " << modelname << std::endl;
+
+    // In 6.30, we use the PyKeras sub-namespace directly
+    auto model = SOFIE::PyKeras::Parse(modelname);
+
+    // Generating inference code
+    model.Generate();
+    
+    std::cout << "Saving file " << infername << std::endl;
+    model.OutputGenerated(infername);
+}
diff --git a/TrainBkg/KKTrainBkgFiles.txt b/TrainBkg/KKTrainBkgFiles.txt
new file mode 100644
index 0000000..ff2b0e5
--- /dev/null
+++ b/TrainBkg/KKTrainBkgFiles.txt
@@ -0,0 +1,2 @@
+/TrainBkg/RootFiles/nts.owner.BD.version.sequence.root
+/TrainBkg/RootFiles/nts.owner.BD.pbar.sequence.root
diff --git a/TrainBkg/TrainBkgDiag.ipynb b/TrainBkg/TrainBkgDiag.ipynb
new file mode 100644
index 0000000..e13848a
--- /dev/null
+++ b/TrainBkg/TrainBkgDiag.ipynb
@@ -0,0 +1,1484 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "e706c0d1-30e1-4a19-a30d-fad24a5e2125",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import uproot \n",
+    "import awkward as ak\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import os\n",
+    "import datetime\n",
+    "import tensorflow as tf\n",
+    "from tensorflow.keras.callbacks import EarlyStopping\n",
+    "from tensorflow.keras.models import Sequential, Model\n",
+    "from tensorflow.keras.layers import Input, Dense, Dropout, Activation, ReLU\n",
+    "from tensorflow.keras.optimizers import SGD\n",
+    "import tensorflow.keras.layers\n",
+    "from tensorflow.keras.optimizers import Adam\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.metrics import roc_curve, roc_auc_score\n",
+    "from xgboost import XGBClassifier"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "db2a0eb2-2056-4dd4-bd05-03ad3a0d1905",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Using files in KKTrainBkgFiles.txt\n",
+      "Processing: /Users/namithachithirasree/Documents/LBL_projects/KKTrain/RootFiles/nts.owner.BD.version.sequence.root\n",
+      "Processed /Users/namithachithirasree/Documents/LBL_projects/KKTrain/RootFiles/nts.owner.BD.version.sequence.root: 2635262 hits\n",
+      "Processing: /Users/namithachithirasree/Documents/LBL_projects/KKTrain/RootFiles/nts.owner.BD.pbar.sequence.root\n",
+      "Processed /Users/namithachithirasree/Documents/LBL_projects/KKTrain/RootFiles/nts.owner.BD.pbar.sequence.root: 116799 hits\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Lists to store data from each file\n",
+    "input_list = []\n",
+    "signal_list = []\n",
+    "backgnd_list = []\n",
+    "kQ_list = []\n",
+    "\n",
+    "filelist = \"KKTrainBkgFiles.txt\"\n",
+    "print(\"Using files in \" + filelist)\n",
+    "\n",
+    "with open(filelist, 'r') as files:\n",
+    "    for filename in files:\n",
+    "        filename = filename.strip() # Clean up whitespace/newlines\n",
+    "        print(\"Processing: \" + filename)    \n",
+    "        with uproot.open(filename) as file:\n",
+    "            bkgdiag = file[\"BD\"][\"bkgcdiag\"].arrays()\n",
+    "            \n",
+    "            # Coordinate math\n",
+    "            mmomfX = file[\"BD\"][\"bkgcdiag\"]['mmom/fCoordinates/fCoordinates.fX'].array()\n",
+    "            mmomfY = file[\"BD\"][\"bkgcdiag\"]['mmom/fCoordinates/fCoordinates.fY'].array()\n",
+    "            mmomfZ = file[\"BD\"][\"bkgcdiag\"]['mmom/fCoordinates/fCoordinates.fZ'].array()\n",
+    "            mmomR = np.sqrt(mmomfX**2 + mmomfY**2 + mmomfZ**2)\n",
+    "\n",
+    "            # Apply filters\n",
+    "            mask = (bkgdiag['nactive']>=5) & (bkgdiag['np']>=2) & (\n",
+    "                   ((bkgdiag['prel']>=0) & (mmomR > 90)) | \n",
+    "                   ((bkgdiag['prel']<0) & (abs(bkgdiag['mpdg'])==11) & (mmomR < 20)) | \n",
+    "                   ((bkgdiag['prel']<0) & (abs(bkgdiag['mpdg'])==2212))\n",
+    "            )\n",
+    "            \n",
+    "            filtered_bkg = bkgdiag[mask]\n",
+    "            \n",
+    "            # Feature Selection (Z-variables as per your logic)\n",
+    "            temp = np.vstack((\n",
+    "                filtered_bkg['crho'].to_numpy(), \n",
+    "                filtered_bkg['zdiff'].to_numpy(), \n",
+    "                filtered_bkg['phidiff'].to_numpy(), \n",
+    "                filtered_bkg['nactive'].to_numpy(),\n",
+    "                filtered_bkg['rmscrho'].to_numpy(),\n",
+    "                filtered_bkg['rmsctime'].to_numpy(), \n",
+    "                filtered_bkg['rmscphi'].to_numpy(), \n",
+    "                filtered_bkg['clusterdensity'].to_numpy()\n",
+    "            )).T\n",
+    "\n",
+    "            # Extract labels and kQ\n",
+    "            prel = filtered_bkg['prel'].to_numpy()\n",
+    "            kQ = filtered_bkg['kQ'].to_numpy()\n",
+    "            \n",
+    "            # Store in lists\n",
+    "            input_list.append(temp)\n",
+    "            signal_list.append(prel == -2)\n",
+    "            backgnd_list.append(prel >= 0)\n",
+    "            kQ_list.append(kQ)\n",
+    "            \n",
+    "            print(f\"Processed {filename}: {temp.shape[0]} hits\")\n",
+    "\n",
+    "# Final Concatenation\n",
+    "input_dataset = np.concatenate(input_list)\n",
+    "signal = np.concatenate(signal_list)\n",
+    "backgnd = np.concatenate(backgnd_list)\n",
+    "kQ_all = np.concatenate(kQ_list) # Now kQ_all has the same length as signal/backgnd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "18b0923c-9be0-4e2f-9fb2-ba9dc4ea950f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training on 207104 matched hits\n",
+      "Total balanced samples: 414208\n",
+      "Splits complete: Train/Test/Valid distributions are equal.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Calculate length for balancing\n",
+    "# len(input_dataset[signal]) gives the total count of signal hits across ALL files\n",
+    "min_len = min(len(input_dataset[signal]), len(input_dataset[backgnd]))\n",
+    "bsize = 32\n",
+    "tsize = 2 * bsize\n",
+    "min_len = min_len - (min_len % tsize)\n",
+    "\n",
+    "print(f\"Training on {min_len} matched hits\")\n",
+    "\n",
+    "# Slice datasets using the full-length kQ_all\n",
+    "signal_dataset = input_dataset[signal][:min_len]\n",
+    "bkg_dataset = input_dataset[backgnd][:min_len]\n",
+    "\n",
+    "# FIX: Using the concatenated kQ_all ensures dimensions match\n",
+    "kQCE = kQ_all[backgnd][:min_len]\n",
+    "kQbkge = kQ_all[signal][:min_len]\n",
+    "\n",
+    "# Create balanced inputs\n",
+    "balanced_input = np.concatenate((signal_dataset, bkg_dataset))\n",
+    "y_balanced_input = np.concatenate((np.ones(len(signal_dataset)), np.zeros(len(bkg_dataset))))\n",
+    "\n",
+    "print(f\"Total balanced samples: {len(balanced_input)}\")\n",
+    "n_variables = balanced_input.shape[1]\n",
+    "# Train/Test/Valid Splits\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "\n",
+    "x_ce_train, x_ce_test, y_ce_train, y_ce_test = train_test_split(\n",
+    "    balanced_input, y_balanced_input, test_size=0.5, random_state=42\n",
+    ")\n",
+    "x_ce_test, x_ce_valid, y_ce_test, y_ce_valid = train_test_split(\n",
+    "    x_ce_test, y_ce_test, test_size=0.5, random_state=42\n",
+    ")\n",
+    "\n",
+    "print(\"Splits complete: Train/Test/Valid distributions are equal.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "4b19cb39-861d-4d88-bba8-4d016ccf24e2",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "clusters failed pre sel cuts 0\n",
+      "clusters pass pre sel cuts 116799\n",
+      "pass ratio 1.0\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<function matplotlib.pyplot.show(close=None, block=None)>"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "kQpresel = kQ[kQ==-1]\n",
+    "kQpass = kQ[kQ>-1]\n",
+    "print(\"clusters failed pre sel cuts\",len(kQpresel))\n",
+    "print(\"clusters pass pre sel cuts\",len(kQpass))\n",
+    "print(\"pass ratio\", len(kQpass) / len(kQ) )\n",
+    "plt.hist(kQCE,label=\"keras Quality CE\", log=1, bins=250,range=(0,1), density=True)\n",
+    "plt.hist(kQbkge,label=\"keras Quality BKGe\",histtype='step', log=1, bins=250,range=(0,1), density=True)\n",
+    "plt.legend()\n",
+    "plt.show"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "35df2ef5-6a2a-492a-9bc0-7a2032807fa3",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "clusterrho_sig = []\n",
+    "zdiff_sig = []\n",
+    "#deltaPhi_sig = []\n",
+    "phidiff_sig = []\n",
+    "fp_sig = []\n",
+    "lp_sig = []\n",
+    "pgap_sig = []\n",
+    "#nplanes_sig = []\n",
+    "#planefraction_sig = []\n",
+    "nhits_sig = []\n",
+    "rmscrho_sig = []\n",
+    "rmsctime_sig = []\n",
+    "rmscphi_sig = []\n",
+    "clusterdensity_sig = []\n",
+    "        \n",
+    "for i in range(signal_dataset.shape[0]):\n",
+    "    clusterrho_sig.append(signal_dataset[i][0])\n",
+    "    \n",
+    "for i in range(signal_dataset.shape[0]):\n",
+    "        zdiff_sig.append(signal_dataset[i][1])\n",
+    "    \n",
+    "for i in range(signal_dataset.shape[0]):\n",
+    "        phidiff_sig.append(signal_dataset[i][2])\n",
+    "\n",
+    "for i in range(signal_dataset.shape[0]):\n",
+    "        nhits_sig.append(signal_dataset[i][3])\n",
+    "    \n",
+    "for i in range(signal_dataset.shape[0]):\n",
+    "    rmscrho_sig.append(signal_dataset[i][4])\n",
+    "    \n",
+    "for i in range(signal_dataset.shape[0]):\n",
+    "    rmsctime_sig.append(signal_dataset[i][5])\n",
+    "\n",
+    "for i in range(signal_dataset.shape[0]):\n",
+    "    rmscphi_sig.append(signal_dataset[i][6])\n",
+    "\n",
+    "for i in range(signal_dataset.shape[0]):\n",
+    "    clusterdensity_sig.append(signal_dataset[i][7])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "8d3a0047-0597-45cf-8810-fe415f6dde10",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "clusterrho_back = []\n",
+    "zdiff_back = []\n",
+    "#deltaPhi_back = []\n",
+    "phidiff_back = []\n",
+    "fp_back = []\n",
+    "lp_back = []\n",
+    "pgap_back = []\n",
+    "#nplanes_back = []\n",
+    "#planefraction_back = []\n",
+    "nhits_back = []\n",
+    "rmscrho_back = []\n",
+    "rmsctime_back = []\n",
+    "rmscphi_back = []\n",
+    "clusterdensity_back = []\n",
+    "\n",
+    "for i in range(bkg_dataset.shape[0]):\n",
+    "    clusterrho_back.append(bkg_dataset[i][0])\n",
+    "\n",
+    "for i in range(bkg_dataset.shape[0]):\n",
+    "        zdiff_back.append(bkg_dataset[i][1])\n",
+    "    \n",
+    "for i in range(bkg_dataset.shape[0]):\n",
+    "        phidiff_back.append(bkg_dataset[i][2])\n",
+    "\n",
+    "for i in range(bkg_dataset.shape[0]):\n",
+    "        nhits_back.append(bkg_dataset[i][3])\n",
+    "          \n",
+    "for i in range(bkg_dataset.shape[0]):\n",
+    "    rmscrho_back.append(bkg_dataset[i][4]) \n",
+    "    \n",
+    "for i in range(bkg_dataset.shape[0]):\n",
+    "    rmsctime_back.append(bkg_dataset[i][5])\n",
+    "\n",
+    "for i in range(bkg_dataset.shape[0]):\n",
+    "    rmscphi_back.append(bkg_dataset[i][6])\n",
+    "\n",
+    "for i in range(bkg_dataset.shape[0]):\n",
+    "    clusterdensity_back.append(bkg_dataset[i][7])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "6bd3918c-0281-454d-b064-82d9e8c13fd3",
+   "metadata": {
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<function matplotlib.pyplot.show(close=None, block=None)>"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(clusterrho_sig,label=\"Cluster Rho Signal\", bins=400,range=(350,750))\n",
+    "plt.hist(clusterrho_back,label=\"Cluster Rho Background\", histtype='step', bins=400,range=(350,700))\n",
+    "plt.legend()\n",
+    "plt.show"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "7e22a484-3392-42c2-bfca-3f67d3788887",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<function matplotlib.pyplot.show(close=None, block=None)>"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(zdiff_sig,label=\"z_{diff} Signal\", bins=50,range=(0.0,3000.0))\n",
+    "plt.hist(zdiff_back,label=\"z_{diff} Background\", histtype='step', bins=50, range=(0.0,3000.0))\n",
+    "plt.legend()\n",
+    "plt.show"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "be53e8b2-fb1a-434e-b670-46a7e7f1b916",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<function matplotlib.pyplot.show(close=None, block=None)>"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(phidiff_sig,label=\"phiDiff Signal\", bins=50,range=(-0.5,0.5))\n",
+    "plt.hist(phidiff_back,label=\"phiDiff Background\", histtype='step', bins=50, range=(-0.5,0.5))\n",
+    "plt.legend()\n",
+    "plt.show"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "53d36a1d-0e47-4579-9d62-503ace534917",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<function matplotlib.pyplot.show(close=None, block=None)>"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(rmscphi_sig,label=\"RMS of Phi Signal\", log=1,bins=100, range=(0.,6.0))\n",
+    "plt.hist(rmscphi_back,label=\"RMS of Phi Background\",log=1, histtype='step', bins=100, range=(0.,6.0))\n",
+    "plt.legend()\n",
+    "plt.show"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "318a8509-dd37-4fdc-93f3-72e85e504108",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<function matplotlib.pyplot.show(close=None, block=None)>"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(nhits_sig,label=\"# of Hits Signal\", bins=100, range=(0.0,100.0))\n",
+    "plt.hist(nhits_back,label=\"# of Hits Background\", histtype='step', bins=100, range=(0.0,100.0))\n",
+    "plt.yscale('log')\n",
+    "plt.legend()\n",
+    "plt.show"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "575c67ab-3206-415f-8985-94904040e5a2",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<function matplotlib.pyplot.show(close=None, block=None)>"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAicAAAGdCAYAAADJ6dNTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABEZElEQVR4nO3de1yUVcIH8N8IMjjERSBBEBCviQi2oOYtwXU1vGS5n7JWEfNSBikuaV7YXdMy6vUStg2auWG1u+W2XnKNN8VN8YJ5IakUFd1IUCQWQkYkQeC8f/AyMjCDDMwwzzPz+34+fHKe58zznAPNzG/OOc95FEIIASIiIiKJ6GTpChARERE1xnBCREREksJwQkRERJLCcEJERESSwnBCREREksJwQkRERJLCcEJERESSwnBCREREkmJv6QoYq66uDoWFhXB2doZCobB0dYiIiKgVhBC4desWfHx80KlTy30jsgknarUaarUa1dXV+M9//mPp6hAREVEbFBQUoEePHi2WUcht+fry8nK4ubmhoKAALi4ulq4OERERtYJGo4Gfnx9u3rwJV1fXFsvKpuekQcNQjouLC8MJERGRzLRmSgYnxBIREZGkMJwQERGRpDCcEBERkaTIbs4JEVF7CSFQU1OD2tpaS1eFyGrY2dnB3t7eJMt8MJwQkU2prq7GjRs3UFlZaemqEFkdlUqF7t27w8HBoV3HYTghIptRV1eHvLw82NnZwcfHBw4ODlzMkcgEhBCorq7Gf//7X+Tl5aFv3773XWitJQwnRGQzqqurUVdXBz8/P6hUKktXh8iqdOnSBZ07d8bVq1dRXV0NR0fHNh+LE2KJyOa05xsdERlmqtcWX6FEREQkKQwnRERkUnv27EGfPn1gZ2eHxYsXt/k4hw8fhkKhwM2bN01Wt9bq2bMnkpOTO/y8ERER7fqdWQvOOSEim9dz+Rcder4f35xkVPnZs2fjww8/BADtZN5JkybhjTfeQNeuXbXlevbsiatXr+KTTz7BM888o3OMgQMHIicnB6mpqZg9ezYA4OzZs/jjH/+IU6dOQaPRwNvbG8OGDYNarYanp2eb2/fCCy/gueeew6JFi+Ds7Ky3TENdAcDR0REBAQGYO3culixZYvZJyrdv38aaNWvw2Wefae9yP3DgQCxZsgSTJ08GAJw+fRpOTk5mrQcZZpFwYm9vj+DgYABAeHg4tm3bZolqEBHJxmOPPYbU1FTU1NQgJycHc+bMwc2bN/HJJ5/olPPz80NqaqpOOPn6669RVFSk82FbXFyMcePGYcqUKdi/fz/c3NyQl5eHvXv3tusy64qKChQXF2PChAnw8fFpseyaNWswf/583LlzBwcPHsSLL74IFxcXvPDCC20+f2ssWLAAp06dwrvvvougoCCUlpYiMzMTpaWl2jIPPvigWetALbPIsI6bmxuys7ORnZ1tvcHkZgFQmH3v52aBhStERHKmVCrh7e2NHj16YPz48Zg+fToOHDjQrNyMGTOQkZGBgoJ77zkffPABZsyYAXv7e99HMzMzodFosG3bNjz88MMIDAzE2LFjkZycDH9/f4P1KCsrw6xZs9C1a1eoVCpERUXh8uXLAOqHYRp6SsaOHQuFQoHDhw8bPJazszO8vb3Rs2dPzJs3DyEhIXrblJWVhfDwcKhUKowYMQKXLl3S2b9582b07t0bDg4O6N+/Pz7++GOD5wSAf/3rX1i5ciUmTpyInj17IiwsDAsXLkRMTIy2TNNhnYsXL2LUqFFwdHREUFAQDh48CIVCgT179gAAfvzxRygUCuzatQuRkZFQqVQIDQ3FiRMntMcoLS3Fs88+ix49ekClUmHQoEHNwiXV45wTc7hZAKiHAlvH3PtRD2VAISKT+OGHH/Dll1+ic+fOzfZ5eXlhwoQJ2mGgyspK7NixA3PmzNEp5+3tjZqaGuzevRtCiFafe/bs2Thz5gz27t2LEydOQAiBiRMn4u7duzrBYefOnbhx4wZGjBhx32MKIXD48GFcuHBBb5sSExOxYcMGnDlzBvb29jpt2b17N+Lj4/Hyyy/j3Llz2iGlQ4cOGTyft7c30tLScOvWrVa1ua6uDk888QRUKhVOnjyJrVu3IjExUW/ZxMRELFmyBNnZ2ejXrx+effZZ1NTUAADu3LmDsLAw7Nu3D+fOncPzzz+P6OhonDx5slX1sCVGh5MjR45gypQp8PHx0UmNjaWkpCAwMBCOjo4ICwvD0aNHdfZrNBqEhYVh1KhRyMjIaHPlJauyFLhbCUx7H3g+o/6/dyvrtxMRtcG+ffvwwAMPoEuXLujduzdycnKwbNkyvWXnzJmD7du3QwiBf/7zn+jduzcGDx6sU+aRRx7BypUr8bvf/Q6enp6IiorCunXr8NNPPxmsw+XLl7F3715s27YNo0ePRmhoKP72t7/h+vXr2LNnDxwcHNCtWzcAgLu7O7y9vVtcKXTZsmV44IEHoFQqERkZCSEEFi1a1Kzc2rVrMWbMGAQFBWH58uXIzMzEnTt3AADr16/H7NmzERsbi379+iEhIQHTpk3D+vXrDZ5369atyMzMhIeHB4YMGYLf//73OH78uMHyBw4cwH/+8x989NFHCA0NxahRo7B27Vq9ZZcsWYJJkyahX79+WL16Na5evYorV64AAHx9fbFkyRIMHjwYvXr1wsKFCzFhwgR89tlnBs9tq4wOJ7dv30ZoaCjeffddvft37NiBxYsXIzExEWfPnsXo0aMRFRWF/Px8bZkff/wRWVlZ2LJlC2bNmgWNRtP2FkiZZz/AZ3D9f4mI2iEyMhLZ2dk4efKk9kNt4cKFestOmjQJFRUVOHLkCD744INmvSYN1q5di6KiImzZsgVBQUHYsmULHnroIXz//fd6y1+4cAH29vYYNmyYdpuHhwf69++PCxcuGN2mpUuXIjs7GxkZGYiMjERiYqLenpaQkBDtv7t37w6gfs5MQ51GjhypU37kyJEt1ufRRx/FDz/8gH//+9/47W9/i/Pnz2P06NF47bXX9Ja/dOkS/Pz84O3trd02dOhQvWVbqmttbS3Wrl2LkJAQeHh44IEHHsCBAwd0Ph+pntHhJCoqCq+//jqmTZumd//GjRsxd+5czJs3DwMGDEBycjL8/PywefNmbZmGSVLBwcEICgpCbm6uwfNVVVVBo9Ho/BAR2RonJyf06dMHISEheOedd1BVVYXVq1frLWtvb4/o6GisWrUKJ0+exIwZMwwe18PDA0899RQ2bNiACxcuwMfHx2Cvg6HhHyFEm66w8fT0RJ8+fTB8+HDs3LkTb7/9Ng4ePNisXOOhnobz1NXVNdtmTH06d+6M0aNHY/ny5Thw4ADWrFmD1157DdXV1c3KGtO+luq6YcMGvP3223jllVfw1VdfITs7GxMmTNB7Tltn0jkn1dXVyMrKwvjx43W2jx8/HpmZmQDqJ1NVVVUBAK5du4acnBz06tXL4DGTkpLg6uqq/fHz8zNllYmIZGnVqlVYv349CgsL9e6fM2cOMjIyMHXqVJ3LjVvi4OCA3r174/bt23r3BwUFoaamRmeORGlpKXJzczFgwADjG9FI165dsXDhQixZssSoOTADBgzAsWPHdLZlZmYaXZ+GtjUMFzX20EMPIT8/X2fI6/Tp00YdHwCOHj2KqVOnYubMmQgNDUWvXr20k4lJl0nDSUlJCWpra+Hl5aWz3cvLC0VFRQDqu+DCw8MRGhqKyZMnY9OmTXB3dzd4zBUrVqC8vFz703gGOhGRrYqIiMDAgQPxxhtv6N0/YMAAlJSUIDU1Ve/+ffv2YebMmdi3bx9yc3Nx6dIlrF+/HmlpaZg6dare5/Tt2xdTp07F/PnzcezYMXz77beYOXMmfH19DT7HGHFxcbh06RJ27tzZ6ucsXboU27dvx5YtW3D58mVs3LgRu3btwpIlSww+JyIiAu+99x6ysrLw448/Ii0tDStXrkRkZCRcXFyalf/Nb36D3r17IyYmBt999x2OHz+unRBrTI9Rnz59kJ6ejszMTFy4cAEvvPCC9rORdJllnZOWuthGjBhhcDxTH6VSCaVSadL6WcqkPx/DeXFd+9jYhZiIiBpLSEjAc889h2XLluntVfbw8DD43KCgIKhUKrz88ssoKCiAUqlE3759sW3bNkRHRxt8XmpqKuLj4zF58mRUV1fj0UcfRVpamt6rbIz14IMPIjo6Gq+++qrBqQNNPfHEE9i0aRPWrVuHRYsWITAwEKmpqYiIiDD4nIarmVauXInKykr4+Phg8uTJ+NOf/qS3vJ2dHfbs2YN58+ZhyJAh6NWrF9atW4cpU6YYdXO7P/7xj8jLy8OECROgUqnw/PPP44knnkB5eXmrj2ErFMKY/rOmT1YosHv3bjzxxBMA6od1VCoVPvvsMzz55JPacvHx8dpJT22lVquhVqtRW1uL3NxclJeX6024klCYXX/58PMZ9RNi///xpKq1OC8CtcUYTog61p07d5CXl6e9mpCorY4fP45Ro0bhypUr6N27t6WrIxktvcY0Gg1cXV1b9flt0p4TBwcHhIWFIT09XSecpKent7vLLy4uDnFxcdrGyUFDT8lARR6+sI7OHyIim7R792488MAD6Nu3L65cuYL4+HiMHDmSwcRMjA4nFRUV2mu2ASAvLw/Z2dlwd3eHv78/EhISEB0djfDwcAwfPhxbt25Ffn4+FixYYNKKExERdZRbt27hlVdeQUFBATw9PTFu3Dhs2LDB0tWyWkaHkzNnziAyMlL7OCEhAQAQExOD7du3Y/r06SgtLcWaNWtw48YNBAcHIy0tDQEBAaarNRERUQeaNWsWZs2aZelq2Ayjw0lERMR9L/OKjY1FbGxsmyulT+M5J0RERGS9ZHNvnbi4OOTk5LTp2nIiIiKSD9mEEyIiIrINZlnnxBysYVinj+K67oabBYAbV7wlIiJqTDbhRI6XEjcoE86oFEpsckjR3aFeC8SdYkAhIiJqRDbhRM4K4YlxVevQVXFLu62P4jo2IQWoLGU4ISIiaoThpIMUwhOFwtPS1SAifW4W1H9R6CgqD6v+UrJnzx4sWbIEeXl5WLhwIZKTk9t0nMOHDyMyMhJlZWVwc3MzaR07QkREBAYPHtzm9ktRR/1NGE6IyLbdLADUQ4G7lR13zs4qo4Z0Z8+ejQ8//BBA/X1efHx8MGnSJLzxxhs6dxzu2bMnrl69ik8++QTPPPOMzjEGDhyInJwcpKamYvbs2QCAs2fP4o9//CNOnToFjUYDb29vDBs2DGq1Gp6ebf8y9cILL+C5557DokWL4OzsrLdMQ10BwNHREQEBAZg7dy6WLFli1M302uLVV1/F6tWrtY9dXFwQEhKC119/HWPGjDHrual1ZBNOrGFCLBFJUGVpfTCZ9j7g2c/85yvJBXbNN3pI97HHHkNqaipqamqQk5ODOXPm4ObNm/jkk090yvn5+SE1NVUnnHz99dcoKiqCk5OTdltxcTHGjRuHKVOmYP/+/XBzc0NeXh727t2Lysq2B7WKigoUFxdjwoQJ8PHxabHsmjVrMH/+fNy5cwcHDx7Eiy++CBcXF7zwwgttPn9rDRw4EAcPHgQA/Pzzz1i/fj0mT56Ma9euSXpeY3V1NRwcHCxdDbOTzaXEXOeEiMzKs1/9jTrN/dPGAKRUKuHt7Y0ePXpg/PjxmD59Og4cONCs3IwZM5CRkYGCggLttg8++AAzZsyAvf2976OZmZnQaDTYtm0bHn74YQQGBmLs2LFITk6Gv7+/wXqUlZVh1qxZ6Nq1K1QqFaKionD58mUA9V3+DT0lY8eOhUKhwOHDhw0ey9nZGd7e3ujZsyfmzZuHkJAQvW3KyspCeHg4VCoVRowYgUuXLuns37x5M3r37g0HBwf0798fH3/8scFzNrC3t4e3tze8vb0RFBSE1atXo6KiArm5udoyGzduxKBBg+Dk5AQ/Pz/ExsaioqJC5zjHjx/HmDFjoFKp0LVrV0yYMAFlZWV6z/nll1/C1dUVH330EQCgpqYGixYtgpubGzw8PLBs2TLExMRob6YL1A8NvfTSS0hISICnpyd+85vfAAAyMjIwdOhQKJVKdO/eHcuXL0dNTY32eT179mw2nDR48GC8+uqr2scKhQLbtm3Dk08+CZVKhb59+2Lv3r06z0lLS0O/fv3QpUsXREZG4scff7zv79YUZBNOiIio3g8//IAvv/wSnTt3brbPy8sLEyZM0A4DVVZWYseOHZgzZ45OOW9vb9TU1GD37t33XfW7sdmzZ+PMmTPYu3cvTpw4ASEEJk6ciLt37+oEh507d+LGjRsYMWLEfY8phMDhw4dx4cIFvW1KTEzEhg0bcObMGdjb2+u0Zffu3YiPj8fLL7+Mc+fOaYeUDh061Oo2VVVVYfv27XBzc0P//v212zt16oR33nkH586dw4cffoivvvoKr7zyinZ/dnY2fv3rX2PgwIE4ceIEjh07hilTpujt4f/000/x9NNP46OPPtIug//WW2/hb3/7G1JTU3H8+HFoNBrs2bOn2XM//PBD2Nvb4/jx43jvvfdw/fp1TJw4EUOGDMG3336LzZs34y9/+Qtef/31Vre5werVq/H000/ju+++w8SJEzFjxgz8/PPPAICCggJMmzYNEydORHZ2NubNm4fly5cbfY42ETJTXl4uAIjy8nJLV8Ww62eFWOUiJi7/swhYtk/vz8TlfxZilUt9WSLqEL/88ovIyckRv/zyy72N//967bDXYhvOFxMTI+zs7ISTk5NwdHQUAAQAsXHjRp1yAQEB4u233xZ79uwRvXv3FnV1deLDDz8UDz/8sBBCCFdXV5Gamqotv3LlSmFvby/c3d3FY489Jv7nf/5HFBUVGaxHbm6uACCOHz+u3VZSUiK6dOki/vGPfwghhCgrKxMAxKFDh1psU0BAgHBwcBBOTk6ic+fOAoBwdHTUOfahQ4cEAHHw4EHtti+++EIA0P4NR4wYIebPn69z7KeeekpMnDjR4LlXrVolOnXqJJycnISTk5NQKBTCxcVF/O///m+Ldf7HP/4hPDw8tI+fffZZMXLkSIPlx4wZI+Lj44VarRaurq7iq6++0tnv5eUl1q1bp31cU1Mj/P39xdSpU3WOMXjwYJ3nrVy5UvTv31/U1dVpt6nVavHAAw+I2tpaIcS9/xcaCw0NFatWrdI+BiD+8Ic/aB9XVFQIhUKh/T2sWLFCDBgwQOc8y5YtEwBEWVmZ3jbrfY39P2M+v9lzQkQkA5GRkcjOzsbJkyexcOFCTJgwAQsXLtRbdtKkSaioqMCRI0fwwQcfNOs1abB27VoUFRVhy5YtCAoKwpYtW/DQQw/h+++/11v+woULsLe3x7Bhw7TbPDw80L9/f1y4cMHoNi1duhTZ2dnIyMhAZGQkEhMT9fa0hISEaP/dvXt3APVzZhrqNHLkSJ3yI0eOvG99+vfvj+zsbGRnZyMrKwsvvvginnrqKZw5c0Zb5tChQ/jNb34DX19fODs7Y9asWSgtLcXt27cB3Os5acnOnTuxePFiHDhwQOemueXl5fjpp58wdOhQ7TY7OzuEhYU1O0Z4eLjO4wsXLmD48OE6E4dHjhyJiooKXLt2rcX6NNX4d+vk5ARnZ2ed3+0jjzyic57hw4cbdfy2kk04UavVCAoKwpAhQyxdFSKiDufk5IQ+ffogJCQE77zzDqqqqnSuOGnM3t4e0dHRWLVqFU6ePIkZM2YYPK6HhweeeuopbNiwARcuXICPjw/Wr1+vt6wwMPwjhGjTFTaenp7o06cPhg8fjp07d+Ltt9/WTlJtrPFQT8N56urqmm0zpj4ODg7o06cP+vTpg4cffhhvvvkmfH19tfM0rl69iokTJyI4OBg7d+5EVlYW1Go1AODu3bsAgC5duty3jYMHD8aDDz6I1NRUvb8/fXVvqvFEZkPta3hew/ZOnTo1O1ZDvRtrOoymUCi0v1tDf++OIJtwwgmxRET3rFq1CuvXr0dhYaHe/XPmzEFGRgamTp2qc7lxSxwcHNC7d29tz0BTQUFBqKmpwcmTJ7XbSktLkZubiwEDBhjfiEa6du2KhQsXYsmSJUZ9KA4YMADHjh3T2ZaZmdmm+tjZ2eGXX34BAJw5cwY1NTXYsGEDHnnkEfTr16/Z7zokJAT//ve/Wzxm7969cejQIXz++ec6PV2urq7w8vLCqVOntNtqa2tx9uzZ+9YzKCgImZmZOr+nzMxMODs7w9fXFwDw4IMP4saNG9r9Go0GeXl59z120/N8/fXXOtuaPjYX2YQTIiK6JyIiAgMHDsQbb7yhd/+AAQNQUlKC1NRUvfv37duHmTNnYt++fcjNzcWlS5ewfv16pKWlYerUqXqf07dvX0ydOhXz58/HsWPH8O2332LmzJnw9fU1+BxjxMXF4dKlS9i5c2ern7N06VJs374dW7ZsweXLl7Fx40bs2rULS5YsafF5NTU1KCoqQlFRES5fvozXX38dOTk52nb07t0bNTU1+POf/4wffvgBH3/8MbZs2aJzjBUrVuD06dOIjY3Fd999h4sXL2Lz5s0oKSnRKdevXz8cOnRIO8TTYOHChUhKSsLnn3+OS5cuIT4+HmVlZfft9YmNjUVBQQEWLlyIixcv4vPPP8eqVauQkJCATp3qP9bHjh2Ljz/+GEePHsW5c+cQExMDOzu71v5aAQALFizAf/7zHyQkJODSpUv4+9//ju3btxt1jLaSzTonRERmVZJ7/zISO09CQgKee+45LFu2DH5+zddM8fDwMPjcoKAgqFQqvPzyyygoKIBSqUTfvn2xbds2REdHG3xeamoq4uPjMXnyZFRXV+PRRx9FWlqa3qtsjPXggw8iOjoar776KqZNm9aq5zzxxBPYtGkT1q1bh0WLFiEwMBCpqamIiIho8Xnnz5/Xzl9RqVTo3bs3Nm/erL2SZvDgwdi4cSPeeustrFixAo8++iiSkpK0+4H60HHgwAGsXLkSQ4cORZcuXTBs2DA8++yzzc7Xv39/fPXVV4iIiICdnR02bNiAZcuWoaioCLNmzYKdnR2ef/55TJgw4b4hwtfXF2lpaVi6dClCQ0Ph7u6OuXPn4g9/+IO2zIoVK/DDDz9g8uTJcHV1xWuvvWZ0z4m/vz927tyJ3//+90hJScHQoUPxxhtvGJzDZEoKYclBpTZouPFfeXk5XFxcLF0d/Qqzga1jMKlqLc6LQL1FBiry8IUyEXg+o37tAyIyuzt37iAvLw+BgYFwdHSs3yiDFWLJNtTV1WHAgAF4+umn8dprr1m6Om2i9zX2/4z5/GbPCRHZNje/+qDAe+tQB7t69SoOHDiAMWPGoKqqCu+++y7y8vLwu9/9ztJVsziGEyIiNz+GBepwnTp1wvbt27WTgIODg3Hw4MF2Ty62BrIJJ7y3DhERWRM/Pz8cP37c0tWQJNlcrcNLiYmIiGyDbMIJERER2QaGEyKyOTK7SJFINkz12mI4ISKb0bAWR2VlB142TGRDGl5b7V33RjYTYomI2svOzg5ubm7aG5upVKo23ROGiHQJIVBZWYni4mK4ubkZvRptUwwnRGRTvL29Ady7qy0RmY6bm5v2NdYeDCdEZFMUCgW6d++Obt266b1LKxG1TefOndvdY9JANuGE65wQkSnZ2dmZ7I2UiExLNhNiuc4JERGRbZBNOCEiIiLbwHBCREREksJwQkRERJLCcEJERESSwnBCREREksJwQkRERJLCcEJERESSwnBCREREksJwQkRERJLCcEJERESSIptwolarERQUhCFDhli6KkRERGRGsgknvLcOERGRbZBNOCEiIiLbwHBCREREksJwQkRERJLCcEJERESSwnBCREREksJwQkRERJLCcEJERESSwnBCREREksJwQkRERJLCcEJERESSwnBCREREksJwQkRERJJisXBSWVmJgIAALFmyxFJVICIiIgmyWDhZu3Ythg0bZqnTExERkURZJJxcvnwZFy9exMSJEy1xeiIiIpIwo8PJkSNHMGXKFPj4+EChUGDPnj3NyqSkpCAwMBCOjo4ICwvD0aNHdfYvWbIESUlJba605NwsAAqz7/2U5Fq4QkRERPJlb+wTbt++jdDQUDz33HP47W9/22z/jh07sHjxYqSkpGDkyJF47733EBUVhZycHPj7++Pzzz9Hv3790K9fP2RmZpqkERZ1swCVb4dBpajS2VwplCgTzhaqFBERkXwZHU6ioqIQFRVlcP/GjRsxd+5czJs3DwCQnJyM/fv3Y/PmzUhKSsLXX3+NTz/9FJ999hkqKipw9+5duLi44E9/+pPe41VVVaGq6t4Hv0ajMbbK5lVZCpWiCvHVsbgifLWby4QzCuFpwYoRERHJk9HhpCXV1dXIysrC8uXLdbaPHz9e20uSlJSkHdLZvn07zp07ZzCYNJRfvXq1KatpFleEL86LQKOfN+nPx3BeXAcA/PjmJFNXi4iISHZMOiG2pKQEtbW18PLy0tnu5eWFoqKiNh1zxYoVKC8v1/4UFBSYoqpEREQkUSbtOWmgUCh0Hgshmm0DgNmzZ9/3WEqlEkql0lRVIyIiIokzaTjx9PSEnZ1ds16S4uLiZr0pxlKr1VCr1aitrW3XcaSmj+L6vQc3CwA3P8tVhoiISAJMOqzj4OCAsLAwpKen62xPT0/HiBEj2nXsuLg45OTk4PTp0+06jlSUCWdUCiU2OaTgC2UivlAmAuqh9QGFiIjIhhndc1JRUYErV65oH+fl5SE7Oxvu7u7w9/dHQkICoqOjER4ejuHDh2Pr1q3Iz8/HggULTFpxuSuEJ8ZVrUNXxS0A9T0om5ACVJay94SIiGya0eHkzJkziIyM1D5OSEgAAMTExGD79u2YPn06SktLsWbNGty4cQPBwcFIS0tDQEBAuypqjcM6hfBEoeDlxkRERI0phBDC0pUwhkajgaurK8rLy+Hi4mLp6tSvCLt1DCZVrW3TpcQNBiry6od2ns8AfAabrHpERERSYMznt8Vu/EdERESkD8MJERERSYpswolarUZQUBCGDBli6aoQERGRGckmnFjbpcRERESkn2zCCREREdkGhhMiIiKSFNmEE845ISIisg2yCSecc0JERGQbZBNOiIiIyDYwnBAREZGkMJwQERGRpDCcEBERkaTIJpzwah0iIiLbIJtwwqt1iIiIbINswgkRERHZBoYTIiIikhSGEyIiIpIUhhMiIiKSFNmEE16tQ0REZBtkE054tQ4REZFtkE04ISIiItvAcEJERESSwnBCREREksJwQkRERJLCcEJERESSwnBCREREkiKbcMJ1ToiIiGyDbMIJ1zkhIiKyDbIJJ0RERGQbGE6IiIhIUhhOiIiISFIYToiIiEhSGE6IiIhIUhhOiIiISFIYToiIiEhSGE6IiIhIUhhOiIiISFIYToiIiEhSZBNOeG8dIiIi2yCbcMJ76xAREdkG2YQTIiIisg32lq4ANVGSq/tY5QG4+VmmLkRERBbAcCIRZcIZ6KwCds3X3dFZBcSdYkAhIiKbwXAiEYXwrA8hlaX3Npbk1oeVylKGEyIishkMJ1Li5scQQkRENo8TYomIiEhSGE6IiIhIUhhOiIiISFIYToiIiEhSOCFWQnou/0Ln8UBFHr5QWqgyREREFsKeEyIiIpIUhhMiIiKSlA4PJ7du3cKQIUMwePBgDBo0CO+//35HV4GIiIgkrMPnnKhUKmRkZEClUqGyshLBwcGYNm0aPDw8OroqREREJEEd3nNiZ2cHlUoFALhz5w5qa2shhOjoahAREZFEGR1Ojhw5gilTpsDHxwcKhQJ79uxpViYlJQWBgYFwdHREWFgYjh49qrP/5s2bCA0NRY8ePfDKK6/A09OzzQ0gIiIi62J0OLl9+zZCQ0Px7rvv6t2/Y8cOLF68GImJiTh79ixGjx6NqKgo5Ofna8u4ubnh22+/RV5eHv7+97/jp59+ansLiIiIyKoYHU6ioqLw+uuvY9q0aXr3b9y4EXPnzsW8efMwYMAAJCcnw8/PD5s3b25W1svLCyEhIThy5IjB81VVVUGj0ej8EBERkfUy6ZyT6upqZGVlYfz48Trbx48fj8zMTADATz/9pA0YGo0GR44cQf/+/Q0eMykpCa6urtofPz/etZeIiMiamTSclJSUoLa2Fl5eXjrbvby8UFRUBAC4du0aHn30UYSGhmLUqFF46aWXEBISYvCYK1asQHl5ufanoKDAlFUmIiIiiTHLpcQKhULnsRBCuy0sLAzZ2dmtPpZSqYRSyTXciYiIbIVJe048PT1hZ2en7SVpUFxc3Kw3xVhqtRpBQUEYMmRIu45DRERE0mbScOLg4ICwsDCkp6frbE9PT8eIESPadey4uDjk5OTg9OnT7ToOERERSZvRwzoVFRW4cuWK9nFeXh6ys7Ph7u4Of39/JCQkIDo6GuHh4Rg+fDi2bt2K/Px8LFiwwKQVJyIiIutkdDg5c+YMIiMjtY8TEhIAADExMdi+fTumT5+O0tJSrFmzBjdu3EBwcDDS0tIQEBDQroqq1Wqo1WrU1ta26zhEREQkbQohs7XjNRoNXF1dUV5eDhcXF0tXByjMBraOwaSqtTgvAk166IGKPHyhTASezwB8Bpv02ERERB3JmM/vDr+3DhEREVFLGE6IiIhIUmQTTngpMRERkW2QTTjhpcRERES2QTbhhIiIiGwDwwkRERFJCsMJERERSYpswgknxBIREdkG2YQTToglIiKyDbIJJ0RERGQbGE6IiIhIUhhOiIiISFJkE044IZaIiMg2yCaccEIsERGRbZBNOCEiIiLbYG/pClArlOTe+7fKA3Dzs1xdiIiIzIzhRMLKhDMqhRKqXfPvbeysAuJOMaAQEZHVYjiRsEJ4YlzVOnRV3AIA9FFcxyakAJWlDCdERGS1GE4krhCeKBSelq4GERFRh5HNhFheSkxERGQbZBNOeCkxERGRbZBNOCEiIiLbwHBCREREksJwQkRERJLCcEJERESSwnBCREREksJwQkRERJIim3DCdU6IiIhsg2zCCdc5ISIisg2yCSdERERkGxhOiIiISFIYToiIiEhSGE6IiIhIUhhOiIiISFIYToiIiEhSGE6IiIhIUhhOiIiISFIYToiIiEhSGE6IiIhIUmQTTnhvHSIiItsgm3DCe+sQERHZBtmEEyIiIrINDCdEREQkKQwnREREJCkMJ0RERCQpDCdEREQkKQwnREREJCn2lq4AtUFJru5jlQfg5meZuhAREZkYw4mMlAlnoLMK2DVfd0dnFRB3igGFiIisAsOJjBTCsz6EVJbe21iSWx9WKksZToiIyCownMiNmx9DCBERWTVOiCUiIiJJYTghIiIiSenwcFJQUICIiAgEBQUhJCQEn332WUdXgYiIiCSsw+ec2NvbIzk5GYMHD0ZxcTF+9atfYeLEiXBycuroqshSz+Vf6DweqMjDF0oLVYaIiMgMOjycdO/eHd27dwcAdOvWDe7u7vj5558ZToiIiAhAG4Z1jhw5gilTpsDHxwcKhQJ79uxpViYlJQWBgYFwdHREWFgYjh49qvdYZ86cQV1dHfz8ePUJERER1TM6nNy+fRuhoaF499139e7fsWMHFi9ejMTERJw9exajR49GVFQU8vPzdcqVlpZi1qxZ2Lp1a9tqTkRERFbJ6GGdqKgoREVFGdy/ceNGzJ07F/PmzQMAJCcnY//+/di8eTOSkpIAAFVVVXjyySexYsUKjBgxosXzVVVVoaqqSvtYo9EYW2UiInm4WaC7yKI+5rxdRdPz89YYZCEmnXNSXV2NrKwsLF++XGf7+PHjkZmZCQAQQmD27NkYO3YsoqOj73vMpKQkrF692pTVJCIr1HSy+I9vTrJQTdroZgGgHgrcrWy5nLluV6Hv/Lw1BlmIScNJSUkJamtr4eXlpbPdy8sLRUVFAIDjx49jx44dCAkJ0c5X+fjjjzFo0CC9x1yxYgUSEhK0jzUaDeeoEJH1qSytDwbT3gc8++kv057bVdyvV6Tp+XlrDLIgs1yto1AodB4LIbTbRo0ahbq6ulYfS6lUQqnktbJEJHP6hmz0DZt49gN8Bpv+3K3tFTHH+YmMZNJw4unpCTs7O20vSYPi4uJmvSnGUqvVUKvVqK2tbddxiMh2WWzox9CQjamGTdraK5J/4t7zSnLbVwciEzJpOHFwcEBYWBjS09Px5JNParenp6dj6tSp7Tp2XFwc4uLioNFo4Orq2t6qEpGVaxpELErfkI2phk3a0iui8qgvs2u+7v7Oqvp97cWJtdRORoeTiooKXLlyRfs4Ly8P2dnZcHd3h7+/PxISEhAdHY3w8HAMHz4cW7duRX5+PhYsWGDSihOR7ZDlZNfGH9ANvRKmGjJp3MtRkmt8r4ibX314ac0wk7E4sZZMwOhwcubMGURGRmofN0xWjYmJwfbt2zF9+nSUlpZizZo1uHHjBoKDg5GWloaAgIB2VZTDOkQkG4Y+oPX1SjQEh9YMq7TU4+E/vP7Dv7W9Im5+pgkLTXtJDIUlTqwlIxgdTiIiIiCEaLFMbGwsYmNj21wpfTisQ0RScd+eHH3DOE17JfSFiPsNq7Smx8OcvSJNtTSXpiEsEbVBh99bh4hIykw6hNTSMI6+ENGaANGaHg9T9YoALffoNO0lacA5JtRODCdEZBL6JqC25oO9LWHAVJNdO3LSrMHfj1Q/xA0NDzXV2l6SpiGHAYZaIJtwwjknRGQMH5Sgq+KWzrYy4YxCeJr+2DcLrO+D1tDwUFP3CxktzYHhJFkyQDbhhHNOiIzX1t4MufNBCQ4ql0KlqNLZXimUWHB3MUqFi8HnNgswTSd8Vuo5tnqtdX7QmmJ4SF/I4SRZug/ZhBMia2WrAcKcuipuQaWoQnx1LK4IXwCAh0KDLZ2T8ZHDWy0+t1IoMa5qHQrhCR+UGLjfjRKzqpehVLigj+I6NiHFbAuayfIy6qYMhZzGvycO81AjDCdEZLWuCF+cF4H1DwQwrmpds6GexvoormOTQwqGdLqIK8IXfRTX9U74HPfOt9relTLhbLIFzSS1cJw5GbpSyRp7n6hNZBNOOOeEiNqrEJ4oFIbnnJQJZ1QKJTY5pNzbqGfCZyGu6xxzxK03m4WeLxZPNcsHbWsCjOR7V5oO9XCYh5qQTTjhnBMiMrdCeDbrXWlNyNAXenq++R2A71p8niWvFtIXYDp0CMmUlzuT1ZFNOKGWTfrzMZwX9d/mJP+tiUjCmgUNfoDqsIo5MCR5DCdk9az1zVQSa3SY4Dim0vjy3j6K6/cpTeZcK8ZaXmNkOQwnRHqYc1y/LR8KNjNRso30XTpcKZT1k1WJSHYYTojMiKGiY+i7dNhUC64RUceTTTjh1TokBwwjujq6l0jn0mETseW/qS23nSxLNuGEV+sQmYep7onTkZouH885JtJirfO8qOPIJpwQmQq/DRrPnPepaUtdDC1Nzzkm8tH4dThQkYcvlODNAUmL4YRIgswZoFpz7MZlWgoDDcu8dyR980sAzjFpTG4BvMVVdrlqrE1iOCGiFukLAw3LvHdV3GpxxVVzMsf8ErKMQnjy5oCkg+GEzI7rIFgHhgEyK64YS43IJpzwah3rYg0T5uTWdW4OjSeitmZYpa1zV7jAmrzJ8bXCL1WWJZtwwqt1Wqbzhn2zoMO+gZjzBSy5e4HYkPuFAX03yNM3B6XxcTwUGmzpnHzfuStNA4y+53HyK5F1k004If303kVVvdZsk8jM9Q1Ijt+srFVrVltteoM8fXNQDB1nVvUylAoXvc9rafJt4+dx8quNulmgOy8FwIh3vtX5f4FfUKwDw4nM6f2QQIrNTiJjyGm/1q62qu9OvG05zv2e05rnkQ24WQCohwJ3K3U2H1Ra5qoxMi+GEytwvw8JorYw1QTYthyHk29Jq2Htk5Jc4G6l5K4aI/NgOCGD2AthG0y52mrj53LiKhmj6fuND0qQ6ay79kmlUOJ03UPsJbEBDCc2wpx32SX5MtVqq3rnPrXhOEQNCuGJEbfe1AnOHN6zHQwnpMWeEttjqjkeTec+tfU4RI115JA13/+kRTbhhOucEJmPKeZ4cO4TEZmKbMIJ1zkhW/5mI6Ub7xFJzf3WeeJ6SPIjm3BCZKtMfeM9rrZK1qKj13mijsNwQiRxLd14b0ini61eQwRo3QJrltAQkhiWyBhc58l6MZxYqUl/PobzwjJv9LY8/GJOjeeFtHb5+KbasjCaORlqh6XDEskH5zpZJ4YTIgm639CLoeXjG/ekAIaDh1QWOdN3lQ/n0hARwwmRxLR26KXxN8aW1hmR+tLe/OZLcsGJtR2H4YRIYtoy9KKvB0JfbwrndBCRHDCcEFmYoeXjjR16adoDwVVbiUiuGE6ILMhUy8frw1VbiUiuGE6IOljTya6mWD7eEM7nICI5Yjgh6kCGJrvyTqtEJlSSq/PQByU6ry9TLXeg7zicJGsasgknvLcOyUHT+SNNe0Ckts4IkTVpmGel2jVfZ/tBpfSvWiNdsgknvLcOSZ2hXhF9b4pSWWeEyJq0dNVaV8WtDhni5OXGpiGbcEIkdU17RTr6TZGIOM/KWjCcEJkYe0WIiNqH4YSIiKxe4wUIOc9L+hhOiMys8ZsiV2gl6lhtvUkmWRbDCZGZcIVWIsszdJNMzgWTNoYTsnr3u7zXXLhCK5E06Jsk27QXk69LaWE4IatmzOW95sArB4ikRc538LYlDCdWit8K6pnz8l5DN+wjIulq7VooTV/fgO2+j1oCw4mV4bcC/Ux9ea85b9hHROZ1vx7Nll7ftvw+2pEYTqyMFFZItFYdecM+IrIcfbeZ4Ptox2I4sUKc52B6vGEfke3hgoqWw3BC1Aq8YR8RUcexSDh58skncfjwYfz617/GP//5T0tUgahFhia78psUkfVqeJ1zcrvlWSScLFq0CHPmzMGHH35oidMTtYiTXYlsi6FVZPl6txyLhJPIyEgcPnzYEqcmui99QzgAh3GIrJW+Cwn4eresTsY+4ciRI5gyZQp8fHygUCiwZ8+eZmVSUlIQGBgIR0dHhIWF4ejRo6aoK1GHahjCafjhGxWR9SqEJ1/vEmJ0OLl9+zZCQ0Px7rvv6t2/Y8cOLF68GImJiTh79ixGjx6NqKgo5Ofnt7uyREREZP2MHtaJiopCVFSUwf0bN27E3LlzMW/ePABAcnIy9u/fj82bNyMpKcnoClZVVaGq6t7Yv0ajMfoYRPfTdA0TIiKyHJPOOamurkZWVhaWL1+us338+PHIzMxs0zGTkpKwevVqU1SPSC9Da5hwMhwRmUPP5V/oPP7xzUkWqol0mTSclJSUoLa2Fl5eXjrbvby8UFRUpH08YcIEfPPNN7h9+zZ69OiB3bt3Y8iQIXqPuWLFCiQkJGgfazQa+Pn5mbLaZOO4hgkRkbSY5WodhUKh81gIobNt//79rT6WUqmEUqk0Wd3IujRdj6Q9oYJrmBARSYNJw4mnpyfs7Ox0ekkAoLi4uFlvirHUajXUajVqa2vbdRyyHoaGY3hjLiIieTP6ap2WODg4ICwsDOnp6Trb09PTMWLEiHYdOy4uDjk5OTh9+nS7jkPWo/FwzKSqtYivjoVKUdXsNudERCQvRvecVFRU4MqVK9rHeXl5yM7Ohru7O/z9/ZGQkIDo6GiEh4dj+PDh2Lp1K/Lz87FgwQKTVpyoAYdjiMgSmg4rA5yvZipGh5MzZ84gMjJS+7hhsmpMTAy2b9+O6dOno7S0FGvWrMGNGzcQHByMtLQ0BAQEtKuiHNYhIiKpaOk2F42HlptemUOtY3Q4iYiIgBCixTKxsbGIjY1tc6X0iYuLQ1xcHDQaDVxdXU16bCIiImPou8qvj+I6NjmkoKviFgoFe0/awyL31iEiIrIGHFY2D4YTMjlTXt7bFo1XeOVqr0RkSg3vKXxvMS/ZhBPOOZEHS17eq++25w3n52qvRNQe+t5f+N5iPrIJJ5xzIg9Nx2E7cgxW323PAc6eJ6L20/f+wvcW85FNOCF5sdQ4bCE8ORGNiMyC7y8dx6SLsBERERG1F3tOSDaaTrTlhDQiIuskm3DCCbG2raUFjzghjYjIusgmnHBCrG3Tt+ARwAlpRETWSDbhhAjggkdERLaAE2KJiIhIUthzQjaJq8gSEUmXbMIJJ8SSKXAVWSIi6ZNNOOGEWDIFriJLRCR9sgknRKbCVR6JiKSNE2KJiIhIUhhOiIiISFI4rENGabqEPOdqEBGRqckmnPBqHcvTt4R8pVBiXNU6BhQiIjIZ2QzrxMXFIScnB6dPn7Z0VWxW4yXkJ1WtRXx1LFSKqmZXvhAREbWHbHpOSDq4hDwREZmTbHpOiIiIyDYwnBAREZGkMJwQERGRpDCcEBERkaQwnBAREZGk8GodG9JHcV37b6ktntZ0cbemGtediIism2zCCRdha7sy4YxKocQmhxTtNiktnqZvcTd9KoUSZcK5g2pFRESWIptwEhcXh7i4OGg0Gri6ulq6OrJSCE+Mq1qn7Znoo7iOTQ4p6Kq4JYm78zZe3O2K8DVYTmq9PUREZB6yCSfUPoXwlEQQaQkXdyMiIoATYomIiEhiGE6IiIhIUhhOiIiISFIYToiIiEhSGE6IiIhIUhhOiIiISFIYToiIiEhSuM4JaTVdQr61i541Xlq+tcvMNz4Xl6YnImul79YcXFDy/mQTTrh8vXnpW0L+fkvc61sWv+F5LS0zb+hcXJqeiKyJoVtzSOn2IVIlm3DC5evNq+kS8q1Z4r7psvgN7vetQN9y9fwmQUTWRt97ndRuHyJVsgkn1DGMXUK+Pcvic7l6IrIFfK8zHifEEhERkaQwnBAREZGkMJwQERGRpDCcEBERkaQwnBAREZGkMJwQERGRpDCcEBERkaQwnBAREZGkMJwQERGRpDCcEBERkaQwnBAREZGkMJwQERGRpFgknOzbtw/9+/dH3759sW3bNktUgYiIiCSqw+9KXFNTg4SEBBw6dAguLi741a9+hWnTpsHd3b2jq0JEREQS1OE9J6dOncLAgQPh6+sLZ2dnTJw4Efv37+/oahAREZFEGR1Ojhw5gilTpsDHxwcKhQJ79uxpViYlJQWBgYFwdHREWFgYjh49qt1XWFgIX19f7eMePXrg+vXrbas9ERERWR2jh3Vu376N0NBQPPfcc/jtb3/bbP+OHTuwePFipKSkYOTIkXjvvfcQFRWFnJwc+Pv7QwjR7DkKhcLg+aqqqlBVVaV9rNFojK0yGdBHcV3vv+V+LiIiS2p4j+N7XdsZHU6ioqIQFRVlcP/GjRsxd+5czJs3DwCQnJyM/fv3Y/PmzUhKSoKvr69OT8m1a9cwbNgwg8dLSkrC6tWrja0mtaBMOKNSKLHJIUVne6VQokw4y/ZcRESWpO/9ju91bWPSCbHV1dXIysrC8uXLdbaPHz8emZmZAIChQ4fi3LlzuH79OlxcXJCWloY//elPBo+5YsUKJCQkaB9rNBr4+fmZsto2pxCeGFe1Dl0Vt3S2lwlnFMJTtuciIrIkfe93fK9rG5OGk5KSEtTW1sLLy0tnu5eXF4qKiupPaG+PDRs2IDIyEnV1dXjllVfg4eFh8JhKpRJKpdKU1STUv4gKRce8YDryXERElsT3O9Mwy6XETeeQCCF0tj3++ON4/PHHzXFqIiIikjmTXkrs6ekJOzs7bS9Jg+Li4ma9KcZSq9UICgrCkCFD2nUcIiIikjaThhMHBweEhYUhPT1dZ3t6ejpGjBjRrmPHxcUhJycHp0+fbtdxiIiISNqMHtapqKjAlStXtI/z8vKQnZ0Nd3d3+Pv7IyEhAdHR0QgPD8fw4cOxdetW5OfnY8GCBSatOBEREVkno8PJmTNnEBkZqX3ccCVNTEwMtm/fjunTp6O0tBRr1qzBjRs3EBwcjLS0NAQEBLSromq1Gmq1GrW1te06DhEREUmb0eEkIiJC70JqjcXGxiI2NrbNldInLi4OcXFx0Gg0cHV1NemxiYiISDoscldiIiIiIkMYToiIiEhSZBNOeCkxERGRbZBNOOGlxERERLZBNuGEiIiIbAPDCREREUmKbMIJ55wQERHZBrPc+M8cGtY5KS8vh5ubGzQajaWrVO9WBVAlcLfqF9SJSkvXxmTuKn6BBrrt0reNiIhaT9/7qGQ+z8ysoZ33WysNABSiNaUk5Nq1a/Dz87N0NYiIiKgNCgoK0KNHjxbLyC6c1NXVobCwEM7OzlAoFJauDoD6NOjn54eCggK4uLhYujpmYyvtBGynrWyndWE7rYu1tVMIgVu3bsHHxwedOrU8q0Q2wzoNOnXqdN/EZSkuLi5W8T/Q/dhKOwHbaSvbaV3YTutiTe1s7e1nZDMhloiIiGwDwwkRERFJCsOJCSiVSqxatQpKpdLSVTErW2knYDttZTutC9tpXWylnfrIbkIsERERWTf2nBAREZGkMJwQERGRpDCcEBERkaQwnBAREZGkMJyYQEpKCgIDA+Ho6IiwsDAcPXrU0lVqtaSkJAwZMgTOzs7o1q0bnnjiCVy6dEmnjBACr776Knx8fNClSxdERETg/PnzOmWqqqqwcOFCeHp6wsnJCY8//jiuXbvWkU0xSlJSEhQKBRYvXqzdZi3tvH79OmbOnAkPDw+oVCoMHjwYWVlZ2v3W0s6amhr84Q9/QGBgILp06YJevXphzZo1qKur05aRY1uPHDmCKVOmwMfHBwqFAnv27NHZb6o2lZWVITo6Gq6urnB1dUV0dDRu3rxp5tbd01I77969i2XLlmHQoEFwcnKCj48PZs2ahcLCQp1jyL2dTb3wwgtQKBRITk7W2S6HdpqcoHb59NNPRefOncX7778vcnJyRHx8vHBychJXr161dNVaZcKECSI1NVWcO3dOZGdni0mTJgl/f39RUVGhLfPmm28KZ2dnsXPnTvH999+L6dOni+7duwuNRqMts2DBAuHr6yvS09PFN998IyIjI0VoaKioqamxRLNadOrUKdGzZ08REhIi4uPjtdutoZ0///yzCAgIELNnzxYnT54UeXl54uDBg+LKlSvaMtbQTiGEeP3114WHh4fYt2+fyMvLE5999pl44IEHRHJysraMHNualpYmEhMTxc6dOwUAsXv3bp39pmrTY489JoKDg0VmZqbIzMwUwcHBYvLkyR3VzBbbefPmTTFu3DixY8cOcfHiRXHixAkxbNgwERYWpnMMubezsd27d4vQ0FDh4+Mj3n77bZ19cminqTGctNPQoUPFggULdLY99NBDYvny5RaqUfsUFxcLACIjI0MIIURdXZ3w9vYWb775prbMnTt3hKurq9iyZYsQov6NpHPnzuLTTz/Vlrl+/bro1KmT+PLLLzu2Afdx69Yt0bdvX5Geni7GjBmjDSfW0s5ly5aJUaNGGdxvLe0UQohJkyaJOXPm6GybNm2amDlzphDCOtra9MPMVG3KyckRAMTXX3+tLXPixAkBQFy8eNHMrWqupQ/tBqdOnRIAtF/8rKmd165dE76+vuLcuXMiICBAJ5zIsZ2mwGGddqiurkZWVhbGjx+vs338+PHIzMy0UK3ap7y8HADg7u4OAMjLy0NRUZFOG5VKJcaMGaNtY1ZWFu7evatTxsfHB8HBwZL7PcTFxWHSpEkYN26cznZraefevXsRHh6Op556Ct26dcPDDz+M999/X7vfWtoJAKNGjcK///1v5ObmAgC+/fZbHDt2DBMnTgRgXW1tYKo2nThxAq6urhg2bJi2zCOPPAJXV1dJthuof29SKBRwc3MDYD3trKurQ3R0NJYuXYqBAwc2228t7TSW7G78JyUlJSWora2Fl5eXznYvLy8UFRVZqFZtJ4RAQkICRo0aheDgYADQtkNfG69evaot4+DggK5duzYrI6Xfw6effopvvvkGp0+fbrbPWtr5ww8/YPPmzUhISMDKlStx6tQpLFq0CEqlErNmzbKadgLAsmXLUF5ejoceegh2dnaora3F2rVr8eyzzwKwnr9pY6ZqU1FREbp169bs+N26dZNku+/cuYPly5fjd7/7nfYGeNbSzrfeegv29vZYtGiR3v3W0k5jMZyYgEKh0HkshGi2TQ5eeuklfPfddzh27FizfW1po5R+DwUFBYiPj8eBAwfg6OhosJzc21lXV4fw8HC88cYbAICHH34Y58+fx+bNmzFr1ixtObm3EwB27NiBv/71r/j73/+OgQMHIjs7G4sXL4aPjw9iYmK05ayhrU2Zok36ykux3Xfv3sUzzzyDuro6pKSk3Le8nNqZlZWFTZs24ZtvvjG6PnJqZ1twWKcdPD09YWdn1yyZFhcXN/tmI3ULFy7E3r17cejQIfTo0UO73dvbGwBabKO3tzeqq6tRVlZmsIylZWVlobi4GGFhYbC3t4e9vT0yMjLwzjvvwN7eXltPubeze/fuCAoK0tk2YMAA5OfnA7CevycALF26FMuXL8czzzyDQYMGITo6Gr///e+RlJQEwLra2sBUbfL29sZPP/3U7Pj//e9/JdXuu3fv4umnn0ZeXh7S09O1vSaAdbTz6NGjKC4uhr+/v/Z96erVq3j55ZfRs2dPANbRzrZgOGkHBwcHhIWFIT09XWd7eno6RowYYaFaGUcIgZdeegm7du3CV199hcDAQJ39gYGB8Pb21mljdXU1MjIytG0MCwtD586ddcrcuHED586dk8zv4de//jW+//57ZGdna3/Cw8MxY8YMZGdno1evXlbRzpEjRza7FDw3NxcBAQEArOfvCQCVlZXo1En3LczOzk57KbE1tbWBqdo0fPhwlJeX49SpU9oyJ0+eRHl5uWTa3RBMLl++jIMHD8LDw0NnvzW0Mzo6Gt99953O+5KPjw+WLl2K/fv3A7COdrZJR8/AtTYNlxL/5S9/ETk5OWLx4sXCyclJ/Pjjj5auWqu8+OKLwtXVVRw+fFjcuHFD+1NZWakt8+abbwpXV1exa9cu8f3334tnn31W76WLPXr0EAcPHhTffPONGDt2rOQuPW2q8dU6QlhHO0+dOiXs7e3F2rVrxeXLl8Xf/vY3oVKpxF//+ldtGWtopxBCxMTECF9fX+2lxLt27RKenp7ilVde0ZaRY1tv3bolzp49K86ePSsAiI0bN4qzZ89qr1IxVZsee+wxERISIk6cOCFOnDghBg0a1KGXnrbUzrt374rHH39c9OjRQ2RnZ+u8N1VVVVlNO/VperWOEPJop6kxnJiAWq0WAQEBwsHBQfzqV7/SXoYrBwD0/qSmpmrL1NXViVWrVglvb2+hVCrFo48+Kr7//nud4/zyyy/ipZdeEu7u7qJLly5i8uTJIj8/v4NbY5ym4cRa2vmvf/1LBAcHC6VSKR566CGxdetWnf3W0k6NRiPi4+OFv7+/cHR0FL169RKJiYk6H15ybOuhQ4f0viZjYmKEEKZrU2lpqZgxY4ZwdnYWzs7OYsaMGaKsrKyDWtlyO/Py8gy+Nx06dMhq2qmPvnAih3aamkIIITqih4aIiIioNTjnhIiIiCSF4YSIiIgkheGEiIiIJIXhhIiIiCSF4YSIiIgkheGEiIiIJIXhhIiIiCSF4YSIiIgkheGEiIiIJIXhhIiIiCSF4YSIiIgkheGEiIiIJOX/AAmZ2M69ImjNAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(rmscrho_sig,label=\"RMS of Rho Signal\", log=1,bins=100, range=(-50.,1500.0))\n",
+    "plt.hist(rmscrho_back,label=\"RMS of Rho Background\",log=1, histtype='step', bins=100, range=(-50.,1500.0))\n",
+    "plt.legend()\n",
+    "plt.show"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "80e00d94-2658-4d1d-87f6-8ca39772ef86",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<function matplotlib.pyplot.show(close=None, block=None)>"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjoAAAGdCAYAAAAbudkLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABM/ElEQVR4nO3deVzU1eL/8dcoMDKKg0IwopSYu2a5FKLd3LXC1F+LlkaZftW+mktuZdZNu7lcM7MylzSXTDOvqV9vmtstKcM9KVPTLFxKiDAcUBRcPr8/uH5yABd0YGB4Px+PeeScOfOZ8zmS8+Z8zucci2EYBiIiIiJeqJSnGyAiIiJSUBR0RERExGsp6IiIiIjXUtARERERr6WgIyIiIl5LQUdERES8loKOiIiIeC0FHREREfFaPp5ugCddvHiR48ePExAQgMVi8XRzRERE5DoYhkF6ejphYWGUKnX1MZsSHXSOHz9OeHi4p5shIiIiN+DYsWNUqVLlqnVKdNAJCAgAsjuqfPnyHm6NiIiIXI+0tDTCw8PN7/GrKdFB59LlqvLlyyvoiIiIFDPXM+1Ek5FFRETEaynoiIiIiNdS0BERERGvpaAjIiIiXktBR0RERLxWvoPOV199xUMPPURYWBgWi4WVK1e6vG4YBmPGjCEsLAx/f39atmzJ3r17XepkZmYycOBAgoODKVu2LJ06deLXX391qZOamkpMTAx2ux273U5MTAwnT550qXP06FEeeughypYtS3BwMIMGDSIrKyu/pyQiIiJeKt9B5/Tp09x5551MmzYtz9cnTZrElClTmDZtGjt27MDhcNCuXTvS09PNOkOGDGHFihUsWbKEzZs3c+rUKTp27MiFCxfMOt27dyc+Pp61a9eydu1a4uPjiYmJMV+/cOEC0dHRnD59ms2bN7NkyRI+/fRThg0blt9TEhEREW9l3ATAWLFihfn84sWLhsPhMCZOnGiWnT171rDb7cbMmTMNwzCMkydPGr6+vsaSJUvMOr/99ptRqlQpY+3atYZhGMa+ffsMwNi6datZZ8uWLQZg/Pjjj4ZhGMaaNWuMUqVKGb/99ptZ5+OPPzasVqvhdDqvq/1Op9MArru+iIiIeF5+vr/dOkcnISGBpKQk2rdvb5ZZrVZatGhBXFwcALt27eLcuXMudcLCwqhfv75ZZ8uWLdjtdiIjI806TZs2xW63u9SpX78+YWFhZp0OHTqQmZnJrl278mxfZmYmaWlpLg8RERHxXm4NOklJSQCEhoa6lIeGhpqvJSUl4efnR4UKFa5aJyQkJNfxQ0JCXOrk/JwKFSrg5+dn1slpwoQJ5pwfu92ufa5ERES8XIHcdZVzSWbDMK65THPOOnnVv5E6lxs1ahROp9N8HDt27KptEhERkeLNrUHH4XAA5BpRSU5ONkdfHA4HWVlZpKamXrXO77//nuv4f/zxh0udnJ+TmprKuXPnco30XGK1Ws19rbS/lYiIiPdza9CJiIjA4XCwYcMGsywrK4vY2FiaNWsGQOPGjfH19XWpk5iYyA8//GDWiYqKwul0sn37drPOtm3bcDqdLnV++OEHEhMTzTrr16/HarXSuHFjd56WiIiIFFP53r381KlTHDp0yHyekJBAfHw8FStW5NZbb2XIkCGMHz+eGjVqUKNGDcaPH4/NZqN79+4A2O12evfuzbBhwwgKCqJixYoMHz6cO+64g7Zt2wJQp04d7r//fvr06cOsWbMA6Nu3Lx07dqRWrVoAtG/fnrp16xITE8Mbb7zBn3/+yfDhw+nTp49GakSKspPHIOOEa5ktCAI1Z05E3C/fQWfnzp20atXKfD506FAAnn76aebPn8/IkSM5c+YM/fv3JzU1lcjISNavX09AQID5nrfeegsfHx+6du3KmTNnaNOmDfPnz6d06dJmnUWLFjFo0CDz7qxOnTq5rN1TunRpVq9eTf/+/WnevDn+/v50796dyZMn578XRKRwnDwG790D5zJcy31tMGD7X2FHYUhE3MRiGIbh6UZ4SlpaGna7HafTqVEgkcJwPB7ebwEPz4bgmtllKQdheR/oGwthd11/GBKREis/39/5HtEREblpwTWzQ01eMk5kh5y8wlDGCQUdEckXBR0RKRpSDrr+92phSETkOinoiIhn2YKyL0st7/NXma8tu1xE5CYp6IiIZwWGZ8+9uXzysSYei4ibKOiIiOcFhivYiEiBKJAtIERERESKAo3oiEjBunxNnEsTjUVEComCjogUnLzWxNFEYxEpRAo6IlJw8loTRxONRaQQKeiISMFz15o4l1/6UmASkeugoCMiRd+V1trRlhAicg0KOiJS9OVca0dbQojIdVLQEZECF/3uZvYavwFweGL0jR1Ea+2IyA1Q0BGRQlX1xdW5ym44/IiIXIMWDBQRERGvpaAjIiIiXktBR0RERLyW5uiIiPtcvt0DaMsHEfE4BR0RcY+8tnsAMgwrqUaAhxolIiWdgo6IuEde2z0Abd/5juMEX/WtOe/E0l1YIuIuCjoi4l45tns4zm8F91k5L41pWwgRyUFBR0Tc6vLFAQtMXltCgLaFEJFcFHREpPjJuSUEaFsIEcmTgo6IFE/aEkJEroPW0RERERGvpaAjIiIiXktBR0RERLyWgo6IiIh4LU1GFpEiJ+cCgqBFBEXkxmhER0RERLyWgo6IiIh4LQUdERER8VoKOiIiIuK1NBlZRLzL5Rt9apNPkRJPQUdEbtzJY3/tN5VzJ/HCltdGn9rkU6TEU9ARkRtz8hi8dw+cyzCLMgwrqUaAZ9qTc6NPbfIpIijoiMiNyjiRHXIeng3BNQFo+853HCfYc23SRp8ikoOCjojcnOCaEHYXAMf5zbNtERHJQXddiYiIiNdS0BERERGvpaAjIiIiXktzdETkpkS/u5m9hubmiEjRpBEdERER8VoKOiIiIuK1FHRERETEaynoiIiIiNfSZGQRKRaqvrja5fnhidEeaomIFCca0RERERGvpREdEbk+l+9UDp7frVxE5Doo6IjIteWxUzl4eLdyEZHroKAjIteWx07lUAR2KxcRuQYFHRG5fpftVA7arVxEij5NRhYRERGvpaAjIiIiXktBR0RERLyWgo6IiIh4LU1GFhHvlnO9H1sQBIZ7pi0iUugUdETEO9mCwNcGy/u4lvvaYMB2hR2REkJBR0S8U2B4dqDJuZrz8j7ZZQo6IiWCgo6IXLfodzez1yhGa+cEhivQiJRwbp+MfP78eV5++WUiIiLw9/enWrVqvPbaa1y8eNGsYxgGY8aMISwsDH9/f1q2bMnevXtdjpOZmcnAgQMJDg6mbNmydOrUiV9//dWlTmpqKjExMdjtdux2OzExMZw8edLdpyQiIiLFlNuDzj//+U9mzpzJtGnT2L9/P5MmTeKNN97g3XffNetMmjSJKVOmMG3aNHbs2IHD4aBdu3akp6ebdYYMGcKKFStYsmQJmzdv5tSpU3Ts2JELFy6Ydbp37058fDxr165l7dq1xMfHExMT4+5TEhERkWLK7ZeutmzZQufOnYmOjgagatWqfPzxx+zcuRPIHs2ZOnUqo0eP5uGHHwZgwYIFhIaGsnjxYvr164fT6eSDDz5g4cKFtG3bFoCPPvqI8PBwNm7cSIcOHdi/fz9r165l69atREZGAjB79myioqI4cOAAtWrVcvepiYiISDHj9hGde++9l//85z8cPJh9S+d3333H5s2befDBBwFISEggKSmJ9u3bm++xWq20aNGCuLg4AHbt2sW5c+dc6oSFhVG/fn2zzpYtW7Db7WbIAWjatCl2u92sk1NmZiZpaWkuDxEREfFebh/ReeGFF3A6ndSuXZvSpUtz4cIFxo0bxxNPPAFAUlISAKGhoS7vCw0N5ciRI2YdPz8/KlSokKvOpfcnJSUREhKS6/NDQkLMOjlNmDCBsWPH3twJipQAVV9c7fK8niWB1VYPNUZE5Ca4fUTnk08+4aOPPmLx4sV8++23LFiwgMmTJ7NgwQKXehaLxeW5YRi5ynLKWSev+lc7zqhRo3A6nebj2LFj13taIiIiUgy5fURnxIgRvPjiizz++OMA3HHHHRw5coQJEybw9NNP43A4gOwRmUqVKpnvS05ONkd5HA4HWVlZpKamuozqJCcn06xZM7PO77//nuvz//jjj1yjRZdYrVasVv1aKiIiUlK4fUQnIyODUqVcD1u6dGnz9vKIiAgcDgcbNmwwX8/KyiI2NtYMMY0bN8bX19elTmJiIj/88INZJyoqCqfTyfbt280627Ztw+l0mnVERESkZHP7iM5DDz3EuHHjuPXWW6lXrx67d+9mypQp9OrVC8i+3DRkyBDGjx9PjRo1qFGjBuPHj8dms9G9e3cA7HY7vXv3ZtiwYQQFBVGxYkWGDx/OHXfcYd6FVadOHe6//3769OnDrFmzAOjbty8dO3bUHVciIiICFEDQeffdd3nllVfo378/ycnJhIWF0a9fP/7+97+bdUaOHMmZM2fo378/qampREZGsn79egICAsw6b731Fj4+PnTt2pUzZ87Qpk0b5s+fT+nSpc06ixYtYtCgQebdWZ06dWLatGnuPiUREREppiyGYRieboSnpKWlYbfbcTqdlC9f3tPNESky8r7rajTRmePYa0R4qFWuDk+Mzv+bjsfD+y2gbyyE3eXuJolIIcnP97fb5+iIiIiIFBXa1FNEiqWco05wg6M8IuLVNKIjIiIiXktBR0RERLyWgo6IiIh4LQUdERER8VqajCwiuYSRQgVLuvm8uuU3D7ZGROTGKeiIiKuTx9hoHYHNkulSnGFYSTUCrvAmEZGiSUFHRFxlnMBmyWRwVn8OGZXN4lQjgOMEe7BhIiL5p6AjInk6ZFQuMqsgi4jcKAUdESl5Ug7+9WdbEASGe64tIlKgFHREpOSwBYGvDZb3+avM1wYDtivsiHgpBR0RKTkCw7NDTcaJ7OcpB7NDT8YJBR0RL6WgIyIlS2C4Qo1ICaIFA0VERMRrKeiIiIiI11LQEREREa+loCMiIiJeS0FHREREvJaCjoiIiHgt3V4uIlR9cbX553qWBFZbPdgYERE30oiOiIiIeC0FHREREfFaCjoiIiLitRR0RERExGtpMrKIEEYKFSzpAFS3/Obh1oiIuI+CjkhJd/IYG60jsFkyzaIMw0qqEeDBRomIuIeCjkhJl3ECmyWTwVn9OWRUBiDVCOA4wR5umIjIzVPQESlhLl8zB/5aN+eQUZm9RoSHWiUiUjA0GVlERES8loKOiIiIeC0FHREREfFaCjoiIiLitRR0RERExGsp6IiIiIjX0u3lIuI1ct46f3hitIdaIiJFhYKOiEjKQdfntiAIDPdMW0TErRR0RKTksgWBrw2W93Et97XBgO0KOyJeQEFHREquwPDsQJNx4q+ylIPZwSfjhIKOiBdQ0BGRki0wXIFGxIvprisRERHxWhrRESlhwkihgiXdfF7d8psHWyMiUrAUdERKkpPH2Ggdgc2S6VKcYVhJNQI81CgRkYKjoCNSkmScwGbJZHBWfw4Zlc3iVCOA4wR7sGEiIgVDQUekBDpkVGavEeHpZoiIFDhNRhYRERGvpaAjIiIiXkuXrkS83OX7P9WzJLDa6sHGiIgUMo3oiIiIiNdS0BERERGvpaAjIiIiXktBR0RERLyWgo6IiIh4LQUdERER8VoKOiIiIuK1tI6OiBe5fM0cERHRiI6IiIh4MQUdERER8VoKOiIiIuK1FHRERETEaynoiIiIiNcqkKDz22+/8eSTTxIUFITNZuOuu+5i165d5uuGYTBmzBjCwsLw9/enZcuW7N271+UYmZmZDBw4kODgYMqWLUunTp349ddfXeqkpqYSExOD3W7HbrcTExPDyZMnC+KUREREpBhye9BJTU2lefPm+Pr68vnnn7Nv3z7efPNNAgMDzTqTJk1iypQpTJs2jR07duBwOGjXrh3p6elmnSFDhrBixQqWLFnC5s2bOXXqFB07duTChQtmne7duxMfH8/atWtZu3Yt8fHxxMTEuPuUREREpJhy+zo6//znPwkPD2fevHlmWdWqVc0/G4bB1KlTGT16NA8//DAACxYsIDQ0lMWLF9OvXz+cTicffPABCxcupG3btgB89NFHhIeHs3HjRjp06MD+/ftZu3YtW7duJTIyEoDZs2cTFRXFgQMHqFWrlrtPTURERIoZt4/orFq1iiZNmvDYY48REhJCw4YNmT17tvl6QkICSUlJtG/f3iyzWq20aNGCuLg4AHbt2sW5c+dc6oSFhVG/fn2zzpYtW7Db7WbIAWjatCl2u92sk1NmZiZpaWkuDxEREfFebh/R+eWXX5gxYwZDhw7lpZdeYvv27QwaNAir1cpTTz1FUlISAKGhoS7vCw0N5ciRIwAkJSXh5+dHhQoVctW59P6kpCRCQkJyfX5ISIhZJ6cJEyYwduzYmz5HESke8lop+vDEaA+0REQ8xe0jOhcvXqRRo0aMHz+ehg0b0q9fP/r06cOMGTNc6lksFpfnhmHkKsspZ5286l/tOKNGjcLpdJqPY8eOXe9piYiISDHk9qBTqVIl6tat61JWp04djh49CoDD4QDINeqSnJxsjvI4HA6ysrJITU29ap3ff/891+f/8ccfuUaLLrFarZQvX97lISIiIt7L7UGnefPmHDhwwKXs4MGD3HbbbQBERETgcDjYsGGD+XpWVhaxsbE0a9YMgMaNG+Pr6+tSJzExkR9++MGsExUVhdPpZPv27Wadbdu24XQ6zToiIiJSsrl9js7zzz9Ps2bNGD9+PF27dmX79u28//77vP/++0D25aYhQ4Ywfvx4atSoQY0aNRg/fjw2m43u3bsDYLfb6d27N8OGDSMoKIiKFSsyfPhw7rjjDvMurDp16nD//ffTp08fZs2aBUDfvn3p2LGj7rgSERERoACCzt13382KFSsYNWoUr732GhEREUydOpUePXqYdUaOHMmZM2fo378/qampREZGsn79egICAsw6b731Fj4+PnTt2pUzZ87Qpk0b5s+fT+nSpc06ixYtYtCgQebdWZ06dWLatGnuPiURyYcyPhYqlClFqatPufOYs2fPXr3CeQPKhWf/91p1RaRA+Pr6unzf3wyLYRiGW45UDKWlpWG323E6nZqvI14hr7uMwkihgiV7Mc7qlt9422860Znj2GtEuPWzLcDDdcrSplo5fEtb/ltS9FSp4H/1CheyID0JbEFQ2je7zFIKSrn990IRuYrAwEAcDkeeNxjl5/tb/+eKeLEwUthoHYHNkmmWZRhWUo2Aq7zrxjxcpywda9upUDEYi48fXOMuSk+JcFzjl5rzWfCnAVwELq3EbkDF28DHr4BbJyKGYZCRkUFycjKQfZPTzVDQEfFiFSzp2CyZDM7qzyGjMgCpRgDHCXbr5/j7WGhTrRwVKgZTyt/9IcqdypQpc60aUKYuXDyf/fT8WTh5BPx8wO9a7xURd/D3zx55TU5OJiQk5KYuYynoiBRjeV2qyssho7LbL1VdLrBMKXxLW7JHcryBjx/gJeciUkzZbDYAzp07d1NBp0B2LxeRkiV74rGlyF6uEpHi51qLCF8vBR0RERHxWgo6IiLFxMqVK6levTqlS5dmyJAhN3ycTZs2YbFYOHnypNva5kmHDx/GYrEQHx/v6abk4sm2WSwWVq5cWeifW9Rojo6IFKhO074ptM9a9VzzfNXv2bMnCxYsAKB06dKEhYURHR3N+PHjXTYVrhoZzZFfE/n44495/PHHXY5Rr1499u3bx7x58+jZsycAu3fv5pVXXmH79u2kpaXhcDiIjIzkvffeIzj4xieC9+vXj2eeeYZBgwa5rDuW0+7duxk/fjxfffUVTqeTW2+9lRYtWjBixAhq1qx5w59/JWPGjGHlypUF8mV++d/RlZw/f57ExMSb6tsb9csvvzB69GhiY2P5888/CQ4OpnHjxrzxxhvUrFmT8PBwj7VNsmlER0RKtPvvv5/ExEQOHz7MnDlz+Pe//03//v1z1QsPr8K8efNcyrZu3UpSUhJly5Y1y5KTk2nbti3BwcGsW7eO/fv3M3fuXCpVqkRGRsYNt/PUqVMkJyfToUMHwsLCrhh0PvvsM5o2bUpmZiaLFi1i//79LFy4ELvdziuvvHLDn18Yzp07l6vs7bffJjEx0XwAzJs3z6WsdOnSOBwOfHwK93f3rKws2rVrR1paGsuXL+fAgQN88skn1K9fH6fTCeCxtslfFHREpESzWq04HA6qVKlC+/bt6datG+vXr89Vr8fj3YiNjeXYsWNm2dy5c+nRo4fLl1hcXBxpaWnMmTOHhg0bEhERQevWrZk6dSq33nrrFduRmprKU089RYUKFbDZbDzwwAP89NNPQPalpkvBpnXr1lgsFjZt2pTrGBkZGTzzzDM8+OCDrFq1irZt2xIREUFkZCSTJ082t8vJacyYMdx1110uZVOnTqVq1arm802bNnHPPfdQtmxZAgMDad68OUeOHGH+/PmMHTuW7777DovFgsViYf78+QA4nU769u1LSEgI5cuXp3Xr1nz33Xe5Pnfu3LlUq1YNq9VKzjVs7XY7DofDfMBfC8ldeuS8PHTp0ty6deto2LAh/v7+tG7dmuTkZD7//HPq1KlD+fLleeKJJ1zCp2EYTJo0iWrVquHv78+dd97JsmXLrvh3tm/fPn755RemT59O06ZNue2222jevDnjxo3j7rvvBvK+dLVq1Spq1KiBv78/rVq1YsGCBS6XEufPn09gYCDr1q2jTp06lCtXzgzkl+zYsYN27doRHByM3W6nRYsWfPvtt1dsa0mmoCMi8l+//PILa9euxdfXN9droSEhdOjQwbyMkpGRwSeffEKvXr1c6jkcDs6fP8+KFStyfWlfTc+ePdm5cyerVq1iy5YtGIbBgw8+yLlz52jWrJm5WfKnn35KYmJinpsXr1u3jpSUFEaOHJnnZwQGBl53ey53/vx5unTpQosWLfj+++/ZsmULffv2xWKx0K1bN4YNG0a9evXMEZZu3bphGAbR0dEkJSWxZs0adu3aRaNGjWjTpg1//vmneexDhw6xdOlSPv30U7df+hozZgzTpk0jLi6OY8eO0bVrV6ZOncrixYtZvXo1GzZs4N133zXrv/zyy8ybN48ZM2awd+9enn/+eZ588kliY2PzPP4tt9xCqVKlWLZsGRcuXMizTk6HDx/m0UcfpUuXLsTHx9OvXz9Gjx6dq15GRgaTJ09m4cKFfPXVVxw9epThw4ebr6enp/P000/z9ddfs3XrVmrUqMGDDz5Ienp6PnvJ+2ksTaSYuN41cyR/PvvsM8qVK8eFCxfMfbCmTJmSZ91evXoxbNgwRo8ezbJly7j99ttzjYQ0bdqUl156ie7du/Pss89yzz330Lp1a5566ilCQ0PzPO5PP/3EqlWr+Oabb8wAs2jRIsLDw1m5ciWPPfYYISEhAFSsWNEc2cjrOAC1a9fOdz9cTVpaGk6nk44dO3L77bcD2RsrX1KuXDl8fHxc2vXFF1+wZ88ekpOTsVqtAEyePJmVK1eybNky+vbtC2Rf/lm4cCG33HKLW9sM8Prrr9O8efa8rd69ezNq1Ch+/vlnqlWrBsCjjz7Kl19+yQsvvMDp06eZMmUKX3zxBVFRUQBUq1aNzZs3M2vWLFq0aJHr+JUrV+add95h5MiRjB07liZNmtCqVSt69OhhfkZOM2fOpFatWrzxxhsA1KpVix9++IFx48a51Dt37hwzZ840+/u5557jtddeM19v3bq1S/1Zs2ZRoUIFYmNj6dix4410l9fSiI6IlGitWrUiPj6ebdu2MXDgQDp06MDAgQPzrBsdHc2pU6f46quvmDt3bq7RnEvGjRtHUlISM2fOpG7dusycOZPatWuzZ8+ePOvv378fHx8fIiMjzbKgoCBq1arF/v37r/tcCmrrwooVK9KzZ086dOjAQw89ZM6buZpdu3Zx6tQpgoKCKFeunPlISEjg559/NuvddtttBRJyABo0aGD+OTQ0FJvN5hJAQkNDzW0G9u3bx9mzZ2nXrp1Lez/88EOX9uY0YMAAkpKS+Oijj4iKiuJf//oX9erVY8OGDXnWP3DggHlZ65J77rknVz2bzWaGHMjeBuFSWyF7Ltizzz5LzZo1sdvt2O12Tp06xdGjR6/RKyWPgo6IlGhly5alevXqNGjQgHfeeYfMzEzGjh2bZ10fHx9iYmJ49dVX2bZtGz169LjicYOCgnjsscd488032b9/P2FhYUyePDnPulcKKIZh5GvRtEt3VP3444/X/R6AUqVK5WpDzonB8+bNY8uWLTRr1oxPPvmEmjVrsnXr1ise8+LFi1SqVIn4+HiXx4EDBxgxYoRZ7/KJ3O52+SVIi8WS65KkxWLh4sWLZnsBVq9e7dLeffv2XXWeDkBAQACdOnVi3LhxfPfdd/ztb3/j9ddfz7NuXn+nef3959XWy+v17NmTXbt2MXXqVOLi4oiPjycoKIisrKyrtrUkUtAREbnMq6++yuTJkzl+/Hier/fq1YvY2Fg6d+7scgv61fj5+XH77bdz+vTpPF+vW7cu58+fZ9u2bWbZiRMnOHjwoMslomtp3749wcHBTJo0Kc/Xr7Ruzi233EJSUpLLF2le82UaNmzIqFGjiIuLo379+ixevBjIPr+cc1QaNWpEUlISPj4+VK9e3eVRFG+1rlu3LlarlaNHj+Zqb3h4+HUfx2KxULt27Sv+XdeuXZsdO3a4lO3cuTPf7f36668ZNGgQDz74IPXq1cNqtZKSkpLv45QECjoiIpdp2bIl9erVY/z48Xm+XqdOHVJSUnLdan7JZ599xpNPPslnn33GwYMHOXDgAJMnT2bNmjV07tw5z/fUqFGDzp0706dPHzZv3sx3333Hk08+SeXKla/4nryULVuWOXPmsHr1ajp16sTGjRs5fPgwO3fuZOTIkTz77LNXPOc//viDSZMm8fPPP/Pee+/x+eefm68nJCQwatQotmzZwpEjR1i/fr1LCKtatSoJCQnEx8eTkpJCZmYmbdu2JSoqii5durBu3ToOHz5MXFwcL7/88g19sRe0gIAAhg8fzvPPP8+CBQv4+eef2b17N++9994V1/GJj4+nc+fOLFu2jH379nHo0CE++OAD5s6de8W/t379+vHjjz/ywgsvcPDgQZYuXWrepZaf0bvq1auzcOFC9u/fb44uXtoIU1wp6IiI5DB06FBmz57tciv55YKCgq74pVK3bl1sNhvDhg3jrrvuomnTpixdupQ5c+YQExNzxc+cN28ejRs3pmPHjkRFRWEYBmvWrMnzDrCr6dy5M3Fxcfj6+tK9e3dq167NE088gdPpvOLllDp16jB9+nTee+897rzzTrZv3+5yh4/NZuPHH3/kkUceoWbNmvTt25fnnnuOfv36AfDII49w//3306pVK2655RY+/vhjLBYLa9as4b777qNXr17UrFmTxx9/nMOHD19xUran/eMf/+Dvf/87EyZMoE6dOnTo0IF///vfRETkvSFulSpVqFq1KmPHjiUyMpJGjRrx9ttvM3bs2DzvpAKIiIhg2bJlLF++nAYNGjBjxgyz7qVJ29dj7ty5pKam0rBhQ2JiYhg0aJA5YV1cWYyCmr1WDKSlpWG323E6nZQvX97TzRG5qhu566qeJYHV1tFEZ44r0N3LKweUZkyrEELCqhT5HcwbVAnM3xuyMiDlAATXAj9bgbRJSrZx48Yxc+bMKwbrkurs2bMkJCQQERFBmTJlXF7Lz/e3bi8XEREpRNOnT+fuu+8mKCiIb775hjfeeIPnnnvO083yWgo6Il4kjBQqWP5aMKy65TcPtkZE8vLTTz/x+uuv8+eff3LrrbcybNgwRo0a5elmeS0FHREvEUYKG60jsFkyXcozDCupxpU3gBSRwvXWW2/x1ltveboZJYaCjoiXqGBJx2bJZHBWfw4Zlc3yVCOA4xS923k95ftfT7o8z/ecHREpVhR0RLzMIaNygU48FhEpTnR7uYiIiHgtBR0RERHxWgo6IiIi4rUUdERERMRraTKyiBQo31O/4XP2z0L5rPNlKnKuXOVrVyymVq5cyfDhw0lISGDgwIFMnTr1ho6zadMmWrVqRWpqKoGBgW5toyccPnyYiIgIdu/ezV133eXp5hQIi8XCihUr6NKli6eb4jZjxoxh5cqVeW4g604KOiJSYHxP/UatZW0odf5MoXzeRR9/Djz6n+sOO688359Vyz4GoHTp0oSFhREdHc348eNddiavGhnNkV8T+XjhfB7v+lh2YSkf8PGjXr167Nu3j3nz5tGzZ08Adu/ezSuvvML27dtJS0vD4XAQGRnJe++9d1M7d/fr149nnnmGQYMGERBw5bWRdu/ezfjx4/nqq69wOp3ceuuttGjRghEjRlCzZs0b/vwrKcgvrJ49e15xU81Lzp8/T2Jiokd2RW/ZsiWxsbFAdhi55ZZbuO+++5g8eTK33XZbobdHclPQESmibmRvq6LG5+yflDp/hqMtp5IZWL1AP8t68hC3bhqCz9k/8zWqc//99zNv3jzOnz/Pvn376NWrFydPnuTjj7MDEKWy/5kMD3Mwb85MHm/dILvcUoqtP6eRlJRE2bJlzeMlJyfTtm1bHnroIdatW0dgYCAJCQmsWrWKjIyMGz6/U6dOkZycTIcOHQgLC7tivc8++4xHHnmEDh06sGjRIm6//XaSk5P517/+xSuvvMInn3xyw20oaOfOncu1ienbb7/NxIkTzeeVKlVi3rx53H///WZZ6dKlcTgchdbOnPr06cNrr72GYRgcOXKEIUOG8OSTT/L11197rE3XI6/+9kaaoyMiBS4zsDpngu8o0MeNBimr1YrD4aBKlSq0b9+ebt26sX79+r8q+PhBaT969OhB7NbdHDtTFgJvA+Mic+fNo0ePHvj4/PU7Y1xcHGlpacyZM4eGDRsSERFB69atmTp1KrfeeusV25GamspTTz1FhQoVsNlsPPDAA/z0009A9qWmSyM4rVu3xmKxsGnTplzHyMjI4JlnnuHBBx9k1apVtG3bloiICCIjI5k8eTKzZs3K87PHjBmT65LP1KlTqVq1qvl806ZN3HPPPZQtW5bAwECaN2/OkSNHmD9/PmPHjuW7777DYrFgsViYP38+AE6nk759+xISEkL58uVp3bo13333Xa7PnTt3LtWqVcNqtZJzn2m73Y7D4TAfAIGBgS5lhw8fxmKxmCNKmzZtwmKxsG7dOho2bIi/vz+tW7cmOTmZzz//nDp16lC+fHmeeOIJl/BpGAaTJk2iWrVq+Pv7c+edd7Js2bIr/p1dYrPZcDgcVKpUiaZNmzJgwAC+/fZb8/ULFy7Qu3dvIiIi8Pf3p1atWrz99tu5jjN37lzq1auH1WqlUqVKV93/6rXXXiM0NNQ858TERKKjo/H39yciIoLFixdTtWpVl8ubFouFmTNn0rlzZ8qWLWvuZj9jxgxuv/12/Pz8qFWrFgsXLjTfk7NvAU6ePOnyM3ipv//zn//QpEkTbDYbzZo148CBAy5tnjhxIqGhoQQEBNC7d2/Onj17zb51BwUdEZH/+uWXX1i7dm2ev+WGhlWhQ4cOLPh4KfiUIePMGT5Z9im9evVyqedwODh//jwrVqzI9aV9NT179mTnzp2sWrWKLVu2YBgGDz74IOfOnXP50vj0009JTEykWbNmuY6xbt06UlJSGDlyZJ6fcaPzcc6fP0+XLl1o0aIF33//PVu2bKFv375YLBa6devGsGHDqFevHomJiSQmJtKtWzcMwyA6OpqkpCTWrFnDrl27aNSoEW3atOHPP/+as3Xo0CGWLl3Kp59+6vZLX2PGjGHatGnExcVx7NgxunbtytSpU1m8eDGrV69mw4YNvPvuu2b9l19+mXnz5jFjxgz27t3L888/z5NPPmlemroef/75J//617+IjIw0yy5evEiVKlVYunQp+/bt4+9//zsvvfQSS5cuNevMmDGDAQMG0LdvX/bs2cOqVauoXj13eDcMg8GDB/PBBx+wefNmM6A+9dRTHD9+nE2bNvHpp5/y/vvvk5ycnOv9r776Kp07d2bPnj306tWLFStWMHjwYIYNG8YPP/xgXh798ssvr/ucLxk9ejRvvvkmO3fuxMfHx+X/jaVLl/Lqq68ybtw4du7cSaVKlZg+fXq+P+NG6NKViJRon332GeXKlePChQvmb5hTpkzJs26vXr0YNmwYo0c8z7LP/sPt1SJyjYQ0bdqUl156ie7du/Pss89yzz330Lp1a5566ilCQ0PzPO5PP/3EqlWr+Oabb8wAs2jRIsLDw1m5ciWPPfYYISEhAFSsWPGKl2kujQDVrl073/1wNWlpaTidTjp27Mjtt98OQJ06dczXy5Urh4+Pj0u7vvjiC/bs2UNycjJWqxWAyZMns3LlSpYtW0bfvn0ByMrKYuHChdxyyy1ubTPA66+/TvPmzQHo3bs3o0aN4ueff6ZatWoAPProo3z55Ze88MILnD59milTpvDFF18QFRUFQLVq1di8eTOzZs2iRYsWV/yc6dOnM2fOHAzDICMjg5o1a7Ju3TrzdV9fX8aOHWs+j4iIIC4ujqVLl9K1a1ezrcOGDWPw4MFmvbvvvtvlc86fP89TTz3Fzp07+eabb6hSpQoAP/74Ixs3bmTHjh00adIEgDlz5lCjRo1cbe3evbtLAOnevTs9e/akf//+AAwdOpStW7cyefJkWrVqda0udjFu3Dizn1588UWio6M5e/YsZcqUYerUqfTq1Yv/+Z//Mc9348aNhTKqoxEdESnRWrVqRXx8PNu2bWPgwIF06NCBgQMH5lk3OjqaU6dO8dXXm5n7yf/R6+mn8qw3btw4kpKSmDlzJnXr1mXmzJnUrl2bPXv25Fl///79+Pj4uIwCBAUFUatWLfbv33/d55KfEaT8qFixIj179qRDhw489NBDvP322yQmJl71Pbt27eLUqVMEBQVRrlw585GQkMDPP/9s1rvtttsKJOQANGjQwPxzaGgoNpvNDDmXyi6Neuzbt4+zZ8/Srl07l/Z++OGHLu3NS48ePYiPj+e7775j8+bNVK9enfbt25Oenm7WmTlzJk2aNOGWW26hXLlyzJ49m6NHjwLZ87qOHz9OmzZtrvo5zz//PFu2bOHrr782Qw7AgQMH8PHxoVGjRmZZ9erVXSbUX3IpCF2yf/9+Mwxe0rx583z93F1yeX9XqlQJwOzf/fv3mwHykpzPC4qCjoiUaGXLlqV69eo0aNCAd955h8zMTJffvi/n4+NDTEwMr/5jHNt2/0CPJ7pd8bhBQUE89thjvPnmm+zfv5+wsDAmT56cZ90rBRTDMLBYLNd9LpfuqPrxxx+v+z0ApUqVytWGc+fOuTyfN28eW7ZsoVmzZnzyySfUrFmTrVu3XvGYFy9epFKlSsTHx7s8Dhw4wIgRI8x6l0/kdrfLL0FaLJZclyQtFgsXL1402wuwevVql/bu27fvmvN07HY71atXp3r16jRv3pwPPviAn376yZz4vXTpUp5//nl69erF+vXriY+P55lnniErKwsAf3//6zqfdu3a8dtvv7mMFsHVf35yyqu/c/6MXf5zV6pUqVzHyvmzcUnO/oa/+tWTFHRERC7z6quvMnnyZI4fP57n67169SL2q6/p3L5Fnr8x58XPz4/bb7+d06dP5/l63bp1OX/+PNu2bTPLTpw4wcGDB10uEV1L+/btCQ4OZtKkSXm+fvLkyTzLb7nlFpKSkly+zPKaL9OwYUNGjRpFXFwc9evXZ/HixUD2+V24cMGlbqNGjUhKSsLHx8cMAZcenrgN/Frq1q2L1Wrl6NGjudobHh6er2OVLl0agDNnspdV+Prrr2nWrBn9+/enYcOGVK9e3WWUKCAggKpVq/Kf//znqsft1KkTixcv5n/+539YsmSJWV67dm3Onz/P7t27zbJDhw5d8e/7cnXq1GHz5s0uZXFxcebP3aXRtstH8G5kLlWdOnVyBeOrBWV30hwdEZHLtGzZknr16jF+/HimTZuW6/U6deqQcvwotoxf83z/Z599xpIlS3j88cepWbMmhmHw73//mzVr1jBv3rw831OjRg06d+5Mnz59mDVrFgEBAbz44otUrlyZzp07X3fby5Yty5w5c3jsscfo1KkTgwYNonr16qSkpLB06VKOHj3q8gV5+Tn/8ccfTJo0iUcffZS1a9fy+eefU758eQASEhJ4//336dSpE2FhYRw4cICDBw/y1FPZl+6qVq1KQkIC8fHxVKlShYCAANq2bUtUVBRdunThn//8J7Vq1eL48eOsWbOGLl265LqE4mkBAQEMHz6c559/nosXL3LvvfeSlpZGXFwc5cqV4+mnn77iezMyMkhKSgLg999/5/XXX6dMmTK0b98eyL6M9OGHH7Ju3ToiIiJYuHAhO3bsICIiwjzGmDFjePbZZwkJCeGBBx4gPT2db775Jtdl1P/3//4fCxcuJCYmBh8fHx599FFq165N27Zt6du3LzNmzMDX15dhw4bh7+9/zRHBESNG0LVrV3Oi+L///W+WL1/Oxo0bgezRpqZNmzJx4kSqVq1KSkoKL7/8cr77d/DgwTz99NM0adKEe++9l0WLFrF3716XS4kFRUFHRAqc9eShYvUZQ4cO5ZlnnuGFF17I87f5oKAgMFLyfG/dunWx2WwMGzaMY8eOYbVaqVGjBnPmzCEmJuaKnzlv3jwGDx5Mx44dycrK4r777mPNmjX5Xuekc+fOxMXFMWHCBLp3705aWhrh4eG0bt3avJ04pzp16jB9+nTGjx/PP/7xDx555BGGDx/O+++/D2TfPv3jjz+yYMECTpw4Yd763K9fPwAeeeQRli9fTqtWrTh58qS5eOKaNWsYPXo0vXr14o8//sDhcHDfffddcVK2p/3jH/8gJCSECRMm8MsvvxAYGEijRo146aWXrvq+2bNnM3v2bAAqVKhAgwYNWLNmDbVq1QLg2WefJT4+nm7dumGxWHjiiSfo378/n3/+uXmMp59+mrNnz/LWW28xfPhwgoODefTRR/P8vEcffZSLFy8SExNDqVKlePjhh/nwww/p3bs39913Hw6HgwkTJrB3717KlClz1bZ36dKFt99+mzfeeINBgwYRERHBvHnzaNmypVln7ty59OrViyZNmlCrVi0mTZpkhrjr1a1bN37++WdeeOEFzp49yyOPPML//u//5roMVxAsRkHNXisG0tLSsNvtOJ1O8zcXEU9wx+KA9SwJrLaOJjpzHHuNiGu/wY0qB5RmTKsQQsKqYPHxM8uL+srIAA2qBOb/g7IyIOUABNcCP1v+3y9SwH799VfCw8PZuHHjNSc5F1Vnz54lISGBiIiIXIEtP9/fGtERkQJzrlxlDjz6H+11JVLAvvjiC06dOsUdd9xBYmIiI0eOpGrVqtx3332ebprHKeiISIE6V66ywodIATt37hwvvfQSv/zyCwEBATRr1oxFixaViC0erkVBR6QYCyOFCpbstTqqW37zcGtExFM6dOhAhw4dPN2MIklBR6SYCiOFjdYR2CyZZlmGYSXVuPKu1iIiJY2CjkgxVcGSjs2SyeCs/hwysi8NpRoBHKforVEiIuIpCjoixdwho3Kh32WV00UDwICSexOniLiZu24KV9ARkZt28uxFzl0wMM5nYfG1ero5+fL9rydzld3QLeci4lYZGRkANz2hWkFHRG7amfMG//nlFB39SlOhItlr6eRjj6ai5po7KmdlwnkDzmbCRe2kI+JOl3aBT05OJjAw0NxS40Yp6IiIWyzfn72PU5tqF/AtbQGKb9DxO3ONTRYvZEH6H5BWGkr7Xb2uiNyQwMBAHA7HTR9HQUdE3MIAPt1/mtU/ZVChTClKFd+cw3+Gtbx6heT9sHYYdF0IIZ6dHyXijXx9fW96JOcSBR0Rcauz5w0ST124dsUi7Fr7A+FjgVPHsv97rboi4lG6uCwiIiJeS0FHREREvJaCjoiIiHgtBR0RERHxWpqMLOIBVV9c7ekmiIiUCBrREREREa+lER0RkRuVcvCvP9uCIDDcc20RkTwp6IiI5JctCHxtsLzPX2W+NhiwXWFHpIhR0BERya/A8OxQk3Ei+3nKwezQk3FCQUekiFHQERG5EYHhCjUixYAmI4uIiIjXKvCgM2HCBCwWC0OGDDHLDMNgzJgxhIWF4e/vT8uWLdm7d6/L+zIzMxk4cCDBwcGULVuWTp068euvv7rUSU1NJSYmBrvdjt1uJyYmhpMnTxb0KYmIiEgxUaBBZ8eOHbz//vs0aNDApXzSpElMmTKFadOmsWPHDhwOB+3atSM9Pd2sM2TIEFasWMGSJUvYvHkzp06domPHjly48Ndmgd27dyc+Pp61a9eydu1a4uPjiYmJKchTEhERkWKkwILOqVOn6NGjB7Nnz6ZChQpmuWEYTJ06ldGjR/Pwww9Tv359FixYQEZGBosXLwbA6XTywQcf8Oabb9K2bVsaNmzIRx99xJ49e9i4cSMA+/fvZ+3atcyZM4eoqCiioqKYPXs2n332GQcOHCio0xLxmDBSqGdJMB/VLb95ukkiIkVegQWdAQMGEB0dTdu2bV3KExISSEpKon379maZ1WqlRYsWxMXFAbBr1y7OnTvnUicsLIz69eubdbZs2YLdbicyMtKs07RpU+x2u1knp8zMTNLS0lweIsVBGClstI5gtXW0+XjbbzoZhpVUI8DTzRMRKbIK5K6rJUuW8O2337Jjx45cryUlJQEQGhrqUh4aGsqRI0fMOn5+fi4jQZfqXHp/UlISISEhuY4fEhJi1slpwoQJjB07Nv8nJOJhFSzp2CyZDM7qzyGjslmeagRwnGAPtkxEpGhze9A5duwYgwcPZv369ZQpU+aK9SwWi8tzwzByleWUs05e9a92nFGjRjF06FDzeVpaGuHhuj1Uio9DRmX2GhGebobXy7kX2eGJ0R5qiYjcLLdfutq1axfJyck0btwYHx8ffHx8iI2N5Z133sHHx8ccyck56pKcnGy+5nA4yMrKIjU19ap1fv/991yf/8cff+QaLbrEarVSvnx5l4eIiIh4L7cHnTZt2rBnzx7i4+PNR5MmTejRowfx8fFUq1YNh8PBhg0bzPdkZWURGxtLs2bNAGjcuDG+vr4udRITE/nhhx/MOlFRUTidTrZv327W2bZtG06n06wjIiIiJZvbL10FBARQv359l7KyZcsSFBRklg8ZMoTx48dTo0YNatSowfjx47HZbHTv3h0Au91O7969GTZsGEFBQVSsWJHhw4dzxx13mJOb69Spw/3330+fPn2YNWsWAH379qVjx47UqlXL3aclIiIixZBHtoAYOXIkZ86coX///qSmphIZGcn69esJCPjr7pG33noLHx8funbtypkzZ2jTpg3z58+ndOnSZp1FixYxaNAg8+6sTp06MW3atEI/HxERESmaLIZhGJ5uhKekpaVht9txOp2aryMFJufE1htRz5LAautoojPHaTKyB1xzMvLxeHi/BfSNhbC7CqNJIiVafr6/tdeViIiIeC0FHREREfFaCjoiIiLitTwyGVlExCulHHR9bguCQC1KKuJJCjoiIjfLFgS+Nljex7Xc1wYDtivsiHiQgo6IyM0KDM8ONBkn/ipLOZgdfDJOKOiIeJCCjoiIOwSGK9CIFEGajCwiIiJeS0FHREREvJaCjoiIiHgtBR0RERHxWgo6IiIi4rUUdERERMRrKeiIiIiI19I6OiJFVBgpVLCkA1Dd8puHWyMiUjwp6IgUQWGksNE6Apsl0yzLMKykGgEebJWISPGjoCPiZlVfXH3Tx6hgScdmyWRwVn8OGZUBSDUCOE7wTR9bRKQkUdARKcIOGZXZa0R4uhkiIsWWJiOLiIiI19KIjojINeR1OfLwxGgPtERE8ksjOiIiIuK1FHRERETEaynoiIiIiNdS0BERERGvpaAjIiIiXktBR0RERLyWgo6IiIh4LQUdERER8VoKOiIiIuK1FHRERETEa2kLCBGRgpRy8K8/24IgMNxzbREpgRR0RG5CXnsgiQDZocbXBsv7/FXma4MB2xV2RAqRgo5IERBGChUs6ebz6pbfPNgacYvA8OxQk3Ei+3nKwezQk3FCQUekECnoiHhYGClstI7AZsl0Kc8wrKQaAR5qlbhFYLhCjYiHKeiIeFgFSzo2SyaDs/pzyKhslqcaARwn2IMtExEp/hR0RIqIQ0Zl9hoRnm6GiIhX0e3lIiIi4rUUdERERMRrKeiIiIiI11LQEREREa+loCMiIiJeS0FHREREvJZuLxcRuQE5t/84PDHaQy0RkatR0BHJB+1tJSJSvOjSlYiIiHgtjeiIiBSmlIOuz21B2g9LpAAp6IiIFAZbEPjasncwv5yvLXuXc4UdkQKhoCPiAWGkUMGSDkB1y28ebo0UisDw7ECTceKvspSD2cEn44SCjkgBUdARKWRhpLDROgKbJdMsyzCspBoBHmyVFIrAcAUakUKmoCNSyCpY0rFZMhmc1Z9DRmUAUo0AjhPs4ZaJiHgfBR0RDzlkVGavEeHpZoiIeDXdXi4iIiJeS0FHREREvJaCjoiIiHgtBR0RERHxWpqMLCLiBnntg6aNPkU8TyM6IiIi4rUUdERERMRrKeiIiIiI11LQEREREa+lycgiBezyDTxBm3iKiBQmt4/oTJgwgbvvvpuAgABCQkLo0qULBw4ccKljGAZjxowhLCwMf39/WrZsyd69e13qZGZmMnDgQIKDgylbtiydOnXi119/damTmppKTEwMdrsdu91OTEwMJ0+edPcpSQlV9cXVuR75dWkDz9XW0ebjbb/p2sRTRKSQuD3oxMbGMmDAALZu3cqGDRs4f/487du35/Tp02adSZMmMWXKFKZNm8aOHTtwOBy0a9eO9PS/fusdMmQIK1asYMmSJWzevJlTp07RsWNHLly4YNbp3r078fHxrF27lrVr1xIfH09MTIy7T0nkhl2+gWd05jjz0TbzDW3iKSJSCNx+6Wrt2rUuz+fNm0dISAi7du3ivvvuwzAMpk6dyujRo3n44YcBWLBgAaGhoSxevJh+/frhdDr54IMPWLhwIW3btgXgo48+Ijw8nI0bN9KhQwf279/P2rVr2bp1K5GRkQDMnj2bqKgoDhw4QK1atdx9aiI3TBt4ioh4RoFPRnY6nQBUrFgRgISEBJKSkmjfvr1Zx2q10qJFC+Li4gDYtWsX586dc6kTFhZG/fr1zTpbtmzBbrebIQegadOm2O12s05OmZmZpKWluTxERETEexVo0DEMg6FDh3LvvfdSv359AJKSkgAIDQ11qRsaGmq+lpSUhJ+fHxUqVLhqnZCQkFyfGRISYtbJacKECeZ8HrvdTnh4+M2doIiIO6QchOPx2Y+TxzzdGhGvUqB3XT333HN8//33bN68OddrFovF5blhGLnKcspZJ6/6VzvOqFGjGDp0qPk8LS1NYUdEPMcWBL42WN7nrzJfGwzYDoH6t0nEHQos6AwcOJBVq1bx1VdfUaVKFbPc4XAA2SMylSpVMsuTk5PNUR6Hw0FWVhapqakuozrJyck0a9bMrPP777/n+tw//vgj12jRJVarFavVevMnJyLiDoHh2aEm40T285SD2aEn44SCjoibuP3SlWEYPPfccyxfvpwvvviCiAjXCZgRERE4HA42bNhglmVlZREbG2uGmMaNG+Pr6+tSJzExkR9++MGsExUVhdPpZPv27Wadbdu24XQ6zToiIkVeYDiE3ZX9CK7p6daIeB23j+gMGDCAxYsX83//938EBASY82Xsdjv+/v5YLBaGDBnC+PHjqVGjBjVq1GD8+PHYbDa6d+9u1u3duzfDhg0jKCiIihUrMnz4cO644w7zLqw6depw//3306dPH2bNmgVA37596dixo+64EpEiIefaS9rNXKTwuT3ozJgxA4CWLVu6lM+bN4+ePXsCMHLkSM6cOUP//v1JTU0lMjKS9evXExDw1wJqb731Fj4+PnTt2pUzZ87Qpk0b5s+fT+nSpc06ixYtYtCgQebdWZ06dWLatGnuPiUREREppiyGYRieboSnpKWlYbfbcTqdlC9f3tPNEQ+7kZWPr6WeJYHV1tFEZ47TOjpy7RGd4/HwfgvoG5t9KUtE8pSf729t6ikiIiJeS0FHREREvJaCjoiIiHgtBR0RERHxWgW6MrJISRRGChUs6QBUt/zm4daIiJRsCjoibhRGChutI7BZMs2yDMNKqhFwlXeJiEhBUdARcaMKlnRslkwGZ/XnkFEZgFQjgOMEe7hlIiIlk4KOSAE4ZFTWujkiIkWAgo6ISFGTctD1uS1Im3yK3CAFHRGRosIWBL627B3ML+dry97lXGFHJN8UdEREiorA8OxAk3Hir7KUg9nBJ+OEgo7IDVDQEREpJHntp5Zr/6vAcAUaETfSgoEiIiLitTSiI3ITLl8cELRAoIhIUaOgIyVSXpcQ8iuvxQFBCwSKiBQlCjoiNyivxQFBCwSKiBQlCjoiN0mLA4qIFF2ajCwiIiJeS0FHREREvJaCjoiIiHgtzdEREfGgnHcA5lpAUERuikZ0RERExGsp6IiIiIjX0qUrKRHcsUAguK6ErFWQpVClHPzrz7Yg7Yclcp0UdESuU14rIWsVZClwtiDwtWXvYH6Jry17l3OFHZFrUtARuU55rYSsVZClwAWGZ4eajBPZz1MOZoeejBMKOiLXQUFHJJ+0ErIUusBwhRqRG6SgIyJShOQ1n0y3nIvcON11JSIiIl5LQUdERES8loKOiIiIeC3N0RGvUxBr5oDWzRERKY4UdETykNeaOaB1c0REihsFHZE85LVmDmjdHBGR4kZBR+QqtGaOFFmXbwkB2hZC5AoUdEREipO8toQAbQshcgUKOlLsuWvysUixkHNLCNC2ECJXoaAjIlLE5QzzhydGK9CIXCcFHZH/uvx2ct1KLsXS5fN2NGdHBFDQEQHyvp1ct5JLsZHXvB3N2REBFHREgLxvJ9et5FJs5Jy3ozk7IiYFHZHL6HZyKbYCwxVqRPKgoCMiUszkdafh4YnRHmiJSNGnoCPFivaxEhGR/FDQkRJH+1iJiJQcCjpS4mgfKxGRkkNBR0osTTwWb3L5Zd16lgRWWz3YGJEiREFHRMRbaeNPEQUdKdoKYvKxJh6Lt0s1ArTxp8h/KeiI19Oqx1LSHCdYG3+K/JeCjng9rXosJZIWEBQBFHSkBNHkYylJcl72NScoa+NPKWEUdKTIcNd8HBHJLc95O5qzIyWAgo54Ha16LJLbcYJplj7RZVL+20zXnB3xego64lW06rHIlR0nmOOG5qZJyaKgIx5TEJeqtOqxSP4MnvYJh4zN5vPVL3TWCI94FQUdKfbyWiNHE49Fri7VCCDDsPK233TXF94bp3k74lUUdKRY0xo5IjfmOMG0zXwj13y2t5nO4EnTzRFRjfBIcaegI4WiIFY4hux/mLVGjsiNyTlnJ89RHo3wSDGnoCPFxtUmGu+4WFvhRuQm5RzlMe/MOrrFdZVlrb8jxUixDzrTp0/njTfeIDExkXr16jF16lT+9re/ebpZJd6NjODkHK3JKa/RG9AIjog7XT7Kc2mEx6Y9s6QYK9ZB55NPPmHIkCFMnz6d5s2bM2vWLB544AH27dvHrbfe6unmlRjuuCx1pdGanDR6I1J4rnceT16/bByeGF2obRW5EothGIanG3GjIiMjadSoETNmzDDL6tSpQ5cuXZgwYcI135+WlobdbsfpdFK+fPmCbKpXKajRmrf9pucarclJozcinnWlGwCePTeEE8aV/x1dPfDe3IW6BCY3KD/f38V2RCcrK4tdu3bx4osvupS3b9+euLi4PN+TmZlJZuZf/3M6nU4gu8MKRPrvcOr3gjl2IXl01pZcZTXzeYyKlnSm+k7HRtaVKxmQdNaPLZm3kUTQNY6Ykc8WiIi7/IqNlpmvEfjfX1wu/f89zTLxqu9Lezd3WYbhx5Bz/fkzH3dJLusXla/2ShFQLhQCQt16yEvf29czVlNsg05KSgoXLlwgNNS180JDQ0lKSsrzPRMmTGDs2LG5ysPD9RtFQfvkumv+bwG2QkTc4ViO59f//3de/pGv2va3burDxMukp6djt9uvWqfYBp1LLBaLy3PDMHKVXTJq1CiGDh1qPr948SJ//vknQUFBV3zPjUpLSyM8PJxjx47pslgBUj8XDvVz4VA/Fw71c+EpqL42DIP09HTCwsKuWbfYBp3g4GBKly6da/QmOTk51yjPJVarFavV6lIWGBhYUE0EoHz58vofqRConwuH+rlwqJ8Lh/q58BREX19rJOeSUm791ELk5+dH48aN2bBhg0v5hg0baNasmYdaJSIiIkVJsR3RARg6dCgxMTE0adKEqKgo3n//fY4ePcqzzz7r6aaJiIhIEVCsg063bt04ceIEr732GomJidSvX581a9Zw2223ebppWK1WXn311VyXysS91M+FQ/1cONTPhUP9XHiKQl8X63V0RERERK6m2M7REREREbkWBR0RERHxWgo6IiIi4rUUdERERMRrKegUgOnTpxMREUGZMmVo3LgxX3/9taebVOx99dVXPPTQQ4SFhWGxWFi5cqXL64ZhMGbMGMLCwvD396dly5bs3bvXM40tpiZMmMDdd99NQEAAISEhdOnShQMHDrjUUT/fvBkzZtCgQQNzAbWoqCg+//xz83X1ccGYMGECFouFIUOGmGXqa/cYM2YMFovF5eFwOMzXPd3PCjpu9sknnzBkyBBGjx7N7t27+dvf/sYDDzzA0aNHPd20Yu306dPceeedTJs2Lc/XJ02axJQpU5g2bRo7duzA4XDQrl070tOvvGO6uIqNjWXAgAFs3bqVDRs2cP78edq3b8/p06fNOurnm1elShUmTpzIzp072blzJ61bt6Zz587mP/zqY/fbsWMH77//Pg0aNHApV1+7T7169UhMTDQfe/bsMV/zeD8b4lb33HOP8eyzz7qU1a5d23jxxRc91CLvAxgrVqwwn1+8eNFwOBzGxIkTzbKzZ88adrvdmDlzpgda6B2Sk5MNwIiNjTUMQ/1ckCpUqGDMmTNHfVwA0tPTjRo1ahgbNmwwWrRoYQwePNgwDP08u9Orr75q3HnnnXm+VhT6WSM6bpSVlcWuXbto3769S3n79u2Ji4vzUKu8X0JCAklJSS79brVaadGihfr9JjidTgAqVqwIqJ8LwoULF1iyZAmnT58mKipKfVwABgwYQHR0NG3btnUpV1+7108//URYWBgRERE8/vjj/PLLL0DR6OdivTJyUZOSksKFCxdybSoaGhqaa/NRcZ9LfZtXvx85csQTTSr2DMNg6NCh3HvvvdSvXx9QP7vTnj17iIqK4uzZs5QrV44VK1ZQt25d8x9+9bF7LFmyhG+//ZYdO3bkek0/z+4TGRnJhx9+SM2aNfn99995/fXXadasGXv37i0S/aygUwAsFovLc8MwcpWJ+6nf3ee5557j+++/Z/PmzbleUz/fvFq1ahEfH8/Jkyf59NNPefrpp4mNjTVfVx/fvGPHjjF48GDWr19PmTJlrlhPfX3zHnjgAfPPd9xxB1FRUdx+++0sWLCApk2bAp7tZ126cqPg4GBKly6da/QmOTk5V5oV97k0u1/97h4DBw5k1apVfPnll1SpUsUsVz+7j5+fH9WrV6dJkyZMmDCBO++8k7ffflt97Ea7du0iOTmZxo0b4+Pjg4+PD7Gxsbzzzjv4+PiY/am+dr+yZctyxx138NNPPxWJn2kFHTfy8/OjcePGbNiwwaV8w4YNNGvWzEOt8n4RERE4HA6Xfs/KyiI2Nlb9ng+GYfDcc8+xfPlyvvjiCyIiIlxeVz8XHMMwyMzMVB+7UZs2bdizZw/x8fHmo0mTJvTo0YP4+HiqVaumvi4gmZmZ7N+/n0qVKhWNn+lCmfJcgixZssTw9fU1PvjgA2Pfvn3GkCFDjLJlyxqHDx/2dNOKtfT0dGP37t3G7t27DcCYMmWKsXv3buPIkSOGYRjGxIkTDbvdbixfvtzYs2eP8cQTTxiVKlUy0tLSPNzy4uN///d/DbvdbmzatMlITEw0HxkZGWYd9fPNGzVqlPHVV18ZCQkJxvfff2+89NJLRqlSpYz169cbhqE+LkiX33VlGOprdxk2bJixadMm45dffjG2bt1qdOzY0QgICDC/9zzdzwo6BeC9994zbrvtNsPPz89o1KiReXuu3Lgvv/zSAHI9nn76acMwsm9hfPXVVw2Hw2FYrVbjvvvuM/bs2ePZRhczefUvYMybN8+so36+eb169TL/fbjllluMNm3amCHHMNTHBSln0FFfu0e3bt2MSpUqGb6+vkZYWJjx8MMPG3v37jVf93Q/WwzDMApn7EhERESkcGmOjoiIiHgtBR0RERHxWgo6IiIi4rUUdERERMRrKeiIiIiI11LQEREREa+loCMiIiJeS0FHREREvJaCjoiIiHgtBR0RERHxWgo6IiIi4rUUdERERMRr/X9smyjOW5e3iAAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(rmsctime_sig,label=\"RMS of Cluster Time Signal\", bins=100, range=(0.0,50.0))\n",
+    "plt.hist(rmsctime_back,label=\"RMS of Cluster Time Background\",histtype='step', bins=100, range=(0.0,50.0))\n",
+    "plt.legend()\n",
+    "plt.show"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "2fb45e39-2647-40be-a6f7-6f9b3fd9e5f9",
+   "metadata": {
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:absl:At this time, the v2.11+ optimizer `tf.keras.optimizers.Adam` runs slowly on M1/M2 Macs, please use the legacy Keras optimizer instead, located at `tf.keras.optimizers.legacy.Adam`.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/200\n",
+      "6472/6472 [==============================] - 3s 371us/step - loss: 0.5051 - accuracy: 0.7785 - val_loss: 0.4910 - val_accuracy: 0.7850\n",
+      "Epoch 2/200\n",
+      "6472/6472 [==============================] - 2s 363us/step - loss: 0.4433 - accuracy: 0.7941 - val_loss: 0.4115 - val_accuracy: 0.8091\n",
+      "Epoch 3/200\n",
+      "6472/6472 [==============================] - 2s 365us/step - loss: 0.4213 - accuracy: 0.8017 - val_loss: 0.4583 - val_accuracy: 0.7735\n",
+      "Epoch 4/200\n",
+      "6472/6472 [==============================] - 2s 372us/step - loss: 0.4037 - accuracy: 0.8113 - val_loss: 0.3961 - val_accuracy: 0.8139\n",
+      "Epoch 5/200\n",
+      "6472/6472 [==============================] - 3s 438us/step - loss: 0.3949 - accuracy: 0.8162 - val_loss: 0.3877 - val_accuracy: 0.8195\n",
+      "Epoch 6/200\n",
+      "6472/6472 [==============================] - 3s 455us/step - loss: 0.3892 - accuracy: 0.8195 - val_loss: 0.3841 - val_accuracy: 0.8234\n",
+      "Epoch 7/200\n",
+      "6472/6472 [==============================] - 2s 372us/step - loss: 0.3845 - accuracy: 0.8219 - val_loss: 0.3910 - val_accuracy: 0.8169\n",
+      "Epoch 8/200\n",
+      "6472/6472 [==============================] - 2s 372us/step - loss: 0.3823 - accuracy: 0.8233 - val_loss: 0.4053 - val_accuracy: 0.8096\n",
+      "Epoch 9/200\n",
+      "6472/6472 [==============================] - 2s 372us/step - loss: 0.3790 - accuracy: 0.8247 - val_loss: 0.3783 - val_accuracy: 0.8276\n",
+      "Epoch 10/200\n",
+      "6472/6472 [==============================] - 2s 373us/step - loss: 0.3767 - accuracy: 0.8254 - val_loss: 0.3753 - val_accuracy: 0.8291\n",
+      "Epoch 11/200\n",
+      "6472/6472 [==============================] - 2s 372us/step - loss: 0.3741 - accuracy: 0.8273 - val_loss: 0.3673 - val_accuracy: 0.8322\n",
+      "Epoch 12/200\n",
+      "6472/6472 [==============================] - 2s 372us/step - loss: 0.3721 - accuracy: 0.8284 - val_loss: 0.3713 - val_accuracy: 0.8305\n",
+      "Epoch 13/200\n",
+      "6472/6472 [==============================] - 2s 379us/step - loss: 0.3697 - accuracy: 0.8304 - val_loss: 0.4213 - val_accuracy: 0.7961\n",
+      "Epoch 14/200\n",
+      "6472/6472 [==============================] - 2s 374us/step - loss: 0.3680 - accuracy: 0.8316 - val_loss: 0.3859 - val_accuracy: 0.8185\n",
+      "Epoch 15/200\n",
+      "6472/6472 [==============================] - 2s 372us/step - loss: 0.3664 - accuracy: 0.8315 - val_loss: 0.3626 - val_accuracy: 0.8339\n",
+      "Epoch 16/200\n",
+      "6472/6472 [==============================] - 2s 374us/step - loss: 0.3651 - accuracy: 0.8331 - val_loss: 0.3702 - val_accuracy: 0.8275\n",
+      "Epoch 17/200\n",
+      "6472/6472 [==============================] - 2s 378us/step - loss: 0.3637 - accuracy: 0.8340 - val_loss: 0.3766 - val_accuracy: 0.8249\n",
+      "Epoch 18/200\n",
+      "6472/6472 [==============================] - 2s 380us/step - loss: 0.3628 - accuracy: 0.8341 - val_loss: 0.3680 - val_accuracy: 0.8303\n",
+      "Epoch 19/200\n",
+      "6472/6472 [==============================] - 2s 372us/step - loss: 0.3615 - accuracy: 0.8349 - val_loss: 0.3606 - val_accuracy: 0.8347\n",
+      "Epoch 20/200\n",
+      "6472/6472 [==============================] - 2s 380us/step - loss: 0.3611 - accuracy: 0.8349 - val_loss: 0.3566 - val_accuracy: 0.8382\n",
+      "Epoch 21/200\n",
+      "6472/6472 [==============================] - 2s 380us/step - loss: 0.3599 - accuracy: 0.8363 - val_loss: 0.3557 - val_accuracy: 0.8380\n",
+      "Epoch 22/200\n",
+      "6472/6472 [==============================] - 2s 375us/step - loss: 0.3591 - accuracy: 0.8361 - val_loss: 0.3567 - val_accuracy: 0.8379\n",
+      "Epoch 23/200\n",
+      "6472/6472 [==============================] - 3s 392us/step - loss: 0.3581 - accuracy: 0.8368 - val_loss: 0.3550 - val_accuracy: 0.8392\n",
+      "Epoch 24/200\n",
+      "6472/6472 [==============================] - 2s 372us/step - loss: 0.3581 - accuracy: 0.8366 - val_loss: 0.3620 - val_accuracy: 0.8366\n",
+      "Epoch 25/200\n",
+      "6472/6472 [==============================] - 2s 384us/step - loss: 0.3572 - accuracy: 0.8370 - val_loss: 0.3713 - val_accuracy: 0.8330\n",
+      "Epoch 26/200\n",
+      "6472/6472 [==============================] - 2s 374us/step - loss: 0.3566 - accuracy: 0.8376 - val_loss: 0.3533 - val_accuracy: 0.8409\n",
+      "Epoch 27/200\n",
+      "6472/6472 [==============================] - 2s 370us/step - loss: 0.3560 - accuracy: 0.8387 - val_loss: 0.3514 - val_accuracy: 0.8415\n",
+      "Epoch 28/200\n",
+      "6472/6472 [==============================] - 2s 372us/step - loss: 0.3551 - accuracy: 0.8391 - val_loss: 0.3571 - val_accuracy: 0.8375\n",
+      "Epoch 29/200\n",
+      "6472/6472 [==============================] - 2s 376us/step - loss: 0.3554 - accuracy: 0.8387 - val_loss: 0.3563 - val_accuracy: 0.8390\n",
+      "Epoch 30/200\n",
+      "6472/6472 [==============================] - 2s 371us/step - loss: 0.3540 - accuracy: 0.8394 - val_loss: 0.3561 - val_accuracy: 0.8395\n",
+      "Epoch 31/200\n",
+      "6472/6472 [==============================] - 2s 373us/step - loss: 0.3539 - accuracy: 0.8393 - val_loss: 0.3698 - val_accuracy: 0.8331\n",
+      "Epoch 32/200\n",
+      "6472/6472 [==============================] - 2s 371us/step - loss: 0.3537 - accuracy: 0.8396 - val_loss: 0.3518 - val_accuracy: 0.8405\n",
+      "Epoch 33/200\n",
+      "6472/6472 [==============================] - 2s 373us/step - loss: 0.3533 - accuracy: 0.8388 - val_loss: 0.3606 - val_accuracy: 0.8351\n",
+      "Epoch 34/200\n",
+      "6472/6472 [==============================] - 2s 370us/step - loss: 0.3526 - accuracy: 0.8395 - val_loss: 0.3510 - val_accuracy: 0.8414\n",
+      "Epoch 35/200\n",
+      "6472/6472 [==============================] - 2s 372us/step - loss: 0.3525 - accuracy: 0.8404 - val_loss: 0.3505 - val_accuracy: 0.8409\n",
+      "Epoch 36/200\n",
+      "6472/6472 [==============================] - 2s 370us/step - loss: 0.3516 - accuracy: 0.8408 - val_loss: 0.3759 - val_accuracy: 0.8271\n",
+      "Epoch 37/200\n",
+      "6472/6472 [==============================] - 2s 372us/step - loss: 0.3516 - accuracy: 0.8404 - val_loss: 0.3571 - val_accuracy: 0.8366\n",
+      "Epoch 38/200\n",
+      "6472/6472 [==============================] - 2s 372us/step - loss: 0.3510 - accuracy: 0.8403 - val_loss: 0.3501 - val_accuracy: 0.8412\n",
+      "Epoch 39/200\n",
+      "6472/6472 [==============================] - 2s 370us/step - loss: 0.3509 - accuracy: 0.8405 - val_loss: 0.3482 - val_accuracy: 0.8424\n",
+      "Epoch 40/200\n",
+      "6472/6472 [==============================] - 2s 373us/step - loss: 0.3504 - accuracy: 0.8407 - val_loss: 0.3504 - val_accuracy: 0.8419\n",
+      "Epoch 41/200\n",
+      "6472/6472 [==============================] - 2s 372us/step - loss: 0.3502 - accuracy: 0.8409 - val_loss: 0.3577 - val_accuracy: 0.8361\n",
+      "Epoch 42/200\n",
+      "6472/6472 [==============================] - 2s 372us/step - loss: 0.3501 - accuracy: 0.8406 - val_loss: 0.3460 - val_accuracy: 0.8435\n",
+      "Epoch 43/200\n",
+      "6472/6472 [==============================] - 2s 370us/step - loss: 0.3495 - accuracy: 0.8417 - val_loss: 0.3502 - val_accuracy: 0.8404\n",
+      "Epoch 44/200\n",
+      "6472/6472 [==============================] - 2s 371us/step - loss: 0.3494 - accuracy: 0.8415 - val_loss: 0.3485 - val_accuracy: 0.8431\n",
+      "Epoch 45/200\n",
+      "6472/6472 [==============================] - 2s 370us/step - loss: 0.3490 - accuracy: 0.8420 - val_loss: 0.3483 - val_accuracy: 0.8420\n",
+      "Epoch 46/200\n",
+      "6472/6472 [==============================] - 2s 373us/step - loss: 0.3486 - accuracy: 0.8415 - val_loss: 0.3458 - val_accuracy: 0.8442\n",
+      "Epoch 47/200\n",
+      "6472/6472 [==============================] - 2s 370us/step - loss: 0.3484 - accuracy: 0.8416 - val_loss: 0.3549 - val_accuracy: 0.8355\n",
+      "Epoch 48/200\n",
+      "6472/6472 [==============================] - 2s 372us/step - loss: 0.3486 - accuracy: 0.8417 - val_loss: 0.3472 - val_accuracy: 0.8425\n",
+      "Epoch 49/200\n",
+      "6472/6472 [==============================] - 2s 372us/step - loss: 0.3486 - accuracy: 0.8421 - val_loss: 0.3498 - val_accuracy: 0.8426\n",
+      "Epoch 50/200\n",
+      "6472/6472 [==============================] - 2s 373us/step - loss: 0.3481 - accuracy: 0.8425 - val_loss: 0.3575 - val_accuracy: 0.8384\n",
+      "Epoch 51/200\n",
+      "6472/6472 [==============================] - 2s 371us/step - loss: 0.3477 - accuracy: 0.8421 - val_loss: 0.3457 - val_accuracy: 0.8438\n",
+      "Epoch 52/200\n",
+      "6472/6472 [==============================] - 2s 373us/step - loss: 0.3476 - accuracy: 0.8429 - val_loss: 0.3528 - val_accuracy: 0.8389\n",
+      "Epoch 53/200\n",
+      "6472/6472 [==============================] - 2s 374us/step - loss: 0.3483 - accuracy: 0.8426 - val_loss: 0.3474 - val_accuracy: 0.8449\n",
+      "Epoch 54/200\n",
+      "6472/6472 [==============================] - 2s 370us/step - loss: 0.3474 - accuracy: 0.8425 - val_loss: 0.3657 - val_accuracy: 0.8322\n",
+      "Epoch 55/200\n",
+      "6472/6472 [==============================] - 2s 373us/step - loss: 0.3475 - accuracy: 0.8421 - val_loss: 0.3558 - val_accuracy: 0.8405\n",
+      "Epoch 56/200\n",
+      "6472/6472 [==============================] - 2s 372us/step - loss: 0.3475 - accuracy: 0.8429 - val_loss: 0.3507 - val_accuracy: 0.8383\n",
+      "Epoch 57/200\n",
+      "6472/6472 [==============================] - 2s 370us/step - loss: 0.3471 - accuracy: 0.8428 - val_loss: 0.3517 - val_accuracy: 0.8397\n",
+      "Epoch 58/200\n",
+      "6472/6472 [==============================] - 2s 372us/step - loss: 0.3469 - accuracy: 0.8429 - val_loss: 0.3460 - val_accuracy: 0.8440\n",
+      "Epoch 59/200\n",
+      "6472/6472 [==============================] - 2s 370us/step - loss: 0.3472 - accuracy: 0.8429 - val_loss: 0.3451 - val_accuracy: 0.8437\n",
+      "Epoch 60/200\n",
+      "6472/6472 [==============================] - 2s 374us/step - loss: 0.3470 - accuracy: 0.8430 - val_loss: 0.3454 - val_accuracy: 0.8440\n",
+      "Epoch 61/200\n",
+      "6472/6472 [==============================] - 2s 371us/step - loss: 0.3464 - accuracy: 0.8433 - val_loss: 0.3582 - val_accuracy: 0.8352\n",
+      "Epoch 62/200\n",
+      "6472/6472 [==============================] - 2s 372us/step - loss: 0.3462 - accuracy: 0.8438 - val_loss: 0.3472 - val_accuracy: 0.8428\n",
+      "Epoch 63/200\n",
+      "6472/6472 [==============================] - 2s 373us/step - loss: 0.3461 - accuracy: 0.8430 - val_loss: 0.3422 - val_accuracy: 0.8460\n",
+      "Epoch 64/200\n",
+      "6472/6472 [==============================] - 2s 372us/step - loss: 0.3464 - accuracy: 0.8439 - val_loss: 0.3499 - val_accuracy: 0.8432\n",
+      "Epoch 65/200\n",
+      "6472/6472 [==============================] - 2s 370us/step - loss: 0.3467 - accuracy: 0.8426 - val_loss: 0.3468 - val_accuracy: 0.8428\n",
+      "Epoch 66/200\n",
+      "6472/6472 [==============================] - 2s 371us/step - loss: 0.3470 - accuracy: 0.8429 - val_loss: 0.3463 - val_accuracy: 0.8427\n",
+      "Epoch 67/200\n",
+      "6472/6472 [==============================] - 2s 370us/step - loss: 0.3461 - accuracy: 0.8434 - val_loss: 0.3570 - val_accuracy: 0.8395\n",
+      "Epoch 68/200\n",
+      "6472/6472 [==============================] - 2s 372us/step - loss: 0.3461 - accuracy: 0.8433 - val_loss: 0.3432 - val_accuracy: 0.8468\n",
+      "Epoch 69/200\n",
+      "6472/6472 [==============================] - 2s 371us/step - loss: 0.3463 - accuracy: 0.8429 - val_loss: 0.3443 - val_accuracy: 0.8459\n",
+      "Epoch 70/200\n",
+      "6472/6472 [==============================] - 2s 370us/step - loss: 0.3459 - accuracy: 0.8435 - val_loss: 0.3465 - val_accuracy: 0.8434\n",
+      "Epoch 71/200\n",
+      "6472/6472 [==============================] - 2s 372us/step - loss: 0.3456 - accuracy: 0.8440 - val_loss: 0.3628 - val_accuracy: 0.8301\n",
+      "Epoch 72/200\n",
+      "6472/6472 [==============================] - 2s 369us/step - loss: 0.3456 - accuracy: 0.8437 - val_loss: 0.3459 - val_accuracy: 0.8444\n",
+      "Epoch 73/200\n",
+      "6472/6472 [==============================] - 2s 371us/step - loss: 0.3464 - accuracy: 0.8434 - val_loss: 0.3459 - val_accuracy: 0.8439\n"
+     ]
+    }
+   ],
+   "source": [
+    "lay0=Input(shape=(n_variables,),batch_size=1)\n",
+    "lay1=Dense(2*n_variables, activation='relu')(lay0)\n",
+    "lay2=Dense(2*n_variables, activation='relu')(lay1)\n",
+    "lay3=Dense(2*n_variables, activation='relu')(lay2)\n",
+    "lay4=Dense(1,activation='sigmoid')(lay3)\n",
+    "output_model=Model(inputs=lay0,outputs=lay4)\n",
+    "\n",
+    "opt = Adam(learning_rate=1e-3)\n",
+    "input=Input(shape=(n_variables,),batch_size=bsize)\n",
+    "x=Dense(2*n_variables, activation='relu')(input)\n",
+    "x=Dense(2*n_variables, activation='relu')(x)\n",
+    "x=Dense(2*n_variables, activation='relu')(x)\n",
+    "output=Dense(1,activation='sigmoid')(x)\n",
+    "model_ce=Model(inputs=input,outputs=output)\n",
+    "model_ce.compile(loss='binary_crossentropy',metrics=['accuracy'],optimizer=opt)\n",
+    "early_stop = EarlyStopping(monitor='val_loss', patience=10, min_delta=1e-5, restore_best_weights=True)\n",
+    "history_ce = model_ce.fit(x_ce_train, y_ce_train,\n",
+    "                          batch_size=bsize,\n",
+    "                          epochs=200,\n",
+    "                          verbose=1,\n",
+    "                          validation_data=(x_ce_valid, y_ce_valid),\n",
+    "                          callbacks=[early_stop]\n",
+    "                         )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "992eb5b3-70a0-4afe-9036-9867906ebe3e",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<style>#sk-container-id-1 {\n",
+       "  /* Definition of color scheme common for light and dark mode */\n",
+       "  --sklearn-color-text: black;\n",
+       "  --sklearn-color-line: gray;\n",
+       "  /* Definition of color scheme for unfitted estimators */\n",
+       "  --sklearn-color-unfitted-level-0: #fff5e6;\n",
+       "  --sklearn-color-unfitted-level-1: #f6e4d2;\n",
+       "  --sklearn-color-unfitted-level-2: #ffe0b3;\n",
+       "  --sklearn-color-unfitted-level-3: chocolate;\n",
+       "  /* Definition of color scheme for fitted estimators */\n",
+       "  --sklearn-color-fitted-level-0: #f0f8ff;\n",
+       "  --sklearn-color-fitted-level-1: #d4ebff;\n",
+       "  --sklearn-color-fitted-level-2: #b3dbfd;\n",
+       "  --sklearn-color-fitted-level-3: cornflowerblue;\n",
+       "\n",
+       "  /* Specific color for light theme */\n",
+       "  --sklearn-color-text-on-default-background: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, black)));\n",
+       "  --sklearn-color-background: var(--sg-background-color, var(--theme-background, var(--jp-layout-color0, white)));\n",
+       "  --sklearn-color-border-box: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, black)));\n",
+       "  --sklearn-color-icon: #696969;\n",
+       "\n",
+       "  @media (prefers-color-scheme: dark) {\n",
+       "    /* Redefinition of color scheme for dark theme */\n",
+       "    --sklearn-color-text-on-default-background: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, white)));\n",
+       "    --sklearn-color-background: var(--sg-background-color, var(--theme-background, var(--jp-layout-color0, #111)));\n",
+       "    --sklearn-color-border-box: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, white)));\n",
+       "    --sklearn-color-icon: #878787;\n",
+       "  }\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 pre {\n",
+       "  padding: 0;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 input.sk-hidden--visually {\n",
+       "  border: 0;\n",
+       "  clip: rect(1px 1px 1px 1px);\n",
+       "  clip: rect(1px, 1px, 1px, 1px);\n",
+       "  height: 1px;\n",
+       "  margin: -1px;\n",
+       "  overflow: hidden;\n",
+       "  padding: 0;\n",
+       "  position: absolute;\n",
+       "  width: 1px;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-dashed-wrapped {\n",
+       "  border: 1px dashed var(--sklearn-color-line);\n",
+       "  margin: 0 0.4em 0.5em 0.4em;\n",
+       "  box-sizing: border-box;\n",
+       "  padding-bottom: 0.4em;\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-container {\n",
+       "  /* jupyter's `normalize.less` sets `[hidden] { display: none; }`\n",
+       "     but bootstrap.min.css set `[hidden] { display: none !important; }`\n",
+       "     so we also need the `!important` here to be able to override the\n",
+       "     default hidden behavior on the sphinx rendered scikit-learn.org.\n",
+       "     See: https://github.com/scikit-learn/scikit-learn/issues/21755 */\n",
+       "  display: inline-block !important;\n",
+       "  position: relative;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-text-repr-fallback {\n",
+       "  display: none;\n",
+       "}\n",
+       "\n",
+       "div.sk-parallel-item,\n",
+       "div.sk-serial,\n",
+       "div.sk-item {\n",
+       "  /* draw centered vertical line to link estimators */\n",
+       "  background-image: linear-gradient(var(--sklearn-color-text-on-default-background), var(--sklearn-color-text-on-default-background));\n",
+       "  background-size: 2px 100%;\n",
+       "  background-repeat: no-repeat;\n",
+       "  background-position: center center;\n",
+       "}\n",
+       "\n",
+       "/* Parallel-specific style estimator block */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel-item::after {\n",
+       "  content: \"\";\n",
+       "  width: 100%;\n",
+       "  border-bottom: 2px solid var(--sklearn-color-text-on-default-background);\n",
+       "  flex-grow: 1;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel {\n",
+       "  display: flex;\n",
+       "  align-items: stretch;\n",
+       "  justify-content: center;\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "  position: relative;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel-item {\n",
+       "  display: flex;\n",
+       "  flex-direction: column;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel-item:first-child::after {\n",
+       "  align-self: flex-end;\n",
+       "  width: 50%;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel-item:last-child::after {\n",
+       "  align-self: flex-start;\n",
+       "  width: 50%;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel-item:only-child::after {\n",
+       "  width: 0;\n",
+       "}\n",
+       "\n",
+       "/* Serial-specific style estimator block */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-serial {\n",
+       "  display: flex;\n",
+       "  flex-direction: column;\n",
+       "  align-items: center;\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "  padding-right: 1em;\n",
+       "  padding-left: 1em;\n",
+       "}\n",
+       "\n",
+       "\n",
+       "/* Toggleable style: style used for estimator/Pipeline/ColumnTransformer box that is\n",
+       "clickable and can be expanded/collapsed.\n",
+       "- Pipeline and ColumnTransformer use this feature and define the default style\n",
+       "- Estimators will overwrite some part of the style using the `sk-estimator` class\n",
+       "*/\n",
+       "\n",
+       "/* Pipeline and ColumnTransformer style (default) */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-toggleable {\n",
+       "  /* Default theme specific background. It is overwritten whether we have a\n",
+       "  specific estimator or a Pipeline/ColumnTransformer */\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "}\n",
+       "\n",
+       "/* Toggleable label */\n",
+       "#sk-container-id-1 label.sk-toggleable__label {\n",
+       "  cursor: pointer;\n",
+       "  display: block;\n",
+       "  width: 100%;\n",
+       "  margin-bottom: 0;\n",
+       "  padding: 0.5em;\n",
+       "  box-sizing: border-box;\n",
+       "  text-align: center;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 label.sk-toggleable__label-arrow:before {\n",
+       "  /* Arrow on the left of the label */\n",
+       "  content: \"▸\";\n",
+       "  float: left;\n",
+       "  margin-right: 0.25em;\n",
+       "  color: var(--sklearn-color-icon);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "}\n",
+       "\n",
+       "/* Toggleable content - dropdown */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-toggleable__content {\n",
+       "  max-height: 0;\n",
+       "  max-width: 0;\n",
+       "  overflow: hidden;\n",
+       "  text-align: left;\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-toggleable__content.fitted {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-toggleable__content pre {\n",
+       "  margin: 0.2em;\n",
+       "  border-radius: 0.25em;\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-toggleable__content.fitted pre {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {\n",
+       "  /* Expand drop-down */\n",
+       "  max-height: 200px;\n",
+       "  max-width: 100%;\n",
+       "  overflow: auto;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {\n",
+       "  content: \"▾\";\n",
+       "}\n",
+       "\n",
+       "/* Pipeline/ColumnTransformer-specific style */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-label.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
+       "  background-color: var(--sklearn-color-fitted-level-2);\n",
+       "}\n",
+       "\n",
+       "/* Estimator-specific style */\n",
+       "\n",
+       "/* Colorize estimator box */\n",
+       "#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-estimator.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-2);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-label label.sk-toggleable__label,\n",
+       "#sk-container-id-1 div.sk-label label {\n",
+       "  /* The background is the default theme color */\n",
+       "  color: var(--sklearn-color-text-on-default-background);\n",
+       "}\n",
+       "\n",
+       "/* On hover, darken the color of the background */\n",
+       "#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
+       "}\n",
+       "\n",
+       "/* Label box, darken color on hover, fitted */\n",
+       "#sk-container-id-1 div.sk-label.fitted:hover label.sk-toggleable__label.fitted {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  background-color: var(--sklearn-color-fitted-level-2);\n",
+       "}\n",
+       "\n",
+       "/* Estimator label */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-label label {\n",
+       "  font-family: monospace;\n",
+       "  font-weight: bold;\n",
+       "  display: inline-block;\n",
+       "  line-height: 1.2em;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-label-container {\n",
+       "  text-align: center;\n",
+       "}\n",
+       "\n",
+       "/* Estimator-specific */\n",
+       "#sk-container-id-1 div.sk-estimator {\n",
+       "  font-family: monospace;\n",
+       "  border: 1px dotted var(--sklearn-color-border-box);\n",
+       "  border-radius: 0.25em;\n",
+       "  box-sizing: border-box;\n",
+       "  margin-bottom: 0.5em;\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-estimator.fitted {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-0);\n",
+       "}\n",
+       "\n",
+       "/* on hover */\n",
+       "#sk-container-id-1 div.sk-estimator:hover {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-estimator.fitted:hover {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-2);\n",
+       "}\n",
+       "\n",
+       "/* Specification for estimator info (e.g. \"i\" and \"?\") */\n",
+       "\n",
+       "/* Common style for \"i\" and \"?\" */\n",
+       "\n",
+       ".sk-estimator-doc-link,\n",
+       "a:link.sk-estimator-doc-link,\n",
+       "a:visited.sk-estimator-doc-link {\n",
+       "  float: right;\n",
+       "  font-size: smaller;\n",
+       "  line-height: 1em;\n",
+       "  font-family: monospace;\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "  border-radius: 1em;\n",
+       "  height: 1em;\n",
+       "  width: 1em;\n",
+       "  text-decoration: none !important;\n",
+       "  margin-left: 1ex;\n",
+       "  /* unfitted */\n",
+       "  border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n",
+       "  color: var(--sklearn-color-unfitted-level-1);\n",
+       "}\n",
+       "\n",
+       ".sk-estimator-doc-link.fitted,\n",
+       "a:link.sk-estimator-doc-link.fitted,\n",
+       "a:visited.sk-estimator-doc-link.fitted {\n",
+       "  /* fitted */\n",
+       "  border: var(--sklearn-color-fitted-level-1) 1pt solid;\n",
+       "  color: var(--sklearn-color-fitted-level-1);\n",
+       "}\n",
+       "\n",
+       "/* On hover */\n",
+       "div.sk-estimator:hover .sk-estimator-doc-link:hover,\n",
+       ".sk-estimator-doc-link:hover,\n",
+       "div.sk-label-container:hover .sk-estimator-doc-link:hover,\n",
+       ".sk-estimator-doc-link:hover {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-3);\n",
+       "  color: var(--sklearn-color-background);\n",
+       "  text-decoration: none;\n",
+       "}\n",
+       "\n",
+       "div.sk-estimator.fitted:hover .sk-estimator-doc-link.fitted:hover,\n",
+       ".sk-estimator-doc-link.fitted:hover,\n",
+       "div.sk-label-container:hover .sk-estimator-doc-link.fitted:hover,\n",
+       ".sk-estimator-doc-link.fitted:hover {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-3);\n",
+       "  color: var(--sklearn-color-background);\n",
+       "  text-decoration: none;\n",
+       "}\n",
+       "\n",
+       "/* Span, style for the box shown on hovering the info icon */\n",
+       ".sk-estimator-doc-link span {\n",
+       "  display: none;\n",
+       "  z-index: 9999;\n",
+       "  position: relative;\n",
+       "  font-weight: normal;\n",
+       "  right: .2ex;\n",
+       "  padding: .5ex;\n",
+       "  margin: .5ex;\n",
+       "  width: min-content;\n",
+       "  min-width: 20ex;\n",
+       "  max-width: 50ex;\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  box-shadow: 2pt 2pt 4pt #999;\n",
+       "  /* unfitted */\n",
+       "  background: var(--sklearn-color-unfitted-level-0);\n",
+       "  border: .5pt solid var(--sklearn-color-unfitted-level-3);\n",
+       "}\n",
+       "\n",
+       ".sk-estimator-doc-link.fitted span {\n",
+       "  /* fitted */\n",
+       "  background: var(--sklearn-color-fitted-level-0);\n",
+       "  border: var(--sklearn-color-fitted-level-3);\n",
+       "}\n",
+       "\n",
+       ".sk-estimator-doc-link:hover span {\n",
+       "  display: block;\n",
+       "}\n",
+       "\n",
+       "/* \"?\"-specific style due to the `<a>` HTML tag */\n",
+       "\n",
+       "#sk-container-id-1 a.estimator_doc_link {\n",
+       "  float: right;\n",
+       "  font-size: 1rem;\n",
+       "  line-height: 1em;\n",
+       "  font-family: monospace;\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "  border-radius: 1rem;\n",
+       "  height: 1rem;\n",
+       "  width: 1rem;\n",
+       "  text-decoration: none;\n",
+       "  /* unfitted */\n",
+       "  color: var(--sklearn-color-unfitted-level-1);\n",
+       "  border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 a.estimator_doc_link.fitted {\n",
+       "  /* fitted */\n",
+       "  border: var(--sklearn-color-fitted-level-1) 1pt solid;\n",
+       "  color: var(--sklearn-color-fitted-level-1);\n",
+       "}\n",
+       "\n",
+       "/* On hover */\n",
+       "#sk-container-id-1 a.estimator_doc_link:hover {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-3);\n",
+       "  color: var(--sklearn-color-background);\n",
+       "  text-decoration: none;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 a.estimator_doc_link.fitted:hover {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-3);\n",
+       "}\n",
+       "</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>XGBClassifier(base_score=None, booster=None, callbacks=None,\n",
+       "              colsample_bylevel=None, colsample_bynode=None,\n",
+       "              colsample_bytree=None, device=None, early_stopping_rounds=None,\n",
+       "              enable_categorical=False, eval_metric=None, feature_types=None,\n",
+       "              gamma=None, grow_policy=None, importance_type=None,\n",
+       "              interaction_constraints=None, learning_rate=None, max_bin=None,\n",
+       "              max_cat_threshold=None, max_cat_to_onehot=None,\n",
+       "              max_delta_step=None, max_depth=None, max_leaves=None,\n",
+       "              min_child_weight=None, missing=nan, monotone_constraints=None,\n",
+       "              multi_strategy=None, n_estimators=None, n_jobs=None,\n",
+       "              num_parallel_tree=None, random_state=None, ...)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow fitted\">&nbsp;XGBClassifier<span class=\"sk-estimator-doc-link fitted\">i<span>Fitted</span></span></label><div class=\"sk-toggleable__content fitted\"><pre>XGBClassifier(base_score=None, booster=None, callbacks=None,\n",
+       "              colsample_bylevel=None, colsample_bynode=None,\n",
+       "              colsample_bytree=None, device=None, early_stopping_rounds=None,\n",
+       "              enable_categorical=False, eval_metric=None, feature_types=None,\n",
+       "              gamma=None, grow_policy=None, importance_type=None,\n",
+       "              interaction_constraints=None, learning_rate=None, max_bin=None,\n",
+       "              max_cat_threshold=None, max_cat_to_onehot=None,\n",
+       "              max_delta_step=None, max_depth=None, max_leaves=None,\n",
+       "              min_child_weight=None, missing=nan, monotone_constraints=None,\n",
+       "              multi_strategy=None, n_estimators=None, n_jobs=None,\n",
+       "              num_parallel_tree=None, random_state=None, ...)</pre></div> </div></div></div></div>"
+      ],
+      "text/plain": [
+       "XGBClassifier(base_score=None, booster=None, callbacks=None,\n",
+       "              colsample_bylevel=None, colsample_bynode=None,\n",
+       "              colsample_bytree=None, device=None, early_stopping_rounds=None,\n",
+       "              enable_categorical=False, eval_metric=None, feature_types=None,\n",
+       "              gamma=None, grow_policy=None, importance_type=None,\n",
+       "              interaction_constraints=None, learning_rate=None, max_bin=None,\n",
+       "              max_cat_threshold=None, max_cat_to_onehot=None,\n",
+       "              max_delta_step=None, max_depth=None, max_leaves=None,\n",
+       "              min_child_weight=None, missing=nan, monotone_constraints=None,\n",
+       "              multi_strategy=None, n_estimators=None, n_jobs=None,\n",
+       "              num_parallel_tree=None, random_state=None, ...)"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model_xgboost = XGBClassifier()\n",
+    "model_xgboost.fit(x_ce_train, y_ce_train)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "e1d31e4c-d2ac-47fc-ac57-7e6442554b20",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3236/3236 [==============================] - 1s 188us/step\n"
+     ]
+    }
+   ],
+   "source": [
+    "#prediction_ce = model_ce.predict(x_ce_test).ravel()\n",
+    "prediction_ce = model_ce.predict(x_ce_test)\n",
+    "fpr_ce, tpr_ce, th_ce = roc_curve(y_ce_test,  prediction_ce)\n",
+    "auc_ce = roc_auc_score(y_ce_test, prediction_ce)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "a1486d9a-7863-4d8f-b99e-27440c56ad2d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fpr_ce, tpr_ce, th_ce = roc_curve(y_ce_test, prediction_ce)\n",
+    "auc_ce = roc_auc_score(y_ce_test, prediction_ce)\n",
+    "\n",
+    "# Plot ROC curve\n",
+    "plt.figure(figsize=(6,6))\n",
+    "plt.plot(fpr_ce, tpr_ce, color='blue', lw=2, label=f'ROC curve (AUC = {auc_ce:.3f})')\n",
+    "plt.plot([0, 1], [0, 1], color='gray', lw=1, linestyle='--', label='Random guess')\n",
+    "plt.xlabel('False Positive Rate (FPR)')\n",
+    "plt.ylabel('True Positive Rate (TPR)')\n",
+    "plt.title('ROC Curve')\n",
+    "plt.legend(loc='lower right')\n",
+    "plt.grid(True)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "a2cc1d55-51ef-429a-8d83-de265d12e453",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "prediction_xgboost = model_xgboost.predict_proba(x_ce_test)[:,1]\n",
+    "fpr_xgboost, tpr_xgboost, th_xgboost = roc_curve(y_ce_test,  prediction_xgboost)\n",
+    "auc_xgboost = roc_auc_score(y_ce_test, prediction_xgboost)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "5adef9a7-f0c1-40b2-ab26-165e5a560d7e",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.0, 1.05)"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(1,1)\n",
+    "ax.plot(tpr_ce,1-fpr_ce,label=f'MLP AUC: {auc_ce:.4f}')\n",
+    "ax.plot(tpr_xgboost,1-fpr_xgboost,label=f'BDT AUC: {auc_xgboost:.4f}')\n",
+    "\n",
+    "ax.legend()\n",
+    "ax.set_aspect(\"equal\")\n",
+    "ax.set_xlabel(\"Signal efficiency\")\n",
+    "ax.set_ylabel(\"Background rejection\")\n",
+    "ax.set_xlim(0.,1.05)\n",
+    "ax.set_ylim(0.,1.05)\n",
+    "#fig.savefig(\"TrainBkgDiag.pdf\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "60a73a78-4f0a-47a7-8495-c3730db680b1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.0, 1.05)"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(1,1)\n",
+    "ax.plot(tpr_ce,1-fpr_ce,label=f'MLP AUC: {auc_ce:.4f}')\n",
+    "\n",
+    "ax.legend()\n",
+    "ax.set_aspect(\"equal\")\n",
+    "ax.set_xlabel(\"Signal efficiency\")\n",
+    "ax.set_ylabel(\"Background rejection\")\n",
+    "ax.set_xlim(0.,1.05)\n",
+    "ax.set_ylim(0.,1.05)\n",
+    "#fig.savefig(\"TrainBkgDiag.pdf\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "cc9e9620-2fee-443f-81f7-5db52211c5d4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"model_1\"\n",
+      "_________________________________________________________________\n",
+      " Layer (type)                Output Shape              Param #   \n",
+      "=================================================================\n",
+      " input_2 (InputLayer)        [(32, 8)]                 0         \n",
+      "                                                                 \n",
+      " dense_4 (Dense)             (32, 16)                  144       \n",
+      "                                                                 \n",
+      " dense_5 (Dense)             (32, 16)                  272       \n",
+      "                                                                 \n",
+      " dense_6 (Dense)             (32, 16)                  272       \n",
+      "                                                                 \n",
+      " dense_7 (Dense)             (32, 1)                   17        \n",
+      "                                                                 \n",
+      "=================================================================\n",
+      "Total params: 705 (2.75 KB)\n",
+      "Trainable params: 705 (2.75 KB)\n",
+      "Non-trainable params: 0 (0.00 Byte)\n",
+      "_________________________________________________________________\n"
+     ]
+    }
+   ],
+   "source": [
+    "model_ce.summary()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "3f425f2e-76a4-48d7-95cd-edd6f2c11b9a",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"model\"\n",
+      "_________________________________________________________________\n",
+      " Layer (type)                Output Shape              Param #   \n",
+      "=================================================================\n",
+      " input_1 (InputLayer)        [(1, 8)]                  0         \n",
+      "                                                                 \n",
+      " dense (Dense)               (1, 16)                   144       \n",
+      "                                                                 \n",
+      " dense_1 (Dense)             (1, 16)                   272       \n",
+      "                                                                 \n",
+      " dense_2 (Dense)             (1, 16)                   272       \n",
+      "                                                                 \n",
+      " dense_3 (Dense)             (1, 1)                    17        \n",
+      "                                                                 \n",
+      "=================================================================\n",
+      "Total params: 705 (2.75 KB)\n",
+      "Trainable params: 705 (2.75 KB)\n",
+      "Non-trainable params: 0 (0.00 Byte)\n",
+      "_________________________________________________________________\n",
+      "WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/namithachithirasree/miniforge3/envs/root_mu2e_env/lib/python3.10/site-packages/keras/src/engine/training.py:3103: UserWarning: You are saving your model as an HDF5 file via `model.save()`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')`.\n",
+      "  saving_api.save_model(\n",
+      "WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"
+     ]
+    }
+   ],
+   "source": [
+    "output_model.set_weights(model_ce.get_weights())\n",
+    "output_model.summary()\n",
+    "#output_model.save(\"model/TrainBkgDiag.h5\")\n",
+    "output_model.save(\"model/TrainBkgDiag.h5\", save_format=\"h5\", include_optimizer=True)\n",
+    "model_ce.save(\"TrainBkgDiag.h5\")\n",
+    "#output_model.save(\"model/TrainBkgDiag.keras\")"
+   ]
+  }
+ ],
+ "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.10.19"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/TrainBkg/model/TrainBkgDiag.dat b/TrainBkg/model/TrainBkgDiag.dat
new file mode 100644
index 0000000..8b9b69e
--- /dev/null
+++ b/TrainBkg/model/TrainBkgDiag.dat
@@ -0,0 +1,16 @@
+tensor_dense3bias0 1
+-1.96825349
+tensor_dense2bias0 16
+1.81444991 -2.43205142 2.93159699 0.400496036 3.55280352 -2.55380392 1.2771194 1.94875526 2.83959794 -0.0223902371 0.8193627 3.58963847 -0.112936802 -0.0161391366 -0.295811236 4.15845823
+tensor_dense1bias0 16
+5.37122297 -0.725740433 -0.427898288 -6.14881706 -0.178254247 3.84829736 3.28701782 -4.3743062 0.356970549 -0.185411453 -0.385833383 -0.185350507 0.552149355 -4.13211536 -2.76091433 4.5546937
+tensor_dense1kernel0 256
+0.0151994331 -0.559730947 -0.902227998 0.239607617 0.113310613 -0.0040753684 -0.661186993 0.131104559 -0.128956035 -0.371055394 -0.377484471 -0.00181585911 -0.56802839 0.377833754 0.235789776 -0.154223531 0.246131212 0.387398213 0.171434492 -0.0814669728 0.282898575 0.299317509 0.00104033947 0.154930264 0.106793612 -0.407717884 0.0844173133 -0.209771186 0.413009793 -0.271367252 0.336103529 0.218085676 -0.167278603 0.210219994 0.0277943891 -0.122301936 -0.370809138 -1.05023742 -0.49164483 -0.211183473 -0.368622482 -0.11574053 -0.400881737 -0.157905802 -0.164439291 -0.143450379 -2.23387647 -0.173186496 -0.117711432 -0.404797852 -0.322535098 0.221683264 0.0485998355 0.0514241159 -0.35666126 -0.102045693 -0.328774124 -0.289175838 -0.337484032 -0.00748520344 -0.0640463158 0.394681424 0.055783622 0.202232063 -0.158077314 -1.42023087 -0.101996981 -0.150481135 -0.234765768 -0.0802826062 -0.294870377 0.184184626 0.0793941766 -0.0632362664 -0.485748112 -0.163729221 0.0715391487 0.0200015567 0.0814818665 0.0256430507 0.0038584529 0.195346862 0.196428344 -0.374293715 -0.348317116 -0.27264598 0.26817733 -0.146935269 -0.408100754 0.284201652 0.110725731 -0.188632995 0.13912186 -0.0813704655 -0.0865850598 0.336041033 0.358495057 -0.176090628 0.0209799707 0.258624375 0.401499718 0.268885642 -0.391147822 -0.349308521 -0.354997098 -0.0556010306 -0.326197207 -0.12658377 0.220354602 0.345855504 0.00633487012 -0.167775989 -0.0368395112 0.040515285 0.0574143194 0.0459896848 -0.122791588 -1.56322336 0.274933338 -0.14658685 -0.697551668 0.0314206518 0.012672985 -0.036488086 -0.00493445154 -0.309809387 0.0282775387 -0.100089423 0.0171369817 -0.737181723 -0.261027247 0.00847681612 -0.544209301 0.132406741 0.0330541953 -0.0862057507 -0.884025931 -0.446310371 -0.125864878 -0.201159939 0.211101457 0.0876285434 0.133656204 0.122085594 0.0254377294 -0.298435003 -0.418414682 0.0781589001 -0.0194527153 0.173261344 -0.20615384 0.183271855 -0.365756094 -0.201818302 -0.398668051 -0.0263647251 0.598242342 -0.0504656658 0.0805128738 0.27773577 -0.107827216 -0.314933002 -0.169593006 -0.128862739 0.109568447 0.160409659 0.0271734595 -0.164506376 -0.248002276 0.105660528 0.128128618 0.420508295 0.292676777 0.387458891 0.00177744031 0.423367947 -0.0817975104 0.0931796134 -0.33946079 0.10898447 -0.561482131 -0.250662178 0.692951262 0.0664248094 0.270903289 -0.307679653 -0.0176539905 -0.018188199 0.087554507 -0.0743870437 -0.429351419 0.195680156 0.271385849 -0.261098564 -0.119853079 -0.16435194 -0.0600992218 0.143457204 0.259915501 0.159216166 -0.137077942 0.07332775 0.306963712 -0.0314518698 0.0311599616 0.156009927 -0.421285659 0.122595519 0.0429571308 -0.647938788 -0.148699686 0.00219781348 -0.611231863 0.225229666 0.124085076 0.252743125 0.12267644 -0.102126062 -0.317296445 -0.109172866 -0.154027581 -0.241009757 -0.243154168 -0.274306118 0.352005333 0.0492113233 -0.1846973 -0.214453712 -0.248520866 0.228581697 0.319411874 0.067783542 0.00379144028 0.242783397 -0.350348681 0.175443605 -0.108651377 0.363339394 0.401327372 -0.119681329 -0.151205242 -0.0957518518 -0.0294597745 0.0105435252 -0.281461298 0.0416213274 0.363249034 -0.208442509 -0.168095648 -0.00408512354 -0.0225839019 0.0663609505 0.0181961656 0.376667827 -0.124703467 0.375448376
+tensor_densebias0 16
+-8.20883369 0 -0.0204744488 -0.0558916256 -3.37021828 -0.0769029707 -0.0673587471 3.18622589 1.35664129 -6.91007328 0 2.18412638 -0.0212656818 -2.00032425 -0.0597755425 0
+tensor_dense3kernel0 16
+0.840395331 0.55547905 -0.42122972 0.239075184 -0.455593556 0.483111233 0.112563826 0.216411114 -0.137490451 0.00439425418 -0.825030684 -0.561267018 -0.0472239368 -0.778770208 -0.0634069592 1.6127305
+tensor_dense2kernel0 256
+0.721922874 0.313979179 0.486713499 0.363075405 0.299933523 -0.461742133 -0.500439823 -0.732593596 0.364008546 -0.74836117 0.805593371 0.0492408685 -0.507366896 -0.282340139 -0.204208687 0.281491101 0.19052282 -0.208950981 0.49232617 0.153240159 -0.0989828631 -0.178796247 -0.0171661414 -0.565656304 -0.284137756 0.0867341608 -0.190257713 0.428598046 0.00506892614 -0.0434137546 -0.466787666 0.201322138 -0.395407975 0.230853558 0.0533354394 -0.360134721 -0.0375892855 -0.316637486 0.0324834771 0.507576466 -0.338083893 0.0901579708 0.170780554 -0.311412781 -0.255897194 -0.288026273 -0.52832514 -0.764252961 -0.163561076 0.527250588 -0.0257069133 -0.440602541 -0.101967908 0.793161333 -1.13820577 0.166451395 -0.189878985 -0.162465438 -0.473664522 0.299535513 -0.204938427 -1.54731083 -0.105317876 -0.295778036 -0.415055394 0.30790776 0.66856277 0.791338503 0.214703143 0.178853273 0.208204284 0.0490156226 -0.239751399 0.410173893 0.868932724 0.0892255306 -0.0523313433 0.20869264 0.286978841 -0.948317051 0.386802673 0.155149356 -2.5432682 -3.01225567 -1.34075999 -0.235642359 0.669074476 0.0923283994 -0.752711117 0.0466861762 -1.34574807 -3.79655576 0.294409633 0.0762320757 -0.119818717 0.09983024 -0.649070501 0.133589521 0.163616151 -0.0919478089 -0.914779365 -0.312404186 0.645495832 0.604173601 0.0562080741 -0.0575164445 -0.50598073 -0.169528797 -0.39762181 0.462017477 -0.010139158 -0.00767322537 -0.390011728 -0.704382241 -0.133734778 0.0194980223 -0.123317666 0.336533815 0.0366089568 0.0845273137 -0.121102139 -0.0967235714 -1.21531391 -0.454380691 -0.0321100727 -0.967044115 -0.0842495412 -0.127226695 0.371003181 -0.382814378 -1.3607223 -0.84427768 -0.0196426976 0.253576159 0.132835776 -0.0272028279 0.573270321 -0.731032073 -1.06966639 -0.426857144 0.334566444 -0.602975667 -0.222694352 -0.0285837818 -0.0574405827 0.116257496 0.389273912 -0.382042378 0.728868127 -0.160183087 -0.47505334 -0.345047414 0.125934944 0.463254303 0.0229522102 0.442475617 -0.0232883226 0.00360025815 -0.431586057 -0.494644552 0.203783467 0.14170292 0.144500121 0.159614772 -0.110676482 0.125142187 -0.451372862 -0.181350365 0.261528343 -0.160370693 0.426852643 0.321592063 -0.248323455 0.0456809103 0.00558496965 0.260216624 -0.407946736 0.151767075 0.133613706 0.0825098306 0.412901372 0.127189025 0.1653997 0.0100775706 0.319970131 0.00872283988 0.0298637003 -0.0231483318 -0.244450197 -0.20001097 0.341956884 -0.0575703979 -0.421066046 -0.0749354884 0.100581363 0.341819018 -0.232927829 -0.337581486 -0.579369605 0.0288225319 -0.30309388 -0.285728335 -0.450434178 -0.426482886 0.1115954 -1.73347938 -0.234253645 0.044851467 -0.267025411 -1.78389263 -0.266282856 0.402034283 0.072806038 -0.0217206813 -0.482096016 -0.565065324 0.218249068 -0.383761197 -1.26122475 -1.49262929 -0.484524846 -0.97238636 -0.114315957 -0.0506812744 -0.235502243 0.164450392 0.0232807659 -0.242847472 -0.165894777 0.108287714 0.110485941 -0.982693315 0.0339857303 -0.515599549 -0.0329903178 0.0544714928 -0.433743477 -1.01729691 -0.10311538 -0.210394725 -0.0790625438 0.184273288 -0.0128326053 0.535682976 0.0174460765 0.24734138 0.26360932 0.462990671 -0.0936573446 -0.0391456261 0.29846409 0.462254345 -0.141640246 0.543951631 -0.707391918 0.0370970368
+tensor_densekernel0 128
+0.124605723 -0.272176027 -0.383912683 -0.0493397489 -0.0150224548 -0.135312662 -0.404249609 0.166087627 -0.0426664688 0.0285350345 -0.0846010447 0.0423698947 -0.395707786 0.0622826852 -0.346556187 -0.210098386 0.112589076 -0.280231237 0.535327137 -0.0613143221 0.188191608 0.0154601857 0.0372289419 -0.637577057 -0.114309363 0.0225985218 -0.0424835682 -0.0336718 -0.479676753 0.258869827 -0.0472621806 -0.325410724 -6.37785482 -0.0866527557 0.219122127 0.118748508 0.522052467 0.0327157564 -0.32113716 -5.61345863 6.35103893 6.38462305 0.171573043 8.39260674 -0.672375441 8.20938015 0.314235657 -0.198039412 -1.31050241 -0.0795766115 0.445620537 -0.544486225 -0.743881822 -0.236851856 -0.24517785 -0.925560594 -0.700701773 0.309314579 -0.0296000242 3.19003749 -0.621578217 -0.184953183 -0.0169388577 0.196539044 0.0310530905 -0.00871610641 -0.737494767 -0.196681306 0.0958322808 0.0289968532 -0.196958482 0.0701459795 -0.0757764727 -0.802472532 -0.0675243139 -0.539389193 0.178022429 -0.559709311 0.176521689 -0.484115601 -0.657947302 -0.324678659 1.35378444 0.144852519 0.761297822 0.126961127 -0.0837774053 0.460731596 0.36368984 0.919221818 0.370157361 -1.01624084 0.542819023 -2.1053102 -0.344718903 -0.173633814 -6.0880003 -0.324965477 -1.75330377 -0.199719369 -5.15357351 0.0554588437 0.418092877 -0.330969393 5.50049973 0.0909663811 -0.255887985 19.5407925 -0.188445255 7.39218283 -0.408957958 0.315758109 0.154790103 0.228476405 -2.10731626 0.233771518 -3.76407409 0.0572671741 -0.513613403 -0.147251412 -0.335549593 -0.928369522 -0.326810479 0.284668386 0.302921176 1.25659668 -0.143617854 -0.372923136
diff --git a/TrainBkg/model/TrainBkgDiag.h5 b/TrainBkg/model/TrainBkgDiag.h5
new file mode 100644
index 0000000..988bb99
Binary files /dev/null and b/TrainBkg/model/TrainBkgDiag.h5 differ
diff --git a/TrainBkg/model/TrainBkgDiag.hxx b/TrainBkg/model/TrainBkgDiag.hxx
new file mode 100644
index 0000000..be82607
--- /dev/null
+++ b/TrainBkg/model/TrainBkgDiag.hxx
@@ -0,0 +1,260 @@
+//Code generated automatically by TMVA for Inference of Model file [TrainBkgDiag.h5] at [Thu Mar 12 21:55:13 2026] 
+
+#ifndef ROOT_TMVA_SOFIE_TRAINBKGDIAG
+#define ROOT_TMVA_SOFIE_TRAINBKGDIAG
+
+#include <algorithm>
+#include <cmath>
+#include <vector>
+#include "TMVA/SOFIE_common.hxx"
+#include <fstream>
+
+namespace TMVA_SOFIE_TrainBkgDiag{
+namespace BLAS{
+	extern "C" void sgemv_(const char * trans, const int * m, const int * n, const float * alpha, const float * A,
+	                       const int * lda, const float * X, const int * incx, const float * beta, const float * Y, const int * incy);
+	extern "C" void sgemm_(const char * transa, const char * transb, const int * m, const int * n, const int * k,
+	                       const float * alpha, const float * A, const int * lda, const float * B, const int * ldb,
+	                       const float * beta, float * C, const int * ldc);
+}//BLAS
+struct Session {
+std::vector<float> fTensor_dense3bias0 = std::vector<float>(1);
+float * tensor_dense3bias0 = fTensor_dense3bias0.data();
+std::vector<float> fTensor_dense2bias0 = std::vector<float>(16);
+float * tensor_dense2bias0 = fTensor_dense2bias0.data();
+std::vector<float> fTensor_dense1bias0 = std::vector<float>(16);
+float * tensor_dense1bias0 = fTensor_dense1bias0.data();
+std::vector<float> fTensor_dense1kernel0 = std::vector<float>(256);
+float * tensor_dense1kernel0 = fTensor_dense1kernel0.data();
+std::vector<float> fTensor_densebias0 = std::vector<float>(16);
+float * tensor_densebias0 = fTensor_densebias0.data();
+std::vector<float> fTensor_dense3kernel0 = std::vector<float>(16);
+float * tensor_dense3kernel0 = fTensor_dense3kernel0.data();
+std::vector<float> fTensor_dense2kernel0 = std::vector<float>(256);
+float * tensor_dense2kernel0 = fTensor_dense2kernel0.data();
+std::vector<float> fTensor_densekernel0 = std::vector<float>(128);
+float * tensor_densekernel0 = fTensor_densekernel0.data();
+std::vector<float> fTensor_dense3Sigmoid0 = std::vector<float>(1);
+float * tensor_dense3Sigmoid0 = fTensor_dense3Sigmoid0.data();
+std::vector<float> fTensor_dense3Dense = std::vector<float>(1);
+float * tensor_dense3Dense = fTensor_dense3Dense.data();
+std::vector<float> fTensor_denseDense = std::vector<float>(16);
+float * tensor_denseDense = fTensor_denseDense.data();
+std::vector<float> fTensor_dense3bias0bcast = std::vector<float>(1);
+float * tensor_dense3bias0bcast = fTensor_dense3bias0bcast.data();
+std::vector<float> fTensor_dense2Dense = std::vector<float>(16);
+float * tensor_dense2Dense = fTensor_dense2Dense.data();
+std::vector<float> fTensor_dense1Dense = std::vector<float>(16);
+float * tensor_dense1Dense = fTensor_dense1Dense.data();
+std::vector<float> fTensor_denseRelu0 = std::vector<float>(16);
+float * tensor_denseRelu0 = fTensor_denseRelu0.data();
+std::vector<float> fTensor_dense1bias0bcast = std::vector<float>(16);
+float * tensor_dense1bias0bcast = fTensor_dense1bias0bcast.data();
+std::vector<float> fTensor_densebias0bcast = std::vector<float>(16);
+float * tensor_densebias0bcast = fTensor_densebias0bcast.data();
+std::vector<float> fTensor_dense2bias0bcast = std::vector<float>(16);
+float * tensor_dense2bias0bcast = fTensor_dense2bias0bcast.data();
+std::vector<float> fTensor_dense2Relu0 = std::vector<float>(16);
+float * tensor_dense2Relu0 = fTensor_dense2Relu0.data();
+std::vector<float> fTensor_dense1Relu0 = std::vector<float>(16);
+float * tensor_dense1Relu0 = fTensor_dense1Relu0.data();
+
+
+Session(std::string filename ="") {
+   if (filename.empty()) filename = "TrainBkgDiag.dat";
+   std::ifstream f;
+   f.open(filename);
+   if (!f.is_open()) {
+      throw std::runtime_error("tmva-sofie failed to open file for input weights");
+   }
+   std::string tensor_name;
+   size_t length;
+   f >> tensor_name >> length;
+   if (tensor_name != "tensor_dense3bias0" ) {
+      std::string err_msg = "TMVA-SOFIE failed to read the correct tensor name; expected name is tensor_dense3bias0 , read " + tensor_name;
+      throw std::runtime_error(err_msg);
+    }
+   if (length != 1) {
+      std::string err_msg = "TMVA-SOFIE failed to read the correct tensor size; expected size is 1 , read " + std::to_string(length) ;
+      throw std::runtime_error(err_msg);
+    }
+   for (size_t i = 0; i < length; ++i)
+      f >> tensor_dense3bias0[i];
+   f >> tensor_name >> length;
+   if (tensor_name != "tensor_dense2bias0" ) {
+      std::string err_msg = "TMVA-SOFIE failed to read the correct tensor name; expected name is tensor_dense2bias0 , read " + tensor_name;
+      throw std::runtime_error(err_msg);
+    }
+   if (length != 16) {
+      std::string err_msg = "TMVA-SOFIE failed to read the correct tensor size; expected size is 16 , read " + std::to_string(length) ;
+      throw std::runtime_error(err_msg);
+    }
+   for (size_t i = 0; i < length; ++i)
+      f >> tensor_dense2bias0[i];
+   f >> tensor_name >> length;
+   if (tensor_name != "tensor_dense1bias0" ) {
+      std::string err_msg = "TMVA-SOFIE failed to read the correct tensor name; expected name is tensor_dense1bias0 , read " + tensor_name;
+      throw std::runtime_error(err_msg);
+    }
+   if (length != 16) {
+      std::string err_msg = "TMVA-SOFIE failed to read the correct tensor size; expected size is 16 , read " + std::to_string(length) ;
+      throw std::runtime_error(err_msg);
+    }
+   for (size_t i = 0; i < length; ++i)
+      f >> tensor_dense1bias0[i];
+   f >> tensor_name >> length;
+   if (tensor_name != "tensor_dense1kernel0" ) {
+      std::string err_msg = "TMVA-SOFIE failed to read the correct tensor name; expected name is tensor_dense1kernel0 , read " + tensor_name;
+      throw std::runtime_error(err_msg);
+    }
+   if (length != 256) {
+      std::string err_msg = "TMVA-SOFIE failed to read the correct tensor size; expected size is 256 , read " + std::to_string(length) ;
+      throw std::runtime_error(err_msg);
+    }
+   for (size_t i = 0; i < length; ++i)
+      f >> tensor_dense1kernel0[i];
+   f >> tensor_name >> length;
+   if (tensor_name != "tensor_densebias0" ) {
+      std::string err_msg = "TMVA-SOFIE failed to read the correct tensor name; expected name is tensor_densebias0 , read " + tensor_name;
+      throw std::runtime_error(err_msg);
+    }
+   if (length != 16) {
+      std::string err_msg = "TMVA-SOFIE failed to read the correct tensor size; expected size is 16 , read " + std::to_string(length) ;
+      throw std::runtime_error(err_msg);
+    }
+   for (size_t i = 0; i < length; ++i)
+      f >> tensor_densebias0[i];
+   f >> tensor_name >> length;
+   if (tensor_name != "tensor_dense3kernel0" ) {
+      std::string err_msg = "TMVA-SOFIE failed to read the correct tensor name; expected name is tensor_dense3kernel0 , read " + tensor_name;
+      throw std::runtime_error(err_msg);
+    }
+   if (length != 16) {
+      std::string err_msg = "TMVA-SOFIE failed to read the correct tensor size; expected size is 16 , read " + std::to_string(length) ;
+      throw std::runtime_error(err_msg);
+    }
+   for (size_t i = 0; i < length; ++i)
+      f >> tensor_dense3kernel0[i];
+   f >> tensor_name >> length;
+   if (tensor_name != "tensor_dense2kernel0" ) {
+      std::string err_msg = "TMVA-SOFIE failed to read the correct tensor name; expected name is tensor_dense2kernel0 , read " + tensor_name;
+      throw std::runtime_error(err_msg);
+    }
+   if (length != 256) {
+      std::string err_msg = "TMVA-SOFIE failed to read the correct tensor size; expected size is 256 , read " + std::to_string(length) ;
+      throw std::runtime_error(err_msg);
+    }
+   for (size_t i = 0; i < length; ++i)
+      f >> tensor_dense2kernel0[i];
+   f >> tensor_name >> length;
+   if (tensor_name != "tensor_densekernel0" ) {
+      std::string err_msg = "TMVA-SOFIE failed to read the correct tensor name; expected name is tensor_densekernel0 , read " + tensor_name;
+      throw std::runtime_error(err_msg);
+    }
+   if (length != 128) {
+      std::string err_msg = "TMVA-SOFIE failed to read the correct tensor size; expected size is 128 , read " + std::to_string(length) ;
+      throw std::runtime_error(err_msg);
+    }
+   for (size_t i = 0; i < length; ++i)
+      f >> tensor_densekernel0[i];
+   f.close();
+   {
+      float * data = TMVA::Experimental::SOFIE::UTILITY::UnidirectionalBroadcast<float>(tensor_densebias0,{ 16 }, { 1 , 16 });
+      std::copy(data, data + 16, tensor_densebias0bcast);
+      delete [] data;
+   }
+   {
+      float * data = TMVA::Experimental::SOFIE::UTILITY::UnidirectionalBroadcast<float>(tensor_dense1bias0,{ 16 }, { 1 , 16 });
+      std::copy(data, data + 16, tensor_dense1bias0bcast);
+      delete [] data;
+   }
+   {
+      float * data = TMVA::Experimental::SOFIE::UTILITY::UnidirectionalBroadcast<float>(tensor_dense2bias0,{ 16 }, { 1 , 16 });
+      std::copy(data, data + 16, tensor_dense2bias0bcast);
+      delete [] data;
+   }
+   {
+      float * data = TMVA::Experimental::SOFIE::UTILITY::UnidirectionalBroadcast<float>(tensor_dense3bias0,{ 1 }, { 1 , 1 });
+      std::copy(data, data + 1, tensor_dense3bias0bcast);
+      delete [] data;
+   }
+}
+
+std::vector<float> infer(float* tensor_input1){
+
+//--------- Gemm
+   char op_0_transA = 'n';
+   char op_0_transB = 'n';
+   int op_0_m = 1;
+   int op_0_n = 16;
+   int op_0_k = 8;
+   float op_0_alpha = 1;
+   float op_0_beta = 1;
+   int op_0_lda = 8;
+   int op_0_ldb = 16;
+   std::copy(tensor_densebias0bcast, tensor_densebias0bcast + 16, tensor_denseDense);
+   BLAS::sgemm_(&op_0_transB, &op_0_transA, &op_0_n, &op_0_m, &op_0_k, &op_0_alpha, tensor_densekernel0, &op_0_ldb, tensor_input1, &op_0_lda, &op_0_beta, tensor_denseDense, &op_0_n);
+
+//------ RELU
+   for (int id = 0; id < 16 ; id++){
+      tensor_denseRelu0[id] = ((tensor_denseDense[id] > 0 )? tensor_denseDense[id] : 0);
+   }
+
+//--------- Gemm
+   char op_2_transA = 'n';
+   char op_2_transB = 'n';
+   int op_2_m = 1;
+   int op_2_n = 16;
+   int op_2_k = 16;
+   float op_2_alpha = 1;
+   float op_2_beta = 1;
+   int op_2_lda = 16;
+   int op_2_ldb = 16;
+   std::copy(tensor_dense1bias0bcast, tensor_dense1bias0bcast + 16, tensor_dense1Dense);
+   BLAS::sgemm_(&op_2_transB, &op_2_transA, &op_2_n, &op_2_m, &op_2_k, &op_2_alpha, tensor_dense1kernel0, &op_2_ldb, tensor_denseRelu0, &op_2_lda, &op_2_beta, tensor_dense1Dense, &op_2_n);
+
+//------ RELU
+   for (int id = 0; id < 16 ; id++){
+      tensor_dense1Relu0[id] = ((tensor_dense1Dense[id] > 0 )? tensor_dense1Dense[id] : 0);
+   }
+
+//--------- Gemm
+   char op_4_transA = 'n';
+   char op_4_transB = 'n';
+   int op_4_m = 1;
+   int op_4_n = 16;
+   int op_4_k = 16;
+   float op_4_alpha = 1;
+   float op_4_beta = 1;
+   int op_4_lda = 16;
+   int op_4_ldb = 16;
+   std::copy(tensor_dense2bias0bcast, tensor_dense2bias0bcast + 16, tensor_dense2Dense);
+   BLAS::sgemm_(&op_4_transB, &op_4_transA, &op_4_n, &op_4_m, &op_4_k, &op_4_alpha, tensor_dense2kernel0, &op_4_ldb, tensor_dense1Relu0, &op_4_lda, &op_4_beta, tensor_dense2Dense, &op_4_n);
+
+//------ RELU
+   for (int id = 0; id < 16 ; id++){
+      tensor_dense2Relu0[id] = ((tensor_dense2Dense[id] > 0 )? tensor_dense2Dense[id] : 0);
+   }
+
+//--------- Gemm
+   char op_6_transA = 'n';
+   char op_6_transB = 'n';
+   int op_6_m = 1;
+   int op_6_n = 1;
+   int op_6_k = 16;
+   float op_6_alpha = 1;
+   float op_6_beta = 1;
+   int op_6_lda = 16;
+   int op_6_ldb = 1;
+   std::copy(tensor_dense3bias0bcast, tensor_dense3bias0bcast + 1, tensor_dense3Dense);
+   BLAS::sgemm_(&op_6_transB, &op_6_transA, &op_6_n, &op_6_m, &op_6_k, &op_6_alpha, tensor_dense3kernel0, &op_6_ldb, tensor_dense2Relu0, &op_6_lda, &op_6_beta, tensor_dense3Dense, &op_6_n);
+	for (int id = 0; id < 1 ; id++){
+		tensor_dense3Sigmoid0[id] = 1 / (1 + std::exp( - tensor_dense3Dense[id]));
+	}
+   std::vector<float> ret (tensor_dense3Sigmoid0, tensor_dense3Sigmoid0 + 1);
+   return ret;
+}
+};
+} //TMVA_SOFIE_TrainBkgDiag
+
+#endif  // ROOT_TMVA_SOFIE_TRAINBKGDIAG