diff --git a/How-to-rediscover-the-Higgs.ipynb b/How-to-rediscover-the-Higgs.ipynb
index 26b88b0..9cbb435 100644
--- a/How-to-rediscover-the-Higgs.ipynb
+++ b/How-to-rediscover-the-Higgs.ipynb
@@ -5,130 +5,169 @@
    "metadata": {},
    "source": [
     "# How to rediscover the Higgs boson yourself!\n",
-    "This notebook uses ATLAS Open Data http://opendata.atlas.cern to show you the steps to rediscover the Higgs boson yourself!\n",
     "\n",
-    "The idea is that you add extra cuts to increase the ratio of signal ($H \\rightarrow ZZ \\rightarrow \\ell\\ell\\ell\\ell$) to background ($Z, t\\bar{t}, ZZ \\rightarrow \\ell\\ell\\ell\\ell$)\n",
-    "\n",
-    "First, try to reduce the amount of $Z$ and $t\\bar{t}$ background, since these are quite different to the signal.\n",
-    "\n",
-    "Then, try to reduce the amount of $ZZ \\rightarrow \\ell\\ell\\ell\\ell$, whilst keeping $H \\rightarrow ZZ \\rightarrow \\ell\\ell\\ell\\ell$ signal\n",
-    "\n",
-    "The datasets used in this notebook have already been filtered to include at least 4 leptons per event, so that processing is quicker."
+    "Competition entry by Chetan Gohil"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "<CENTER><img src=\"HZZ_feynman.pdf\" style=\"width:40%\"></CENTER>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## First time setup\n",
-    "This first cell only needs to be run the first time you open this notebook on your computer. \n",
-    "\n",
-    "If you close jupyter and re-open on the same computer, you won't need to run this first cell again.\n",
-    "\n",
-    "If you re-open on binder, you will need to run this cell again.\n",
-    "\n",
-    "If you run into a problem of \"uproot not being available\", Kernel -> Restart & Run All"
+    "# Install modules"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Requirement already up-to-date: pip in /Users/gohil/.local/lib/python3.7/site-packages (19.2.1)\n",
+      "Requirement already up-to-date: numpy in /Users/gohil/.local/lib/python3.7/site-packages (1.16.4)\n",
+      "Requirement already up-to-date: pandas in /Users/gohil/.local/lib/python3.7/site-packages (0.25.0)\n",
+      "Requirement already up-to-date: uproot in /Users/gohil/.local/lib/python3.7/site-packages (3.8.0)\n",
+      "Requirement already up-to-date: matplotlib in /Users/gohil/.local/lib/python3.7/site-packages (3.1.1)\n",
+      "Requirement already up-to-date: keras in /Users/gohil/.local/lib/python3.7/site-packages (2.2.4)\n",
+      "Requirement already up-to-date: scikit-learn in /Users/gohil/.local/lib/python3.7/site-packages (0.21.2)\n",
+      "Requirement already up-to-date: tensorflow in /Users/gohil/.local/lib/python3.7/site-packages (1.14.0)\n",
+      "Requirement already satisfied, skipping upgrade: python-dateutil>=2.6.1 in /Users/gohil/anaconda3/lib/python3.7/site-packages (from pandas) (2.8.0)\n",
+      "Requirement already satisfied, skipping upgrade: pytz>=2017.2 in /Users/gohil/anaconda3/lib/python3.7/site-packages (from pandas) (2018.9)\n",
+      "Requirement already satisfied, skipping upgrade: cachetools in /Users/gohil/.local/lib/python3.7/site-packages (from uproot) (3.1.1)\n",
+      "Requirement already satisfied, skipping upgrade: awkward>=0.12.0 in /Users/gohil/.local/lib/python3.7/site-packages (from uproot) (0.12.3)\n",
+      "Requirement already satisfied, skipping upgrade: uproot-methods>=0.7.0 in /Users/gohil/.local/lib/python3.7/site-packages (from uproot) (0.7.0)\n",
+      "Requirement already satisfied, skipping upgrade: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /Users/gohil/anaconda3/lib/python3.7/site-packages (from matplotlib) (2.3.1)\n",
+      "Requirement already satisfied, skipping upgrade: kiwisolver>=1.0.1 in /Users/gohil/anaconda3/lib/python3.7/site-packages (from matplotlib) (1.0.1)\n",
+      "Requirement already satisfied, skipping upgrade: cycler>=0.10 in /Users/gohil/anaconda3/lib/python3.7/site-packages (from matplotlib) (0.10.0)\n",
+      "Requirement already satisfied, skipping upgrade: keras-applications>=1.0.6 in /Users/gohil/.local/lib/python3.7/site-packages (from keras) (1.0.8)\n",
+      "Requirement already satisfied, skipping upgrade: scipy>=0.14 in /Users/gohil/anaconda3/lib/python3.7/site-packages (from keras) (1.2.1)\n",
+      "Requirement already satisfied, skipping upgrade: keras-preprocessing>=1.0.5 in /Users/gohil/.local/lib/python3.7/site-packages (from keras) (1.1.0)\n",
+      "Requirement already satisfied, skipping upgrade: h5py in /Users/gohil/anaconda3/lib/python3.7/site-packages (from keras) (2.9.0)\n",
+      "Requirement already satisfied, skipping upgrade: pyyaml in /Users/gohil/anaconda3/lib/python3.7/site-packages (from keras) (5.1)\n",
+      "Requirement already satisfied, skipping upgrade: six>=1.9.0 in /Users/gohil/anaconda3/lib/python3.7/site-packages (from keras) (1.12.0)\n",
+      "Requirement already satisfied, skipping upgrade: joblib>=0.11 in /Users/gohil/.local/lib/python3.7/site-packages (from scikit-learn) (0.13.2)\n",
+      "Requirement already satisfied, skipping upgrade: gast>=0.2.0 in /Users/gohil/.local/lib/python3.7/site-packages (from tensorflow) (0.2.2)\n",
+      "Requirement already satisfied, skipping upgrade: wheel>=0.26 in /Users/gohil/anaconda3/lib/python3.7/site-packages (from tensorflow) (0.33.1)\n",
+      "Requirement already satisfied, skipping upgrade: protobuf>=3.6.1 in /Users/gohil/.local/lib/python3.7/site-packages (from tensorflow) (3.9.0)\n",
+      "Requirement already satisfied, skipping upgrade: wrapt>=1.11.1 in /Users/gohil/anaconda3/lib/python3.7/site-packages (from tensorflow) (1.11.1)\n",
+      "Requirement already satisfied, skipping upgrade: astor>=0.6.0 in /Users/gohil/.local/lib/python3.7/site-packages (from tensorflow) (0.8.0)\n",
+      "Requirement already satisfied, skipping upgrade: grpcio>=1.8.6 in /Users/gohil/.local/lib/python3.7/site-packages (from tensorflow) (1.22.0)\n",
+      "Requirement already satisfied, skipping upgrade: tensorflow-estimator<1.15.0rc0,>=1.14.0rc0 in /Users/gohil/.local/lib/python3.7/site-packages (from tensorflow) (1.14.0)\n",
+      "Requirement already satisfied, skipping upgrade: google-pasta>=0.1.6 in /Users/gohil/.local/lib/python3.7/site-packages (from tensorflow) (0.1.7)\n",
+      "Requirement already satisfied, skipping upgrade: termcolor>=1.1.0 in /Users/gohil/.local/lib/python3.7/site-packages (from tensorflow) (1.1.0)\n",
+      "Requirement already satisfied, skipping upgrade: tensorboard<1.15.0,>=1.14.0 in /Users/gohil/.local/lib/python3.7/site-packages (from tensorflow) (1.14.0)\n",
+      "Requirement already satisfied, skipping upgrade: absl-py>=0.7.0 in /Users/gohil/.local/lib/python3.7/site-packages (from tensorflow) (0.7.1)\n",
+      "Requirement already satisfied, skipping upgrade: setuptools in /Users/gohil/anaconda3/lib/python3.7/site-packages (from kiwisolver>=1.0.1->matplotlib) (40.8.0)\n",
+      "Requirement already satisfied, skipping upgrade: werkzeug>=0.11.15 in /Users/gohil/anaconda3/lib/python3.7/site-packages (from tensorboard<1.15.0,>=1.14.0->tensorflow) (0.14.1)\n",
+      "Requirement already satisfied, skipping upgrade: markdown>=2.6.8 in /Users/gohil/.local/lib/python3.7/site-packages (from tensorboard<1.15.0,>=1.14.0->tensorflow) (3.1.1)\n"
+     ]
+    }
+   ],
    "source": [
     "import sys\n",
     "!{sys.executable} -m pip install --upgrade --user pip\n",
-    "!{sys.executable} -m pip install -U numpy pandas uproot matplotlib keras scikit-learn --user"
+    "!{sys.executable} -m pip install -U numpy pandas uproot matplotlib keras scikit-learn tensorflow --user"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## To setup everytime\n",
-    "Cell -> Run All Below\n",
-    "\n",
-    "to be done every time you re-open this notebook"
+    "# Setup necessary modules"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
-    "import uproot\n",
+    "import numpy as np\n",
     "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import uproot\n",
     "import time\n",
     "import math\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
     "import glob\n",
-    "import random\n",
+    "import infofile\n",
+    "\n",
+    "import sklearn.ensemble as ske\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "from sklearn.metrics import roc_curve, auc\n",
     "\n",
-    "import infofile"
+    "from tensorflow.keras import layers\n",
+    "from tensorflow.keras.models import Sequential\n",
+    "from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "lumi = 1000\n",
-    "                                                                                                                                  \n",
-    "tuple_path = \"Input/\"\n",
-    "\n",
-    "stack_order = ['data',r'$Z,t\\bar{t}$','ZZ',r'$H \\rightarrow ZZ \\rightarrow \\ell\\ell\\ell\\ell$']"
+    "# Global Variables"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
+    "lumi = 1000\n",
+    "tuple_path = \"Input/\"\n",
+    "stack_order = ['data',r'$Z,t\\bar{t}$','ZZ',r'$H \\rightarrow ZZ \\rightarrow \\ell\\ell\\ell\\ell$']\n",
     "samples = {\n",
-    "\n",
     "    'data': {\n",
     "        'list' : ['DataEgamma','DataMuons']\n",
     "    },\n",
-    "\n",
     "    r'$Z,t\\bar{t}$' : {\n",
     "        'list' : ['Zee','Zmumu','ttbar_lep'],\n",
     "        'color' : \"#8700da\"\n",
     "    },\n",
-    "\n",
     "    'ZZ' : {\n",
     "        'list' : ['ZZ'],\n",
     "        'color' : \"#f90000\"\n",
     "    },\n",
-    "\n",
     "    r'$H \\rightarrow ZZ \\rightarrow \\ell\\ell\\ell\\ell$' : {\n",
     "        'list' : ['ggH125_ZZ4lep','VBFH125_ZZ4lep'],\n",
     "        'color' : \"#4faeff\"\n",
     "    }\n",
-    "\n",
     "}"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Functions to read in data"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
-    "def get_data_from_files():\n",
+    "def mllll_window(mllll):\n",
+    "    return 120 < mllll < 130\n",
     "\n",
-    "    data = {}\n",
+    "def calc_weight(mcWeight,scaleFactor_PILEUP,scaleFactor_ELE,\n",
+    "                scaleFactor_MUON, scaleFactor_TRIGGER):\n",
+    "    return mcWeight*scaleFactor_PILEUP*scaleFactor_ELE*scaleFactor_MUON*\\\n",
+    "           scaleFactor_TRIGGER\n",
+    "\n",
+    "def get_xsec_weight(totalWeight,sample):\n",
+    "    info = infofile.infos[sample]\n",
+    "    weight = (lumi*info[\"xsec\"])/(info[\"sumw\"]*info[\"red_eff\"])\n",
+    "    weight *= totalWeight\n",
+    "    return weight\n",
     "\n",
+    "def get_data_from_files():\n",
+    "    data = {}\n",
     "    for s in samples:\n",
     "        print(s+':')\n",
     "        frames = []\n",
@@ -146,178 +185,181 @@
     "            else:\n",
     "                print(\"Error: \"+val+\" not found!\")\n",
     "        data[s] = pd.concat(frames)\n",
+    "    return data\n",
+    "\n",
+    "def read_file(path, sample):\n",
+    "    start = time.time()\n",
+    "    print(\"\\tProcessing: \"+sample)\n",
+    "    mc = uproot.open(path)[\"mini\"]\n",
+    "    data = mc.pandas.df([\"lep_n\",\"lep_pt\",\"lep_eta\",\"lep_phi\",\"lep_charge\",\"lep_type\",\n",
+    "               \"lep_etcone20\",\"lep_trackd0pvunbiased\",\"lep_tracksigd0pvunbiased\",\n",
+    "               \"mcWeight\",\"scaleFactor_PILEUP\",\"scaleFactor_ELE\",\"scaleFactor_MUON\",\n",
+    "               \"scaleFactor_TRIGGER\"], flatten=False)\n",
+    "\n",
+    "    nIn = len(data.index)\n",
+    "\n",
+    "    if 'Data' not in sample:\n",
+    "        data['totalWeight'] = np.vectorize(calc_weight)(data.mcWeight,\n",
+    "                                  data.scaleFactor_PILEUP,data.scaleFactor_ELE,\n",
+    "                                  data.scaleFactor_MUON,data.scaleFactor_TRIGGER)\n",
+    "        data['totalWeight'] = np.vectorize(get_xsec_weight)(data.totalWeight,sample)\n",
+    "\n",
+    "    data.drop([\"mcWeight\",\"scaleFactor_PILEUP\",\"scaleFactor_ELE\",\"scaleFactor_MUON\",\n",
+    "               \"scaleFactor_TRIGGER\"], axis=1, inplace=True)\n",
+    "\n",
+    "    # calculation of 4-lepton invariant mass\n",
+    "    data['mllll'] = np.vectorize(calc_mllll)(data.lep_pt,data.lep_eta,data.lep_phi)\n",
+    "\n",
+    "    #\n",
+    "    # Apply cuts\n",
+    "    #\n",
+    "    data = apply_cuts(data)\n",
+    "\n",
+    "    # return events with 120 < mllll < 130 GeV\n",
+    "    nOut = len(data.index)\n",
+    "\n",
+    "    elapsed = time.time() - start\n",
+    "    print(\"\\t\\tTime taken: \"+str(elapsed)+\", nIn: \"+str(nIn)+\", nOut: \"+str(nOut))\n",
+    "    \n",
+    "    return data\n",
+    "\n",
+    "def read_file_bdt(path,sample):\n",
+    "    start = time.time()\n",
+    "    print(\"\\tProcessing: \"+sample)\n",
+    "    mc = uproot.open(path)[\"mini\"]\n",
+    "    data = mc.pandas.df([\"lep_n\",\"lep_pt\",\"lep_eta\",\"lep_phi\",\"lep_charge\",\n",
+    "                         \"lep_type\",\"lep_etcone20\",\"lep_trackd0pvunbiased\",\n",
+    "                         \"lep_tracksigd0pvunbiased\",\"mcWeight\",\"scaleFactor_PILEUP\",                             \"scaleFactor_ELE\",\"scaleFactor_MUON\",\n",
+    "                         \"scaleFactor_TRIGGER\"], flatten=False)\n",
+    "\n",
+    "    nIn = len(data.index)\n",
+    "\n",
+    "    if 'Data' not in sample:\n",
+    "        data['totalWeight'] = np.vectorize(calc_weight)(data.mcWeight,\n",
+    "                              data.scaleFactor_PILEUP,data.scaleFactor_ELE,\n",
+    "                              data.scaleFactor_MUON,data.scaleFactor_TRIGGER)\n",
+    "        data['totalWeight'] = np.vectorize(get_xsec_weight)(data.totalWeight,sample)\n",
     "\n",
+    "    data.drop([\"mcWeight\",\"scaleFactor_PILEUP\",\"scaleFactor_ELE\",\"scaleFactor_MUON\",\n",
+    "               \"scaleFactor_TRIGGER\"], axis=1, inplace=True)\n",
+    "\n",
+    "    # cut on number of leptons\n",
+    "    fail = data[ np.vectorize(cut_n_lep)(data.lep_n)].index\n",
+    "    data.drop(fail, inplace=True)\n",
+    "\n",
+    "    # calculation of 4-lepton invariant mass\n",
+    "    data['mllll'] = np.vectorize(calc_mllll)(data.lep_pt,data.lep_eta,data.lep_phi)\n",
+    "\n",
+    "    data.drop([\"lep_n\",\"lep_pt\",\"lep_eta\",\"lep_phi\",\"lep_charge\",\"lep_type\",\n",
+    "               \"lep_etcone20\",\"lep_trackd0pvunbiased\",\"lep_tracksigd0pvunbiased\"],\n",
+    "               axis=1, inplace=True)  \n",
+    "\n",
+    "    nOut = len(data.index)\n",
+    "\n",
+    "    elapsed = time.time() - start\n",
+    "    print(\"\\t\\tTime taken: \"+str(elapsed)+\", nIn: \"+str(nIn)+\", nOut: \"+str(nOut))\n",
+    "    \n",
+    "    return data\n",
+    "\n",
+    "def remove_variable_length_columns(data):\n",
+    "    '''formats the data so it can be used in machine learning algorithms'''\n",
+    "    if max(data.lep_n) < 5: \n",
+    "        df_split = pd.DataFrame(data['lep_pt'].values.tolist(), \n",
+    "                   columns=['lep1_pt','lep2_pt','lep3_pt','lep4_pt'], index=data.index)\n",
+    "        df_split['lep5_pt'] = 0\n",
+    "        df_split['lep6_pt'] = 0\n",
+    "    elif max(data.lep_n) < 6: \n",
+    "        df_split = pd.DataFrame(data['lep_pt'].values.tolist(),\n",
+    "                   columns=['lep1_pt','lep2_pt','lep3_pt','lep4_pt','lep5_pt'],\n",
+    "                   index=data.index)\n",
+    "        df_split['lep6_pt'] = 0\n",
+    "    else: df_split = pd.DataFrame(data['lep_pt'].values.tolist(),\n",
+    "                     columns=['lep1_pt','lep2_pt','lep3_pt','lep4_pt','lep5_pt',\n",
+    "                              'lep6_pt'], index=data.index)\n",
+    "    df_split.fillna(0, inplace=True)\n",
+    "    data = pd.concat([data, df_split], axis=1)\n",
+    "    \n",
+    "    # drop the variables that are of variable length\n",
+    "    data.drop([\"lep_pt\",\"lep_eta\",\"lep_phi\",\"lep_charge\",\"lep_type\",\"lep_etcone20\",\n",
+    "               \"lep_trackd0pvunbiased\",\"lep_tracksigd0pvunbiased\"], axis=1,\n",
+    "                inplace=True)  \n",
+    "    \n",
     "    return data"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def mllll_window(mllll):\n",
-    "    return 120 < mllll < 130"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def calc_weight(mcWeight,scaleFactor_PILEUP,scaleFactor_ELE,\n",
-    "                scaleFactor_MUON, scaleFactor_TRIGGER):\n",
-    "    return mcWeight*scaleFactor_PILEUP*scaleFactor_ELE*scaleFactor_MUON*scaleFactor_TRIGGER"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def get_xsec_weight(totalWeight,sample):\n",
-    "    info = infofile.infos[sample]\n",
-    "    weight = (lumi*info[\"xsec\"])/(info[\"sumw\"]*info[\"red_eff\"])\n",
-    "    weight *= totalWeight\n",
-    "    return weight"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "def correlations(data, title, **kwds):\n",
-    "    \"\"\"Calculate pairwise correlation between features.\n",
-    "    \n",
-    "    Extra arguments are passed on to DataFrame.corr()\n",
-    "    \"\"\"\n",
-    "    # simply call df.corr() to get a table of\n",
-    "    # correlation values if you do not need\n",
-    "    # the fancy plotting\n",
-    "    corrmat = data.corr(**kwds)\n",
-    "\n",
-    "    fig, ax1 = plt.subplots(ncols=1, figsize=(6,5))\n",
-    "    \n",
-    "    opts = {'cmap': plt.get_cmap(\"RdBu\"),\n",
-    "            'vmin': -1, 'vmax': +1}\n",
-    "    heatmap1 = ax1.pcolor(corrmat, **opts)\n",
-    "    plt.colorbar(heatmap1, ax=ax1)\n",
-    "\n",
-    "    ax1.set_title(title+\" Correlations\")\n",
-    "\n",
-    "    labels = corrmat.columns.values\n",
-    "    for ax in (ax1,):\n",
-    "        # shift location of ticks to center of the bins\n",
-    "        ax.set_xticks(np.arange(len(labels))+0.5, minor=False)\n",
-    "        ax.set_yticks(np.arange(len(labels))+0.5, minor=False)\n",
-    "        ax.set_xticklabels(labels, minor=False, ha='right', rotation=70)\n",
-    "        ax.set_yticklabels(labels, minor=False)\n",
-    "        \n",
-    "    plt.tight_layout()"
+    "# Functions to apply cuts"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
-    "def plot_data(data):\n",
+    "def apply_cuts(data):\n",
+    "    # cut on lepton etcone20\n",
+    "    fail = data[np.vectorize(cut_lep_etcone20)(data.lep_type, data.lep_pt,\n",
+    "                                               data.lep_etcone20)].index\n",
+    "    data.drop(fail, inplace=True)\n",
+    "    print('cut_lep_etcone20:', data.shape)\n",
+    "   \n",
+    "    # cut on lepton d0\n",
+    "    fail = data[np.vectorize(cut_lep_d0)(data.lep_type, data.lep_trackd0pvunbiased,\n",
+    "                                         data.lep_tracksigd0pvunbiased)].index\n",
+    "    data.drop(fail, inplace=True)\n",
+    "    print('cut_lep_d0:', data.shape)\n",
     "\n",
-    "    bins = [80 + x*5 for x in range(35) ]\n",
-    "    data_x = [82.5 + x*5 for x in range(34) ]\n",
+    "    # cut on deltaR\n",
+    "    fail = data[np.vectorize(cut_deltaR)(data.lep_eta,data.lep_phi)].index\n",
+    "    data.drop(fail, inplace=True)\n",
+    "    print('cut_deltaR:', data.shape)\n",
     "\n",
-    "    data_mllll = []\n",
-    "    data_mllll_errors = []\n",
+    "    # cut on number of leptons\n",
+    "    fail = data[np.vectorize(cut_n_lep)(data.lep_n)].index\n",
+    "    data.drop(fail, inplace=True)\n",
+    "    print('cut_n_lep:', data.shape)\n",
     "\n",
-    "    mc_mllll = []\n",
-    "    mc_weights = []\n",
-    "    mc_colors = []\n",
-    "    mc_labels = []\n",
-    "    mc_in_mllll_window = [] # list for numbers of MC events with 120 < mllll < 130 GeV\n",
+    "    # cut on lepton charge\n",
+    "    fail = data[np.vectorize(cut_lep_charge)(data.lep_charge)].index\n",
+    "    data.drop(fail, inplace=True)\n",
+    "    print('cut_lep_charge:', data.shape)\n",
     "\n",
-    "    for s in stack_order:\n",
-    "        if s == \"data\":\n",
-    "            data_mllll,_ = np.histogram(data[s].mllll.values, bins=bins)\n",
-    "            data_mllll_errors = np.sqrt(data_mllll)\n",
-    "        else:\n",
-    "            mc_labels.append(s)\n",
-    "            mc_mllll.append(data[s].mllll.values)\n",
-    "            mc_colors.append(samples[s]['color'])\n",
-    "            mc_weights.append(data[s].totalWeight.values)\n",
-    "            mc_in_mllll_window.append([data[s].totalWeight.values[mllll_iter] for mllll_iter in range(len(data[s].mllll.values)) if 120 < data[s].mllll.values[mllll_iter] < 130])\n",
-    "    \n",
-    "    HZZ_in_mllll_window = sum(mc_in_mllll_window[2]) # number signal MC events with 120 < mllll < 130 GeV\n",
-    "    background_in_mllll_window = sum(mc_in_mllll_window[0]+mc_in_mllll_window[1]) # number background MC events with 120 < mllll < 130 GeV\n",
-    "    SoversqrtB = HZZ_in_mllll_window/math.sqrt(background_in_mllll_window) # calculate significance\n",
-    "    print('Signal/sqrt(Background) for 120<mllll<130 '+str(SoversqrtB))\n",
-    "    \n",
-    "    top = np.amax(data_mllll)+math.sqrt(np.amax(data_mllll))\n",
+    "    # cut on lepton type\n",
+    "    fail = data[np.vectorize(cut_lep_type)(data.lep_type)].index\n",
+    "    data.drop(fail, inplace=True)\n",
+    "    print('cut_lep_type:', data.shape)\n",
     "\n",
-    "    plt.figure()\n",
-    "    plt.hist(mc_mllll,bins=bins,weights=mc_weights,stacked=True,color=mc_colors, label=mc_labels)\n",
-    "    plt.errorbar( x=data_x, y=data_mllll, yerr=data_mllll_errors, fmt='ko', label='Data')\n",
-    "\n",
-    "    #X = np.arange(115,135,5) # gives list [115,120,125,130]\n",
-    "    #data_in_window = data_mllll[7:11] # gives list of data y value for [115,120,125,130]\n",
-    "    #x = np.sum(X*data_in_window)/np.sum(data_in_window) # Gaussian mean\n",
-    "    #width = np.sqrt(np.abs(np.sum((X-x)**2*data_in_window)/np.sum(data_in_window))) # Gaussian width\n",
-    "    #fit = lambda t : np.amax(data_in_window)*np.exp(-(t-x)**2/(2*width**2)) # Gaussian fit\n",
-    "    #plt.plot(X, fit(X), '-') # plot Gaussian\n",
-    "    \n",
-    "    plt.xlabel(r'$M_{\\ell\\ell\\ell\\ell}$ [GeV]',fontname='sans-serif',horizontalalignment='right',x=1.0,fontsize=11)\n",
+    "    # cut on lepton pt\n",
+    "    fail = data[np.vectorize(cut_lep_pt)(data.lep_pt)].index\n",
+    "    data.drop(fail, inplace=True)\n",
+    "    print('cut_lep_pt:', data.shape)\n",
     "\n",
-    "    plt.ylabel(r'Events',fontname='sans-serif',horizontalalignment='right',y=1.0,fontsize=11)\n",
-    "    #plt.yscale('log')                                                                                                                                                                        \n",
-    "    plt.ylim(bottom=0,top=top)\n",
+    "    # cut on minimum lepton pt\n",
+    "    fail = data[np.vectorize(cut_lep_pt_min)(data.lep_type, data.lep_pt)].index\n",
+    "    data.drop(fail, inplace=True)\n",
+    "    print('cut_lep_pt_min:', data.shape)\n",
     "\n",
-    "    ax = plt.gca()\n",
-    "    plt.text(0.05,0.97,r'$\\mathbf{{ATLAS}}$ Open Data',ha=\"left\",va=\"top\",family='sans-serif',transform=ax.transAxes,fontsize=13)\n",
-    "    plt.text(0.05,0.92,'for education only',ha=\"left\",va=\"top\",family='sans-serif',transform=ax.transAxes,style='italic',fontsize=8)\n",
-    "    plt.text(0.05,0.9,r'$\\sqrt{s}=8\\,\\mathrm{TeV},\\;\\int L\\,dt=1\\,\\mathrm{fb}^{-1}$',ha=\"left\",va=\"top\",family='sans-serif',transform=ax.transAxes)\n",
+    "    # calculation of Z boson candidate 1 invariant mass\n",
+    "    data['mZ1'], data['mZ2'] = np.vectorize(calc_mZs)(\n",
+    "                                   data.lep_pt,data.lep_eta,data.lep_phi,\n",
+    "                                   data.lep_charge,data.lep_type)\n",
     "\n",
-    "    plt.legend()\n",
+    "    # cut on mZ1\n",
+    "    fail = data[np.vectorize(cut_mZ1)(data.mZ1)].index\n",
+    "    data.drop(fail, inplace=True)\n",
+    "    print('cut_mZ1:', data.shape)\n",
+    " \n",
+    "    # cut on mZ2\n",
+    "    fail = data[np.vectorize(cut_mZ2)(data.mZ2, data.mllll)].index\n",
+    "    data.drop(fail, inplace=True)\n",
+    "    print('cut_mZ2:', data.shape)\n",
     "\n",
-    "    plt.savefig(\"plot.pdf\")\n",
-    "    \n",
-    "    # scatter plot of signal and background lep_n vs mllll\n",
-    "    #plt.figure()\n",
-    "    #for s in stack_order:\n",
-    "    #    if s != 'data': plt.scatter(data[s].lep_n,data[s].mllll,color=samples[s]['color'],label=s)\n",
-    "    #plt.xlabel(r'Leptons',fontname='sans-serif',horizontalalignment='right',y=1.0,fontsize=11)\n",
-    "    #plt.ylabel(r'$M_{\\ell\\ell\\ell\\ell}$ [GeV]',fontname='sans-serif',horizontalalignment='right',x=1.0,fontsize=11)\n",
-    "    #plt.legend()\n",
-    "    \n",
-    "    # scatter plot of signal and background lep_pt[0] vs mllll\n",
-    "    #plt.figure()\n",
-    "    #for s in stack_order:\n",
-    "    #    if s != 'data': plt.scatter(data[s].lep_pt.apply(lambda x: x[0]),data[s].mllll,color=samples[s]['color'],label=s)\n",
-    "    #plt.legend()\n",
-    "    \n",
-    "    # boxplot of signal and background mllll\n",
-    "    #plt.figure()\n",
-    "    #for s in stack_order:\n",
-    "    #    if s != 'data': data[s]['Process'] = s\n",
-    "    #data_all = pd.concat([data[r'$Z,t\\bar{t}$'],data['ZZ'],data[r'$H \\rightarrow ZZ \\rightarrow \\ell\\ell\\ell\\ell$']])\n",
-    "    #data_all.boxplot(by='Process',column=[\"mllll\"])\n",
-    "    \n",
-    "    # plot correlation matrices for signal and background\n",
-    "    #correlations(pd.concat([data[r'$Z,t\\bar{t}$'],data['ZZ']]),\"background\")\n",
-    "    #correlations(data[r'$H \\rightarrow ZZ \\rightarrow \\ell\\ell\\ell\\ell$'], \"signal\")\n",
+    "    return data\n",
     "\n",
-    "    return"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
     "def calc_mllll(lep_pts,lep_etas,lep_phis):\n",
     "    theta_0 = 2*math.atan(math.exp(-lep_etas[0]))\n",
     "    theta_1 = 2*math.atan(math.exp(-lep_etas[1]))\n",
@@ -344,239 +386,712 @@
     "    sumpy = py_0 + py_1 + py_2 + py_3\n",
     "    sumE = p_0 + p_1 + p_2 + p_3\n",
     "    mllll = sumE**2 - sumpz**2 - sumpx**2 - sumpy**2\n",
-    "    return math.sqrt(mllll)/1000."
+    "    return math.sqrt(mllll)/1000.0\n",
+    "\n",
+    "def calc_mll(lep_pts,lep_etas,lep_phis):\n",
+    "    '''arguments are lists containing 2 elements:: 0 = particle 1 and 1 = particle 2'''\n",
+    "    mll = 2*lep_pts[0]*lep_pts[1]\n",
+    "    cosh = math.cosh(lep_etas[0]-lep_etas[1])\n",
+    "    cos = math.cos(lep_phis[0]-lep_phis[1])\n",
+    "    mll *= ( cosh - cos )\n",
+    "    return math.sqrt(mll)/1000.0\n",
+    "\n",
+    "def cut_n_lep(lep_n):\n",
+    "    '''only keep events with 4 leptons'''\n",
+    "    return lep_n != 4\n",
+    "\n",
+    "def cut_lep_charge(lep_charge):\n",
+    "    '''only keep events with 2 oppositely charged lepton pairs'''\n",
+    "    return lep_charge[0] + lep_charge[1] + lep_charge[2] + lep_charge[3] != 0\n",
+    "\n",
+    "def cut_lep_type(lep_type):\n",
+    "    '''only keep events with e-/e+ and mu-/mu+ pairs'''\n",
+    "    sum_lep_type = lep_type[0] + lep_type[1] + lep_type[2] + lep_type[3]\n",
+    "    return (lep_type[0]+lep_type[1]+lep_type[2]+lep_type[3] != 44) \\\n",
+    "           and (lep_type[0]+lep_type[1]+lep_type[2]+lep_type[3] != 48) \\\n",
+    "           and (lep_type[0]+lep_type[1]+lep_type[2]+lep_type[3] != 52)\n",
+    "\n",
+    "def cut_lep_pt(lep_pt):\n",
+    "    '''\n",
+    "    remove events where the 2nd highest pt lepton used has lep_pt[1] < 15000\n",
+    "    remove events where the 3rd highest pt lepton used has lep_pt[2] < 10000\n",
+    "    '''\n",
+    "    return lep_pt[1] < 15000 or lep_pt[2] < 10000\n",
+    "\n",
+    "def cut_lep_pt_min(lep_type, lep_pt):\n",
+    "    '''\n",
+    "    remove muons with lep_pt < 6000\n",
+    "    remove electrons with lep_pt < 7000\n",
+    "    '''\n",
+    "    cond = []\n",
+    "    for i in range(len(lep_type)):\n",
+    "        if lep_type[i] == 13:\n",
+    "            cond.append(lep_pt[i] < 7000)\n",
+    "        if lep_type[i] == 11:\n",
+    "            cond.append(lep_pt[i] < 6000)\n",
+    "    return True in cond\n",
+    "\n",
+    "def cut_deltaR(lep_eta, lep_phi):\n",
+    "    '''cut on deltaR\n",
+    "       want to throw away leptons that are separated from all other leptons by\n",
+    "       deltaR = math.sqrt(delta(lep_eta)**2 + delta(lep_phi)**2) < 0.2\n",
+    "       want to throw away leptons that are separated from other leptons of the\n",
+    "       same type by deltaR = math.sqrt(delta(lep_eta)**2 + delta(lep_phi)**2) < 0.1\n",
+    "    '''\n",
+    "    delta_eta = []\n",
+    "    for i in range(len(lep_eta)):\n",
+    "        for j in range(len(lep_eta)):\n",
+    "            if i != j:\n",
+    "                delta_eta.append(lep_eta[i] - lep_eta[j])\n",
+    "    delta_phi = []\n",
+    "    for i in range(len(lep_phi)):\n",
+    "        for j in range(len(lep_phi)):\n",
+    "            if i != j:\n",
+    "                delta_phi.append(lep_phi[i] - lep_phi[j])\n",
+    "    deltaR = [math.sqrt(delta_eta[i]**2 + delta_phi[i]**2) < 0.1 \\\n",
+    "              for i in range(len(delta_eta))]\n",
+    "    return True in deltaR\n",
+    "\n",
+    "def cut_lep_etcone20(lep_type, lep_pt, lep_etcone20):\n",
+    "    '''cut on maximum lepton etcone20\n",
+    "       want to throw away muons with lep_etcone20/lep_pt < 0.3\n",
+    "       want to throw away electrons with lep_etcone20/lep_pt < 0.2\n",
+    "    '''\n",
+    "    cond = []\n",
+    "    for i in range(len(lep_type)):\n",
+    "        if lep_type[i] == 13:\n",
+    "            cond.append(1000*lep_etcone20[i]/lep_pt[i] < 0.3)\n",
+    "        if lep_type[i] == 11:\n",
+    "            cond.append(1000*lep_etcone20[i]/lep_pt[i] < 0.2)\n",
+    "    return True in cond\n",
+    "\n",
+    "def cut_lep_d0(lep_type, lep_trackd0pvunbiased, lep_tracksigd0pvunbiased):\n",
+    "    '''\n",
+    "    cut on maximum lepton d0\n",
+    "    want to throw away muons with lep_trackd0pvunbiased/lep_tracksigd0pvunbiased < 3.5\n",
+    "    want to throw away electrons with lep_trackd0pvunbiased/lep_tracksigd0pvunbiased < 6.5\n",
+    "    '''\n",
+    "    cond = []\n",
+    "    for i in range(len(lep_type)):\n",
+    "        if lep_type[i] == 13:\n",
+    "            cond.append(lep_trackd0pvunbiased[i]/lep_tracksigd0pvunbiased[i] > 3.5)\n",
+    "        if lep_type[i] == 11:\n",
+    "            cond.append(lep_trackd0pvunbiased[i]/lep_tracksigd0pvunbiased[i] > 6.5)\n",
+    "    return True in cond\n",
+    "\n",
+    "def calc_mZs(lep_pts, lep_etas, lep_phis, lep_charges, lep_types):\n",
+    "    '''calculates the invariant mass of the Z candidates'''\n",
+    "    # classify particles by charge\n",
+    "    neg = np.where(lep_charges==-1)[0]\n",
+    "    pos = np.where(lep_charges==1)[0]\n",
+    "\n",
+    "    # invariance masses of the different possible combinations\n",
+    "    mll = []\n",
+    "    combinations = [[0,0], [0,1], [1,0], [1,1]]\n",
+    "    for [i, j] in combinations:\n",
+    "        part1 = neg[i]\n",
+    "        part2 = pos[j]\n",
+    "        if lep_types[part1] == lep_types[part2]:\n",
+    "            pt = [lep_pts[part1], lep_pts[part2]]\n",
+    "            eta = [lep_etas[part1], lep_etas[part2]]\n",
+    "            phi = [lep_phis[part1], lep_phis[part2]]\n",
+    "            mll.append(calc_mll(pt, eta, phi))\n",
+    "    Z1_diff = np.abs([m - 91 for m in mll])\n",
+    "    try:\n",
+    "        Z1_index = Z1_diff.argmin()\n",
+    "        mZ1 = mll[Z1_index]\n",
+    "        if Z1_index in [0, 1, 2]:\n",
+    "            Z2_index = Z1_index + 1\n",
+    "        if Z1_index == 3:\n",
+    "            Z2_index = 0\n",
+    "        mZ2 = mll[Z2_index]\n",
+    "        return mZ1, mZ2\n",
+    "    except:\n",
+    "        # These events correspond to mis-identificated particles\n",
+    "        # they will be removed by cut_mZ1 and cut_mZ2\n",
+    "        return 0, 0\n",
+    "\n",
+    "def cut_mZ1(mZ1):\n",
+    "    '''cut on invariant mass of Z boson candidate 1\n",
+    "       want invariant mass of same-type-opposite-charge lepton pair that's closest\n",
+    "       to Z mass (91 GeV) to be in range 50 < m < 106 GeV\n",
+    "    '''\n",
+    "    return mZ1 < 50 or mZ1 > 106\n",
+    "\n",
+    "def cut_mZ2(mZ2, mllll):\n",
+    "    '''cut on invariant mass of Z boson candidate 2\n",
+    "       want invariant mass of remaining lepton pair that's closest to Z mass (91 GeV)\n",
+    "       to be in range 17.5 < m < 115 GeV\n",
+    "       advanced: vary the lower range monotically from 17.5 at mllll=120 to 50 at\n",
+    "       mllll=190, and constant above mllll=190\n",
+    "    '''\n",
+    "    # Straight line fit to lower range of mZ2\n",
+    "    gradient = 0.4642857142857143\n",
+    "    intercept = -38.214285714285715\n",
+    "    lower_limit = gradient*mllll + intercept\n",
+    "    return mZ2 < lower_limit or mZ2 > 115"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Function to implement a random forest regression"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
-    "def calc_mll(lep_pts,lep_etas,lep_phis):\n",
-    "    # this is only pseudo-code to tell you what to do!\n",
-    "    # you need to decide how to find i & j yourself\n",
-    "    mll = 2*lep_pts[i]*lep_pts[j!=i]\n",
-    "    cosh = math.cosh(lep_etas[i]-lep_etas[j!=i])\n",
-    "    cos = math.cos(lep_phis[i]-lep_phis[j!=i])\n",
-    "    mll *= ( cosh - cos )\n",
-    "    return math.sqrt(mll)/1000."
+    "def forest_regression(data):\n",
+    "    '''finds the most important varibles to use as inputs for a neural network'''\n",
+    "    reg = ske.RandomForestRegressor()\n",
+    "\n",
+    "    cleaned_data = remove_variable_length_columns(\n",
+    "                   data[r'$H \\rightarrow ZZ \\rightarrow \\ell\\ell\\ell\\ell$'])\n",
+    "    y = cleaned_data.mllll\n",
+    "\n",
+    "    cleaned_data.drop([\"mllll\"], axis=1, inplace=True)\n",
+    "    X = cleaned_data\n",
+    "\n",
+    "    reg.fit(X, y)\n",
+    "\n",
+    "    fet_ind = np.argsort(reg.feature_importances_)[::-1]\n",
+    "    fet_imp = reg.feature_importances_[fet_ind]\n",
+    "\n",
+    "    plot_forest(data, fet_ind, fet_imp, X, y)\n",
+    "\n",
+    "    # Take the 4 most important variables to train the neural network\n",
+    "    nn_input = cleaned_data.columns.values[fet_ind[:4]]\n",
+    "\n",
+    "    return nn_input\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Uncommenting a new cut\n",
-    "If you add a cut: Cell -> Run All Below"
+    "# Function to implement a deep neural network"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
-    "def read_file(path,sample):\n",
-    "    start = time.time()\n",
-    "    print(\"\\tProcessing: \"+sample)\n",
-    "    mc = uproot.open(path)[\"mini\"]\n",
-    "    data = mc.pandas.df([\"lep_n\",\"lep_pt\",\"lep_eta\",\"lep_phi\",\"lep_charge\",\"lep_type\",\"lep_etcone20\",\"lep_trackd0pvunbiased\",\"lep_tracksigd0pvunbiased\",\n",
-    "                         \"mcWeight\",\"scaleFactor_PILEUP\",\"scaleFactor_ELE\",\"scaleFactor_MUON\", # add more variables here if you make cuts on them\n",
-    "                         \"scaleFactor_TRIGGER\"], flatten=False)\n",
+    "def generate_neural_network(mc_data, VARS):\n",
+    "    NDIM = len(VARS)\n",
     "\n",
-    "    nIn = len(data.index)\n",
+    "    X = mc_data[VARS].values\n",
+    "    Y = mc_data['isSignal'].values\n",
     "\n",
-    "    if 'Data' not in sample:\n",
-    "        data['totalWeight'] = np.vectorize(calc_weight)(data.mcWeight,data.scaleFactor_PILEUP,data.scaleFactor_ELE,data.scaleFactor_MUON,data.scaleFactor_TRIGGER)\n",
-    "        data['totalWeight'] = np.vectorize(get_xsec_weight)(data.totalWeight,sample)\n",
+    "    # Split training and testing data\n",
+    "    X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2)\n",
     "\n",
-    "    data.drop([\"mcWeight\",\"scaleFactor_PILEUP\",\"scaleFactor_ELE\",\"scaleFactor_MUON\",\"scaleFactor_TRIGGER\"], axis=1, inplace=True)\n",
-    "    \n",
-    "    # cut on minimum lepton pt\n",
-    "    \n",
-    "    # cut on lepton etcone20\n",
-    "    \n",
-    "    # cut on lepton d0\n",
-    "    \n",
-    "    # example of adding column that takes the return of the function cut_lep_pt_min\n",
-    "    #data['lep_pt_min'] = data.apply(cut_lep_pt_min,axis=1)\n",
-    "    \n",
-    "    # example of cut on minimum number of leptons passing baseline requirements\n",
-    "    #fail = data[ np.vectorize(cut_n_lep_min)(data.lep_pt_min) ].index\n",
-    "    #data.drop(fail, inplace=True)\n",
-    "    \n",
-    "    # cut on number of leptons\n",
-    "    fail = data[ np.vectorize(cut_n_lep)(data.lep_n) ].index\n",
-    "    data.drop(fail, inplace=True)\n",
+    "    # normalise the data\n",
+    "    scaler = StandardScaler().fit(X_train)\n",
+    "    X_train = scaler.transform(X_train)\n",
+    "    X_test = scaler.transform(X_test)\n",
     "\n",
-    "    # cut on lepton charge\n",
-    "    #fail = data[ np.vectorize(cut_lep_charge)(data.lep_charge) ].index\n",
-    "    #data.drop(fail, inplace=True)\n",
-    "    \n",
-    "    #print(data)\n",
-    "    \n",
-    "    # cut on lepton type\n",
-    "    #fail = data[ np.vectorize(cut_lep_type)(data.lep_type) ].index\n",
-    "    #data.drop(fail, inplace=True)\n",
-    "    \n",
-    "    # cut on lepton pt\n",
-    "    #fail = data[ np.vectorize(cut_lep_pt)(data.lep_pt) ].index\n",
-    "    #data.drop(fail, inplace=True)\n",
-    "    \n",
-    "    # cut on deltaR\n",
-    "    #fail = data[ np.vectorize(cut_deltaR)(data.lep_eta,data.lep_phi...\n",
-    "    #data.drop(fail, inplace=True)\n",
-    "    \n",
-    "    # cut on minimum opposite-charge-same-type lepton pair invariant mass\n",
-    "    #fail = data[ np.vectorize(cut_OCST)(data....\n",
+    "    # create the model\n",
+    "    model = Sequential()\n",
+    "    model.add(layers.Dense(5, activation='sigmoid', input_shape=(X.shape[1],)))\n",
+    "    model.add(layers.Dropout(0.1))\n",
+    "    model.add(layers.Dense(3, activation='sigmoid'))\n",
+    "    model.add(layers.Dense(1, activation='sigmoid'))\n",
+    "    model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])\n",
+    "    model.summary()\n",
     "\n",
-    "    # calculation of Z boson candidate 1 invariant mass\n",
-    "    #data['mZ1'] = np.vectorize(calc_mZ1)(data.lep_pt,data.lep_eta,data.lep_phi)\n",
-    "    \n",
-    "    # cut on mZ1\n",
-    "    #fail = data[ np.vectorize(cut_mZ1)(data.mZ1) ].index\n",
-    "    #data.drop(fail, inplace=True)\n",
-    "    \n",
-    "    # calculation of Z boson candidate 2 invariant mass\n",
-    "    #data['mZ2'] = np.vectorize(calc_mZ2)(data....\n",
-    "    \n",
-    "    # cut on mZ2\n",
-    "    #fail = data[ np.vectorize(cut_mZ2)(data.mZ2) ].index\n",
-    "    #data.drop(fail, inplace=True)\n",
-    "    \n",
-    "    # calculation of 4-lepton invariant mass\n",
-    "    data['mllll'] = np.vectorize(calc_mllll)(data.lep_pt,data.lep_eta,data.lep_phi)\n",
+    "    # early stopping callback\n",
+    "    early_stopping = EarlyStopping(monitor='val_loss', patience=10)\n",
     "\n",
-    "    mllll_window_list = data[ np.vectorize(mllll_window)(data.mllll) ] # return events with 120 < mllll < 130 GeV\n",
-    "    \n",
-    "    # example of expanding lep_pt list column into individual columns whilst requiring exactly 4 leptons\n",
-    "    # need to change cut_lep_n to require exactly 4 leptons\n",
-    "    #data[['lep1_pt','lep2_pt','lep3_pt','lep4_pt']] = pd.DataFrame(data.lep_pt.values.tolist(), index= data.index)\n",
-    "\n",
-    "    # example of expanding lep_pt list column into individual columns without requiring exactly 4 leptons\n",
-    "    # need to do this for columns that you wish to use for fit_BDT\n",
-    "    #if max(data.lep_n) < 5: \n",
-    "    #    df_split = pd.DataFrame(data['lep_pt'].values.tolist(), columns=['lep1_pt','lep2_pt','lep3_pt','lep4_pt'], index=data.index)\n",
-    "    #    df_split['lep5_pt'] = 0\n",
-    "    #    df_split['lep6_pt'] = 0\n",
-    "    #elif max(data.lep_n) < 6: \n",
-    "    #    df_split = pd.DataFrame(data['lep_pt'].values.tolist(), columns=['lep1_pt','lep2_pt','lep3_pt','lep4_pt','lep5_pt'], index=data.index)\n",
-    "    #    df_split['lep6_pt'] = 0\n",
-    "    #else: df_split = pd.DataFrame(data['lep_pt'].values.tolist(), columns=['lep1_pt','lep2_pt','lep3_pt','lep4_pt','lep5_pt','lep6_pt'], index=data.index)\n",
-    "    #df_split.fillna(0, inplace=True)\n",
-    "    #data = pd.concat([data, df_split], axis=1)\n",
-    "    \n",
-    "    #print(data)\n",
+    "    # model checkpoint callback\n",
+    "    # saves model architecture + parameters into dense_model.h5\n",
+    "    model_checkpoint = ModelCheckpoint('dense_model.h5', monitor='val_loss',\n",
+    "                                        verbose=0, save_best_only=True,\n",
+    "                                        save_weights_only=False, mode='auto',\n",
+    "                                        period=1)\n",
     "\n",
-    "    nOut = len(data.index)\n",
+    "    # Train classifier\n",
+    "    print('Training model')\n",
+    "    history = model.fit(X_train,\n",
+    "                        Y_train,\n",
+    "                        epochs=1000,\n",
+    "                        batch_size=2048,\n",
+    "                        verbose=0,\n",
+    "                        callbacks=[early_stopping, model_checkpoint],\n",
+    "                        validation_split=0.2)\n",
     "\n",
-    "    elapsed = time.time() - start\n",
-    "    print(\"\\t\\tTime taken: \"+str(elapsed)+\", nIn: \"+str(nIn)+\", nOut: \"+str(nOut))\n",
+    "    # plot loss vs epoch and accuracy vs epoch\n",
+    "    plot_loss(history)\n",
+    "    plot_accuracy(history)\n",
+    "\n",
+    "    # model checkpoint callback\n",
+    "    # saves model architecture + parameters into dense_model.h5\n",
+    "    model_checkpoint = ModelCheckpoint('dense_model.h5', monitor='val_loss',\n",
+    "                                        verbose=0, save_best_only=True,\n",
+    "                                        save_weights_only=False, mode='auto',\n",
+    "                                        period=1)\n",
+    "\n",
+    "    # make predictions\n",
+    "    Y_predict = model.predict(X_test)\n",
+    "\n",
+    "    # plot ROC\n",
+    "    fpr, tpr, thresholds = roc_curve(Y_test, Y_predict)\n",
+    "    roc_auc = auc(fpr, tpr)\n",
+    "    plot_roc(fpr, tpr, roc_auc)\n",
     "    \n",
-    "    return data"
+    "    return model"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Changing an already uncommented cut"
+    "# Functions to make plots"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": 13,
    "metadata": {},
+   "outputs": [],
    "source": [
-    "If you change a cut: Cell -> Run All Below\n",
+    "def calc_hists(data):\n",
+    "    '''Calculates a histogram of the Monte-Carlo invariant mass and other\n",
+    "        necessary objects'''\n",
+    "    bins = [80 + x*5 for x in range(35) ]\n",
+    "\n",
+    "    data_mllll = []\n",
+    "    data_mllll_errors = []\n",
+    "\n",
+    "    mc_mllll = []\n",
+    "    mc_weights = []\n",
+    "    mc_colors = []\n",
+    "    mc_labels = []\n",
+    "    mc_in_mllll_window = [] # list for numbers of MC events with 120 < mllll < 130 GeV\n",
+    "\n",
+    "    for s in stack_order:\n",
+    "        if s == \"data\":\n",
+    "            data_mllll,_ = np.histogram(data[s].mllll.values, bins=bins)\n",
+    "            data_mllll_errors = np.sqrt(data_mllll)\n",
+    "        else:\n",
+    "            mc_labels.append(s)\n",
+    "            mc_mllll.append(data[s].mllll.values)\n",
+    "            mc_colors.append(samples[s]['color'])\n",
+    "            mc_weights.append(data[s].totalWeight.values)\n",
+    "            mc_in_mllll_window.append([data[s].totalWeight.values[mllll_iter] \\\n",
+    "                for mllll_iter in range(len(data[s].mllll.values)) \\\n",
+    "                if 120 < data[s].mllll.values[mllll_iter] < 130])\n",
+    "\n",
+    "    return [data_mllll, data_mllll_errors, mc_mllll, mc_labels, mc_colors,\n",
+    "            mc_weights, mc_in_mllll_window]\n",
+    "\n",
+    "def plot_data(hists):\n",
+    "    data_mllll = hists[0]\n",
+    "    data_mllll_errors = hists[1]\n",
+    "    mc_mllll = hists[2]\n",
+    "    mc_labels = hists[3]\n",
+    "    mc_colors  = hists[4]\n",
+    "    mc_weights = hists[5]\n",
+    "\n",
+    "    data_x = [82.5 + x*5 for x in range(34)]\n",
+    "    bins   = [80 + x*5 for x in range(35)]\n",
     "\n",
-    "If you uncomment a cut here, you also need to uncomment the corresponding cut in the cell above."
+    "    top = np.amax(data_mllll)+math.sqrt(np.amax(data_mllll))\n",
+    "\n",
+    "    plt.figure()\n",
+    "    plt.hist(mc_mllll,bins=bins,weights=mc_weights,stacked=True,color=mc_colors,\n",
+    "             label=mc_labels)\n",
+    "    plt.errorbar(x=data_x, y=data_mllll, yerr=data_mllll_errors, fmt='ko', label='Data')\n",
+    "    plt.xlabel(r'$M_{\\ell\\ell\\ell\\ell}$ [GeV]',fontname='sans-serif',\n",
+    "               horizontalalignment='right',x=1.0,fontsize=11)\n",
+    "    plt.ylabel(r'Events',fontname='sans-serif',horizontalalignment='right',y=1.0,\n",
+    "               fontsize=11)\n",
+    "    plt.ylim(bottom=0,top=top)\n",
+    "\n",
+    "    ax = plt.gca()\n",
+    "    plt.text(0.05,0.97,r'$\\mathbf{{ATLAS}}$ Open Data',ha=\"left\",va=\"top\",\n",
+    "             family='sans-serif',transform=ax.transAxes,fontsize=13)\n",
+    "    plt.text(0.05,0.92,'for education only',ha=\"left\",va=\"top\",\n",
+    "             family='sans-serif',transform=ax.transAxes,style='italic',fontsize=8)\n",
+    "    plt.text(0.05,0.9,r'$\\sqrt{s}=8\\,\\mathrm{TeV},\\;\\int L\\,dt=1\\,\\mathrm{fb}^{-1}$',\n",
+    "             ha=\"left\",va=\"top\",family='sans-serif',transform=ax.transAxes)\n",
+    "    plt.legend()\n",
+    "    plt.savefig(\"events.png\")\n",
+    "\n",
+    "    return\n",
+    "\n",
+    "def plot_loss(history):\n",
+    "    plt.figure(figsize=(15,10))\n",
+    "    ax = plt.subplot(2, 2, 1)\n",
+    "    ax.plot(history.history['loss'], label='loss')\n",
+    "    ax.plot(history.history['val_loss'], label='val_loss')\n",
+    "    ax.legend(loc=\"upper right\")\n",
+    "    ax.set_xlabel('epoch')\n",
+    "    ax.set_ylabel('loss')\n",
+    "    return\n",
+    "\n",
+    "def plot_accuracy(history):\n",
+    "    ax = plt.subplot(2, 2, 2)\n",
+    "    ax.plot(history.history['acc'], label='acc')\n",
+    "    ax.plot(history.history['val_acc'], label='val_acc')\n",
+    "    ax.legend(loc=\"upper left\")\n",
+    "    ax.set_xlabel('epoch')\n",
+    "    ax.set_ylabel('acc')\n",
+    "    return\n",
+    "\n",
+    "def plot_roc(fpr, tpr, roc_auc):\n",
+    "    ax = plt.subplot(2, 2, 3)\n",
+    "    ax.plot(fpr, tpr, lw=2, color='cyan', label='auc = %.3f' % (roc_auc))\n",
+    "    ax.plot([0, 1], [0, 1], linestyle='--', lw=2, color='k', label='random chance')\n",
+    "    ax.set_xlim([0, 1.0])\n",
+    "    ax.set_ylim([0, 1.0])\n",
+    "    ax.set_xlabel('false positive rate')\n",
+    "    ax.set_ylabel('true positive rate')\n",
+    "    ax.set_title('receiver operating curve')\n",
+    "    ax.legend(loc=\"lower right\")\n",
+    "    plt.savefig('metrics.png')\n",
+    "    return\n",
+    "\n",
+    "def plot_forest(data, fet_ind, fet_imp, X, y):\n",
+    "    fig, ax = plt.subplots(1, 1, figsize=(8, 3))\n",
+    "    labels = np.array(\n",
+    "             data[r'$H \\rightarrow ZZ \\rightarrow \\ell\\ell\\ell\\ell$'].columns)[fet_ind]\n",
+    "    pd.Series(fet_imp, index=labels).plot('bar', ax=ax)\n",
+    "    ax.set_title('Features importance')\n",
+    "    fig, ax = plt.subplots(1, 1)\n",
+    "    ax.scatter(X['lep1_pt'].values, y, label='lep1')\n",
+    "    ax.scatter(X['lep2_pt'].values, y, label='lep2')\n",
+    "    ax.scatter(X['lep2_pt'].values, y, label='lep3')\n",
+    "    ax.scatter(X['lep3_pt'].values, y, label='lep4')\n",
+    "    ax.set_xlabel('lep_pt [GeV]')\n",
+    "    ax.set_ylabel(r'$M_{\\ell\\ell\\ell\\ell}$ [GeV]')\n",
+    "    ax.legend(loc=\"lower right\")\n",
+    "    plt.savefig('forest.png')\n",
+    "    return\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Function to calculate significance"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# cut on number of leptons\n",
-    "def cut_n_lep(lep_n):\n",
-    "    # return when number of leptons is less than 4\n",
-    "    return lep_n < 4\n",
+    "def calc_significance(mc_in_mllll_window):\n",
+    "    # number signal MC events with 120 < mllll < 130 GeV\n",
+    "    N_signal = sum(mc_in_mllll_window[2])\n",
     "\n",
-    "# cut on lepton charge\n",
-    "def cut_lep_charge(lep_charge):\n",
-    "    # return when sum of lepton charges is not equal to 0\n",
-    "    # exclamation mark (!) means \"not\"\n",
-    "    # so != means \"not equal to\"\n",
-    "    # first lepton is [0], 2nd lepton is [1] etc\n",
-    "    return lep_charge[0] + lep_charge[1] + lep_charge[2] + lep_charge[3] != 0\n",
+    "    # number background MC events with 120 < mllll < 130 GeV\n",
+    "    N_background = sum(mc_in_mllll_window[0]+mc_in_mllll_window[1])\n",
     "\n",
-    "# cut on lepton type\n",
-    "def cut_lep_type(lep_type):\n",
-    "# for an electron lep_type is 11\n",
-    "# for a muon lep_type is 13\n",
-    "    sum_lep_type = lep_type[0] + lep_type[1] + lep_type[2] + lep_type[3]\n",
-    "    return (lep_type[0]+lep_type[1]+lep_type[2]+lep_type[3] != 44) and (lep_type[0]+lep_type[1]+lep_type[2]+lep_type[3] != 48) and (lep_type[0]+lep_type[1]+lep_type[2]+lep_type[3] != 52)\n",
+    "    #sig = N_signal/math.sqrt(N_background)\n",
+    "    sig = math.sqrt(2*((N_signal + N_background)*np.log(1.0+N_signal/N_background)-N_signal))\n",
     "\n",
-    "# cut on lepton pt\n",
-    "#def cut_lep_pt(lep_pt):\n",
-    "# want to throw away events where the 2nd highest pt lepton used has lep_pt[1] < 15000\n",
-    "# want to throw away events where the 3rd highest pt lepton used has lep_pt[2] < 10000\n",
+    "    print('signifiance for 120<mllll<130 = %s' % (sig))\n",
     "\n",
-    "# cut on minimum opposite-charge-same-type lepton pair invariant mass\n",
-    "#def cut_mOCST():\n",
-    "# want to throw away events if the invariant mass of any opposite-charge-same-type lepton pair is < 5\n",
+    "    return sig\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Main function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "data:\n",
+      "Input/Data/skim.DataEgamma.root\n",
+      "\tProcessing: DataEgamma\n",
+      "cut_lep_etcone20: (60, 10)\n",
+      "cut_lep_d0: (45, 10)\n",
+      "cut_deltaR: (37, 10)\n",
+      "cut_n_lep: (37, 10)\n",
+      "cut_lep_charge: (30, 10)\n",
+      "cut_lep_type: (22, 10)\n",
+      "cut_lep_pt: (14, 10)\n",
+      "cut_lep_pt_min: (11, 10)\n",
+      "cut_mZ1: (6, 12)\n",
+      "cut_mZ2: (3, 12)\n",
+      "\t\tTime taken: 0.23403286933898926, nIn: 89, nOut: 3\n",
+      "Input/Data/skim.DataMuons.root\n",
+      "\tProcessing: DataMuons\n",
+      "cut_lep_etcone20: (58, 10)\n",
+      "cut_lep_d0: (45, 10)\n",
+      "cut_deltaR: (29, 10)\n",
+      "cut_n_lep: (28, 10)\n",
+      "cut_lep_charge: (20, 10)\n",
+      "cut_lep_type: (17, 10)\n",
+      "cut_lep_pt: (9, 10)\n",
+      "cut_lep_pt_min: (5, 10)\n",
+      "cut_mZ1: (5, 12)\n",
+      "cut_mZ2: (4, 12)\n",
+      "\t\tTime taken: 0.12181401252746582, nIn: 112, nOut: 4\n",
+      "$Z,t\\bar{t}$:\n",
+      "Input/MC/skim.mc_147770.Zee.root\n",
+      "\tProcessing: Zee\n",
+      "cut_lep_etcone20: (468, 11)\n",
+      "cut_lep_d0: (342, 11)\n",
+      "cut_deltaR: (313, 11)\n",
+      "cut_n_lep: (309, 11)\n",
+      "cut_lep_charge: (201, 11)\n",
+      "cut_lep_type: (122, 11)\n",
+      "cut_lep_pt: (33, 11)\n",
+      "cut_lep_pt_min: (20, 11)\n",
+      "cut_mZ1: (20, 13)\n",
+      "cut_mZ2: (11, 13)\n",
+      "\t\tTime taken: 0.40763306617736816, nIn: 720, nOut: 11\n",
+      "Input/MC/skim.mc_147771.Zmumu.root\n",
+      "\tProcessing: Zmumu\n",
+      "cut_lep_etcone20: (613, 11)\n",
+      "cut_lep_d0: (463, 11)\n",
+      "cut_deltaR: (324, 11)\n",
+      "cut_n_lep: (321, 11)\n",
+      "cut_lep_charge: (218, 11)\n",
+      "cut_lep_type: (126, 11)\n",
+      "cut_lep_pt: (32, 11)\n",
+      "cut_lep_pt_min: (14, 11)\n",
+      "cut_mZ1: (14, 13)\n",
+      "cut_mZ2: (7, 13)\n",
+      "\t\tTime taken: 0.443234920501709, nIn: 1057, nOut: 7\n",
+      "Input/MC/skim.mc_117050.ttbar_lep.root\n",
+      "\tProcessing: ttbar_lep\n",
+      "cut_lep_etcone20: (630, 11)\n",
+      "cut_lep_d0: (356, 11)\n",
+      "cut_deltaR: (320, 11)\n",
+      "cut_n_lep: (315, 11)\n",
+      "cut_lep_charge: (203, 11)\n",
+      "cut_lep_type: (112, 11)\n",
+      "cut_lep_pt: (59, 11)\n",
+      "cut_lep_pt_min: (43, 11)\n",
+      "cut_mZ1: (17, 13)\n",
+      "cut_mZ2: (12, 13)\n",
+      "\t\tTime taken: 0.33652281761169434, nIn: 897, nOut: 12\n",
+      "ZZ:\n",
+      "Input/MC/skim.mc_105986.ZZ.root\n",
+      "\tProcessing: ZZ\n",
+      "cut_lep_etcone20: (1011, 11)\n",
+      "cut_lep_d0: (974, 11)\n",
+      "cut_deltaR: (965, 11)\n",
+      "cut_n_lep: (964, 11)\n",
+      "cut_lep_charge: (941, 11)\n",
+      "cut_lep_type: (904, 11)\n",
+      "cut_lep_pt: (897, 11)\n",
+      "cut_lep_pt_min: (876, 11)\n",
+      "cut_mZ1: (670, 13)\n",
+      "cut_mZ2: (360, 13)\n",
+      "\t\tTime taken: 0.7335491180419922, nIn: 1973, nOut: 360\n",
+      "$H \\rightarrow ZZ \\rightarrow \\ell\\ell\\ell\\ell$:\n",
+      "Input/MC/skim.mc_160155.ggH125_ZZ4lep.root\n",
+      "\tProcessing: ggH125_ZZ4lep\n",
+      "cut_lep_etcone20: (10105, 11)\n",
+      "cut_lep_d0: (9943, 11)\n",
+      "cut_deltaR: (9871, 11)\n",
+      "cut_n_lep: (9819, 11)\n",
+      "cut_lep_charge: (9697, 11)\n",
+      "cut_lep_type: (9583, 11)\n",
+      "cut_lep_pt: (9044, 11)\n",
+      "cut_lep_pt_min: (7903, 11)\n",
+      "cut_mZ1: (7436, 13)\n",
+      "cut_mZ2: (6087, 13)\n",
+      "\t\tTime taken: 6.121289968490601, nIn: 21783, nOut: 6087\n",
+      "Input/MC/skim.mc_160205.VBFH125_ZZ4lep.root\n",
+      "\tProcessing: VBFH125_ZZ4lep\n",
+      "cut_lep_etcone20: (10079, 11)\n",
+      "cut_lep_d0: (9897, 11)\n",
+      "cut_deltaR: (9798, 11)\n",
+      "cut_n_lep: (9726, 11)\n",
+      "cut_lep_charge: (9563, 11)\n",
+      "cut_lep_type: (9385, 11)\n",
+      "cut_lep_pt: (8929, 11)\n",
+      "cut_lep_pt_min: (7850, 11)\n",
+      "cut_mZ1: (7230, 13)\n",
+      "cut_mZ2: (5877, 13)\n",
+      "\t\tTime taken: 5.549008131027222, nIn: 20954, nOut: 5877\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/gohil/.local/lib/python3.7/site-packages/sklearn/ensemble/forest.py:245: FutureWarning: The default value of n_estimators will change from 10 in version 0.20 to 100 in 0.22.\n",
+      "  \"10 in version 0.20 to 100 in 0.22.\", FutureWarning)\n",
+      "/Users/gohil/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:102: FutureWarning: `Series.plot()` should not be called with positional arguments, only keyword arguments. The order of positional arguments will change in the future. Use `Series.plot(kind='bar')` instead of `Series.plot('bar',)`.\n",
+      "WARNING: Logging before flag parsing goes to stderr.\n",
+      "W0723 22:11:49.960590 4712277440 deprecation.py:506] From /Users/gohil/.local/lib/python3.7/site-packages/tensorflow/python/ops/init_ops.py:1251: calling VarianceScaling.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
+      "W0723 22:11:50.110382 4712277440 deprecation.py:323] From /Users/gohil/.local/lib/python3.7/site-packages/tensorflow/python/ops/nn_impl.py:180: add_dispatch_support.<locals>.wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n",
+      "W0723 22:11:50.147475 4712277440 callbacks.py:875] `period` argument is deprecated. Please use `save_freq` to specify the frequency in number of samples seen.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"sequential\"\n",
+      "_________________________________________________________________\n",
+      "Layer (type)                 Output Shape              Param #   \n",
+      "=================================================================\n",
+      "dense (Dense)                (None, 5)                 25        \n",
+      "_________________________________________________________________\n",
+      "dropout (Dropout)            (None, 5)                 0         \n",
+      "_________________________________________________________________\n",
+      "dense_1 (Dense)              (None, 3)                 18        \n",
+      "_________________________________________________________________\n",
+      "dense_2 (Dense)              (None, 1)                 4         \n",
+      "=================================================================\n",
+      "Total params: 47\n",
+      "Trainable params: 47\n",
+      "Non-trainable params: 0\n",
+      "_________________________________________________________________\n",
+      "Training model\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "W0723 22:12:33.519140 4712277440 callbacks.py:875] `period` argument is deprecated. Please use `save_freq` to specify the frequency in number of samples seen.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "signifiance for 120<mllll<130 = 0.36980228867737114\n",
+      "Time taken: 61.03127574920654\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 576x216 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZkAAAEHCAYAAAB8yTv9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO2de3hU5bXwf2uSwQQ1CWKQcCugFgRRQaRaPNbqV1ARC61HUXtqrf1sK6cFzilValWsx6ql5wAe9VSPt95UrAolpS1alfqJF8pNEYWCgC1JMBFJ0JJoklnfH3tPmJnsud/D+j1Pnsy8+5291+xM3jXr8q4lqophGIZhZANfvgUwDMMwei6mZAzDMIysYUrGMAzDyBqmZAzDMIysYUrGMAzDyBql+RYgkxx99NE6dOjQfIthGIZRVKxbt+59Va3Oxrl7lJIZOnQoa9euzbcYhmEYRYWIvJutc5u7zDAMw8gapmQMwzCMrGFKxjAMw8gapmQMwzCMrGFKxjAMw8gapmQMwzCMrJEzJSMig0XkBRF5S0Q2i8gsd3yBiGwRkTdEZKmIVIW8Zp6IbBeRrSIyOVeyGoZhGJkhl5ZMB/DvqjoKOB2YKSKjgGeBE1X1JOCvwDwA99gMYDRwHnCviJTkUF7DMAwjTXK2GVNVG4AG9/GHIvI2MFBVnwmZ9ipwsfv4i8DjqvoxsFNEtgMTgFdyJXMitNTW0rhwER0NDZTW1NBvzmwqp06NOn/FqhtZvGMpe3zQPwCzhk9nytm35lDi+CzbUMeClVupb25lQFU5cyePYNrYgfkWyzCMIiQvO/5FZCgwFngt4tDXgSXu44E4SifIbncs8lzXANcADBkyJMOSxqaltpaGG29C29oA6Kivp+HGmwA8Fc2KVTcyf+dS2koEgIYSmL9zKUDBKJplG+qY9/QmWts7AahrbmXe05sATNEYhpE0OQ/8i8gRwFPAbFXdHzJ+A45L7dfJnE9V71fV8ao6vro6K6V3otK4cFGXgumSp62NxoWLPOcv3rGUNp+EjbX5hMU7lmZNxmRZsHJrl4IJ0treyYKVW/MkkWEYxUxOLRkR8eMomF+r6tMh418DLgTO1YP9oOuAwSEvH+SOFQwdDQ1Jje+JotKjjeeD+ubWpMYNwzBikcvsMgEeBN5W1f8KGT8P+D5wkaoeCHnJcmCGiBwmIsOA44E1uZI3EUprapIa7x/wPk+08XwwoKo8qXHDMIxY5PI79ETgX4BzRGSj+3MBcDdwJPCsO/YzAFXdDDwBvAX8EZipqp1Rzp0X+s2ZjZSVhY1JWRn95sz2nD9r+HTKAho2VhZQZg2fnjUZk2Xu5BGU+8OT+Mr9JcydPCJPEhmGUczkMrvsJUA8Dv0+xmtuA27LmlBpEgzuJ5pdFgzuF3J2WTC4b9llhmFkAjkYAil+xo8fr9ZPxjAMIzlEZJ2qjs/GuQso5GwYhmH0NEzJGIZhGFnDlIxhGIaRNUzJGIZhGFnDlIxhGIaRNUzJGIZhGFnDlIxhGIaRNUzJGIZhGFnDlIxhGIaRNUzJGIZhGFnDlIxhGIaRNUzJGIZhGFkjL+2Xi42W2tquSsvtfcp57LOtrDjRV5BVlA91lm2oswrShlFAmJKJQ0ttLQ033tTVZtn/wQEu+SPs8wVYPbqE+Tud1smmaPLPsg11zHt6U1f76LrmVuY9vQnAFI1h5Alzl8WhceGiLgUTpKwDLl/ltEho8wmLdyzNh2hGBAtWbu1SMEFa2ztZsHJrniQyDMOUTBw6Gho8x/vuP/h4j93FgqC+uTWpccMwsk/OlkcRGSwiL4jIWyKyWURmueNHicizIrLN/d3HHRcRuUtEtovIGyIyLleyhlJaU+M5vrfi4OP+gRwJY8RkQFV5UuOGYWSfXH4H7wD+XVVHAacDM0VkFHA98JyqHg885z4HOB843v25BvifHMraRb85s5GysrCxtlJ49Gynk3RZQJk1fHo+RDMimDt5BOX+krCxcn8JcyePyJNEhmHkLPCvqg1Ag/v4QxF5GxgIfBE42532c2AVcJ07/gt1+kO/KiJVIlLjnidnVE6dChCWXfbEZ1t5eZSPmk617LICIhjct+wywygcxFnDc3xRkaHAi8CJwN9UtcodF2CfqlaJyO+AO1T1JffYc8B1qro24lzX4Fg6DBky5NR33303Z+/DMAyjJyAi61R1fDbOnfOQtYgcATwFzFbV/aHHXKslKa2nqver6nhVHV9dXZ1BSQ3DMIx0yamSERE/joL5tao+7Q6/JyI17vEaoNEdrwMGh7x8kDtmGIZhFAm5zC4T4EHgbVX9r5BDy4Er3cdXAr8NGf+qm2V2OtCS63iMYRiGkR653PE/EfgXYJOIbHTHfgDcATwhIlcD7wKXuMd+D1wAbAcOAFflUFbDMAwjA+Qyu+wlQKIcPtdjvgIzsyqUYRiGkVVsr7phGIaRNUzJGIZhGFnDlIxhGIaRNUzJGIZhGFnDlIxhGIaRNUzJGIZhGFnDlIxhGIaRNUzJGIZhGFnDlIxhGIaRNUzJGIZhGFnDlIxhGIaRNUzJGIZhGFnDlIxhGIaRNUzJGIZhGFnDlIxhGIaRNUzJGIZhGFnDlIxhGIaRNXKmZETkIRFpFJE3Q8ZOEZFXRWSjiKwVkQnuuIjIXSKyXUTeEJFxuZLTMAzDyBy5tGQeAc6LGPsJcIuqngLc5D4HOB843v25BvifHMloGIZhZJCcKRlVfRH4IHIYqHAfVwL17uMvAr9Qh1eBKhGpyY2khmEYRqYozfP1ZwMrReSnOArvs+74QODvIfN2u2MNkScQkWtwrB2GDBmSVWENwzCM5Mh34P/bwBxVHQzMAR5M9gSqer+qjlfV8dXV1RkX0DAMw0idfCuZK4Gn3ce/ASa4j+uAwSHzBrljhmEYRhGRbyVTD3zOfXwOsM19vBz4qptldjrQoqrdXGWGYRhGYZOzmIyIPAacDRwtIruBm4H/CywWkVKgDTe2AvweuADYDhwArsqVnIZhGEbmyJmSUdXLohw61WOuAjOzK5FhGIaRbfLtLjMMwzB6MKZkDMMwjKxhSsYwDMPIGvnejFnUtNTW0rhwER0NDZTW1NBvzmwqp04FYMWqG1m8Yyl7fNA/ALOGT2fK2bemdb1lG+pYsHIr9c2tDKgqZ+7kEUwbOzATb8UwDCMrmJJJkZbaWhpuvAltawOgo76ehhtvAuClI9cwf+dS2koEgIYSmL9zKUDKimbZhjrmPb2J1vZOAOqaW5n39CYAUzSGYRQs5i5LkcaFi7oUTBBta6Nx4SIW71hKm0/CjrX5hMU7lqZ8vQUrt3YpmCCt7Z0sWLk15XMahmFkG1MyKdLR4L03tKOhgT1R7mq08USob25NatwwDKMQMCWTIqU13kWhS2tq6B/wfk208UQYUFWe1LhhGEYhYEomRfrNmY2UlYWNSVkZ/ebMZtbw6ZQFNOxYWUCZNXx6ytebO3kE5f6SsLFyfwlzJ49I+ZyGYRjZxgL/KRLMIvPKLpuCcyyT2WXB4L5llxmGUUyIU8GlZzB+/Hhdu3ZtvsUwDMMoKkRknaqOz8a5zZJJgFzvh/HC9sgYhlGMmJKJQ673w3hhe2QMwyhWLPAfh1zvh/HC9sgYhlGsmJKJQ673w3hhe2QMwyhWTMnEIdf7YbywPTKGYRQrcZWMiByVwE9VAud5SEQaReTNiPHviMgWEdksIj8JGZ8nIttFZKuITE7t7aVPrvfDeGF7ZAzDKFYSCfzXuz8SY04JMCTOeR4B7gZ+ERwQkc8DXwROVtWPRaSfOz4KmAGMBgYAfxKRT6tqZ7ezZplc74fxwvbIGIZRrMTdJyMiG1R1bLpz3HlDgd+p6onu8yeA+1X1TxHz5gGo6u3u85XAfFV9Jdb5bZ+MYRhG8mRzn0wiMZkzMjTHi08D/yQir4nIn0XkNHd8IPD3kHm73THDMAyjiEhEyfyniJwZa4KqtsU6HoNS4CjgdGAu8ISIxHLLdUNErhGRtSKytqmpKUUxDMMwjGyQiJL5K7BARHaJyE9EJK5bLAl2A0+rwxogABwN1AGDQ+YNcse6oar3q+p4VR1fXV2dQdEMwzCMdImrZFR1saqeAXwO2As85GaD3Swin07z+suAzwO45+oFvA8sB2aIyGEiMgw4HliT5rUMwzCMHJPwPhlVfVdV73QD/JcB04C3E329iDwGvAKMEJHdInI18BAw3E1rfhy40rVqNgNPAG8BfwRm5iOzzDAMw0iPhGuXiUgpcD5OavG5wCpgfqKvV9XLohz6SpT5twG3JXp+wzAMo/CIq2RE5As4lssFOC6rx4FrVPUfWZbNMAzDKHISsWTmAY8C/66q+7Isj2EYhtGDiKtkVPUcAHH4CjBcVX8kIkOA/m5WmGEYhmF0I5kCmffibLoMxlY+BO7JuESGYRhGjyGZpmWfUdVxIrIBQFX3iUivLMllGIZh9ACSsWTaRaQEUAARqcbZPGkYhmEYniSjZO4ClgL9ROQ24CXgx1mRyjAMw+gRJOwuU9Vfi8g6nD0yAkxT1YQ3YxqGYRiHHsnEZFDVLcCWLMliGIZh9DAS2Yz5RWCQqt7jPn8NCFaivE5Vf5NF+YqGltrabo3NXjpyTVoNzZZtqLNGZYZhFDWJWDLfxyklE+Qw4DTgcOBh4JBXMi21tTTceBPa5nQ86KivZ/cN81g5KUDDGKdtckMJzN+5FCAhRbNsQx3znt5Ea7tTsq2uuZV5T28CMEVjGEbRkEjgv5eqhjYQe0lV96rq33AUTY+npbaWbeecy9snjGLbOefSUlsbdrxx4aIuBRPE90knF78Y3nW0zScs3rGUFatuZNJDJ3LSIycy6aETWbHqxm7XXLBya5eCCdLa3smClVsz9K4MwzCyTyKWTJ/QJ6r6ryFPe3wDFy8rpeHGmwConDrVGWto8Hxt3/3dxxp8jkXTVuL0Zotm4dQ1t3qeM9q4YRhGIZKIJfOaiPzfyEER+SaHQI8XLytF29poXLio63lpTY3na/dWdB/z4Vg0oQQtnFBKojQIjTZuGIZRiCRiycwBlonI5cB6d+xUnNjMtGwJVihEs1JCx/vNmR1m7QAEepXw5Fnhe1XLAkpbFB2xJ0Ldd6p6zos2bhiGUYgk0hmzUVU/C9wK7HJ/fqSqZ6jqe9kVL/9Es1JCxyunTqXm1h9ROmAAiFA6YACDbrudyRd+mZpORVSp6VTmD5tOTZQaCf0jxgdWlXvOizZuGIZRiCSzGfN54PksylKQeFkpUlbGEZ87i23nnEt7fT37KuBXnxPe+YqPWcO/3BVbmcJUz0yy+TuXhrnMygLKrOHTgYNpy3XNrQhuDR+Xcn8JcyePyMr7NAzDyAZxLRkRWZ+hOQ+JSKPbajny2L+LiIrI0e5zEZG7RGS7iLwhIuPinT9beFkpldOn0bJ0GR319Qhw1H645g/K8C0B5u9c6pktFmTK2bc6Fk2EhTPl7Fu70paDwX3FKa0AjgVz+5fGWPqyYRhFhWgcH7+ItALbYk0BKlV1SJzznAV8BPxCVU8MGR8MPACMBE5V1fdF5ALgOzjdOD8DLFbVz8R7M+PHj9e1a9fGm5Y22845l476+m7jTRUwc2YpNZ3KM1/vpkvjMvGO5z2zxwZWlbP6+nNSktUwDCMeIrJOVcdn49yJuMtGJjCnM94EVX1RRIZ6HFqIs+HztyFjX8RRRgq8KiJVIlKjqt5R+BwTL2V5j8+7AkAw5Tkag/Rhyo5bT1OpUN2h9G0ax5qWGdQ1t7JsQ51ZMYZhFB2JdMZ8N1sXd0vW1Knq6xKemjsQCN0Autsd67a6i8g1wDUAQ4bENKYyRmlNjaclE0xZnvJmgIY/xd5bE8mKVTeyo/962nyOB7PRL+zvv54JwJqWGbbb3zCMoiSZUv8ZRUR6Az8AbkrnPKp6v6qOV9Xx1dW52Rvab85spKwsbKytFB49WygLKJe9XB53b00ki3cs7VIwXef0+dhb7YS7bLe/YRjFSFJVmDPMscAwIGjFDALWi8gEoA4YHDJ3kDtWEAStkcaFi8Kyy3aM9DF/2HT8+57yfF00Nxt03ycTpKn0oIVXn+Xd/tFcfCtW3ZhWoc9cYkVFDaOwSErJiMiZwMnAH1R1hzs2TFV3JnthVd0E9As59y5gvBv4Xw78q4g8jhP4bymUeEyQyqlTw1xfE0OObat52dOdFm3PDTiLd0NJ9/HqDiVYnWZAFvfIRCufs+GtJ5nfb13cMjiFgBUVNYzCI1l3WTUwAbhZRP5LRMYDdybyQhF5DHgFGCEiu0Xk6hjTfw/sALYD/wtcm6ScOSe0iGbngQOI3x92PNCrhIfGNUQtijlr+HTKAuGZfmWBAH2bnOztbO+RiVY+x//UGs8yOIveWcrEO55n2PUrmHjH8yzbkH9D04qKGkbhkWzTsqWulXEqcCLwT0BC3TFV9bI4x4eGPFZgZjKyZYNEM8QirQBtbobSUkqqquhsaaG9TzkPfLaVF+KU/S9Tpc3VMxUBZUTzBF5ouZiBOXD7RHPlVXkU+QR4rwT2u+67QrEYorkTs+1m7EmYu9HINOm4yx5yx4ZlQ7B80lJbS8PN89EDB7rGOurrqb9+HnVzvw9AQGD1yTDoWxfz6YUvd7MC6Ojgk5ZmRKG54wCfRLEGnlq/m01VrrVQctCw/ETgy+MGcVHlKSx/4Yf897o13PR6eGpzVbmf+ReNTmkRiFSgJZWVdDY3d5vX7FHkE8LdeHDQYsjEghS50F167O/43YfPxIwJLdtQh0/Es7ZbOm7GeF80CiVelQnlYO5GIxvE3YwZNllkOgeLYu4FHgW+r6qXZEG2pMnEZsyW2loafnAD2t4ed64CbX4oaz+4Mz8abaVw3wXC6tEhgRdVSlXp8Hl7LX2qdJU0k9AyNAGG7XEUDcBXTh/Cf0wbAyS22ERaXgCUliIiYe9bysrYc9lJzO23LqIMTvj1u+YDO++YEudOxCZyoZtQ+Tg7Q1K7nesfrJLg9ZpQyv0lKVdK8LpPUlZGza0/6kqI8CoRFCpbLvB6/6m8b9sMfOiSzc2YSSkZV5gSDrrLKoEqVb05C7IlTSaUzF9PP8PzG30sQsu/xCJYEeDgCzVMeSRDv/YA72z/Sdfziccexeb6D2luDVeO5f4SvnzqQH73ekPXsZ8/cxv9Duzrds6OI46krOLImNllx3TCUU1jea15RrfXV5X72XjzpJTez6o7r8T/1Bqq9sO+Cnjh5GE82Hcmxx73fRr93ZVwaFWFU255ptv7Bqctwn9ecnLK38KjVXYoHTCA459/jkkPnUhDSfe/X6oVH1IlU8ph2PUr8FoNMvHlIduYmy898r3jP1SQHu0ua6mtTVrBQGIKBuDo/fDYHR341FFMH/vhsHZnE+ejZ0dYOXFoLBUqRl7X5T5b/U73RR8cN9avXv1buBweCgbA99GHXHLRf3Dz1IMuuGUb6ljw6uepbz6dynI/uz7pYFun9xeT5tZ2Jt7xfML/4MGF4fx3fsqFr+zksA5nvO9+mPrKTjjjHn4z0vvuBlO+l22o81QwAAHVtBaaeG0eoqWdh8qWi4UvU7GoAVXlnsoqm1mNmcDcfIVNsvtkgtllE0Sky10GFIS7LF0abvtx1q9R4q7PApS7a2P1fvjucuWqZzpYPQrGb3cW2kjlM3FzJ5ev0m7H9vXfwMB+6/mwJDxmM6HycfZWHyxTU/NRFQ1HNLO3wrlmJE3lVew70M7sJRuZvWQjvf0+DrQf7EEQbTEPpa65ldlLNvLoH68Pu/aAfafx0t5/7lpsga6F4ezXDyqYIId1wOdf38mqz/ho9HdXNNUd2rWIR2NAVXlaC320yg7BVPRYaedDr18RVkU7eF9uqd0cpsQzQaaUw9zJIzzdbslkNebDooiVVWhKJv/kLLusGNAUrJhkiGXxCFDRBuetPzgvqHyu+UMHq8bA59+Aso7wY1c928HDXzioiILlaM4s38HWyuawMjWNVS0gPtYeFwi7DkBbiZ//N74Pxx73/bDaaUCYsggqsFhExlEa/cL+o//CaR2drGl2SuQISqurwPpEyWDrsx/6No1jX/8NtIfEPfwBR47gYhaNz4+sZu6Tr9PuWl51za3MffJ1ILFvuNHaPPSbMxuAC4+cxC8/WhkRL3LSzt8BT9fTvgPt3b5lx1uY4x3PhHIIlSdVJZEviyJaS3LLKiwMkg38Z2wzZjZIJybTUltLvZs5VojEivuEJhVEs3aCTNzcyTd/r13KCiAAPDsWfj7JF5aE4A8oZ2zu5NIXD1pWT54Fe/qO91Q0QcupsVQ8Y02VnQF2//Un3ebffH/A07LaWwF3TR/Ptv7rw+QqDQQ4fs84/tIyg8pyv6eF1atEaA8oXh/vw3uV4C/xdb2uT29/dxeh29PnnN3r+erm39OvtZmOo/vxqeu+R+XUqSzbUMfcJ19n7BGPJa2Eg9fs3avUs2+Q3yccUVZK84F2qnr7+aitg/aQPVR+n9Cr1Mc/PnEW86pyPxeeXMMLW5ryGpPIR+LAsg11zFmy0VOhW8JC4hRM4L8nZ5e9PXYctBbvN58mV6FEKpDIrLZ77unwXNA7Be6e6iiGoJL6qAx6fwylIR+RTwR+fgHsPnp8N1dcqOXkiSonNIztcuUFrR0vxfdxKdSeMYxVn3nXM/Dfrz3ArncWZLQddXCxXvKXv3dZP6H4fcKCf3YSCcb+6Bn2HYjvPswVobKl47JK57X5SByIptgEWHjpKeYuS5C8Bv5F5FzgDVVt6tHusiJWMOBYGlc9G75Qg+Neu3yVsnr0wXlelCh8u1YRH/hdr0tFW/d5vRQufQ6+MXsDSHdXXExE2FKzgYqaDWwFAiHzP/HTFZf5qAxWnuZkl1WUXud5qqZS4dSK1KyIaDS3tndLkgilPaDMXrKRBSu3FpSCAUe2YHwqVZdVuu6uVGJD6cZwornENEGZjeyTSNOyANCI41V5E9gEvOH+3qyqH2dbyERJy5IZeUKGpcktwb+il0steOz9Cjj8APTu8JiU5LXer/BOTkiWaFbMfecLfx0hfOyDlpLuyquiI0CrT7rFao7bM7aboolMgEhXGRUqQvSFHohbOSIVd1eokqgs9/OPTzrCrMBY+3Uysb8nXZkt3dkh3ynM3wGuBp4AXgZG4FgyXwNOAPpnQzAjOeIlFYCTLJAp51LQ5Va9H775ewU6U1I0l6/qbn0d1gEzf6f4apWAgGggTJmVBQK0+whTMOA8rz9mPYQoEM8khJA+PclSyAprQFV5zGB3PMsk2VToSCXR3NqO3yf06e2n+UB73AU8Xq25RBRBskkPlu6cexJpWnaPiDwEfBdYBNwFzNJkd3EaBUFqWz9jnyPSJZcMsdx3ob+7lJl2snp0dLdci0849rjvdy3+e6vXR+/Tk6RyyLTCyiR+nzB38oiuhIVoxFrEk3V3eSmJ9oDSu1cpG26Kvyk3mvKqa25l7m9e70p2CD4H74y8ynI/ZX5fTMUWmswRiaU7Z5eEUphVtRW4U0R+BswF1ojIv6rqa1mVzigaoimLeETbs+NFWQdc/mdl9YkH1Vy0bLrg4r+l1FutNkUZjylrmgorm1ZQpypr3/2Az4+sjhlXgoPf3iO/zX/51IE8ta4uYasg3U2gsVx77REVydsDyvzlm7sSGyItqHJ/SdRAf6yyQ0FiKebIc5mrLTnilvoXkbNE5BoR+S/gceB84B9A32wLZxQPmqKJ9OjZQlsSu7VClVkwnlO93/kgB62diZs7uxb/6g5vgzvaeCyiKaZEFFbQCmr0+1ARGv0+dvZfz4TKx5OWA6B3RMZdQOFXr/4troIBp9yOl5vqhS1N3P6lMQysKkdw4hqx4iOV5f6kxiOZO3kE5f7EXazBihLzl29OqqWDl8UViUDcdhVBZVXX3IpyUDkXQpuLQiaRf+9VwEYcBXOXqu7KpkBGceJL0XnqxHEOWiMqB11kXuwNqQrtFc8Jdd01lQojG8ayv1uBzYMbJpOhukOjVh+IZ4xl0m0HdG1kTZZyf0nUBbe+uZVpYwcm/M08Wtm9RMvxRW7+jFZFO5RYFkc6lpW6csR671ZZIDUSaVr2bWA1MAV4TUTeEpElIvJDEZkW57XGIcL7UVoCJMLq0SXMvLaEGdeXcPfU6JZNW6lj+QSJ5qILjld3KGtaZjBszzj6tQcQVfq1e1eQToS+TeMoC0Qs7ursEYpHOlaQF6no9BKRLkvFi2TL0DRHSeOONu7FtLEDWX39Oey8YwqBNMO80eRP9H3FU0bWryg1Egn83xf6XEQGAWOAk4AvA8uyI5pRLCjhi3/KiIRZNkfvx80u806VjhbP2VsRbq2saZkBIbXcttRs4Njq9UnHRNa0zODM8h28XtVy8Ou6CFsrm5nQ+njMc6VjBWWCyNTgTJShyXRBzVgxmnjEkt8rAy3a9VORLxsFRENjP1W9/ahCS2v8jL1CJNn2y6jqblX9g6reqar/kujrROQhEWkUkTdDxhaIyBYReUNElopIVcixeSKyXUS2isjkZOU0vMl0SmAA+OM4Ut4n48Xq0SXMnFnKpfNKuez6UmbMK2XmzNJu1/CK57SVwooz6WatZCom0nBEczd/UJfbKwZeVlBoe+1sUlXuD1Mw08YO5PYvjaEqJHZS5lFVIR5eMZV02oQnE6Pp09ufcOwo+H6D86vK/fgjWjQkInem3280ImM/+w6009zaXrRxoGSrMKfDI8DdwC9Cxp4F5qlqh4jcCcwDrhORUcAMYDQwAPiTiHxaVWN/FTHSJtHeOMENmelsxDx4stRU38ujfPQOdDLtRaeNQsvhvbhv5JdZ1etUaAmfm6mYSKpurzUtM5hA8sVGvSj3l3BYqS9uVWwBrghpaBfJxx0HlZ5X4c54ZKKgZuRrb//SmLCxz4+s9sx4S7aSdWSsKZUssVjvN5NZZ/ESFSLjQIWe8ZZ007K0LiYyFPidqp7ocWw6cLGqXiEi8wBU9Xb32Epgvqq+Euv8h/KO/0SIVxXg/QpYexxM2hA7+O7Z5TNJPFOPR/nCrYSQz2YJ0BmjO2g8KkZeh3pFpFXp16EJL/zRmqhFNpHLJMFimqGLCHR3efl9gr9EutozRBb+DCWbxSwTWfSS2e1f6ItopjqTBolWAwT2QVAAACAASURBVC6UYD24TF073zv+c8XXgSXu44HAqyHHdrtj3RCRa4BrAIYMGZJN+YoeFdh7pHcc4/2Qrp2T13vXncmU9RJZSuZg1YAAr4zyodBtwU9nj8mEysfZSnRXYVBpJLK5sm/TuIxlqyVCvG/tXt/6g8SyTrIVxE50R30ymVrJZLzlg0xnnSUSmwrGgYoh460glIyI3AB0AL9O9rWqej9wPziWTIZFKyoU+LAMjmzztlZEo1dqDg3cRwuohyqi2ILEbisdK/X45VGwf8ud7IewRTsYvAe6HYtFMBYT8Cre6SFnPBdaom4vv0+4dMLgbq6eZIkXawg9NvGO5xNecKK1SEh0j0s0El30elKmVqbfS7xEhdA4UDHcx7wrGRH5GnAhcG5IqZo6YHDItEHumBGHb8wp5YGFHZ4VlN+v6L4vxStrK64iiqNEoh5z/7yxUo8znW3lFYsB8KkSbadJIvGVWAqvqtzP/Isc62P8p44KszaaD3zS1QcmHlXl/oxUJPYaT3ePS7oyFGurZy8y/V4iYz+xssuK4T7mVcmIyHk47Zs/p6oHQg4tBx51qwwMAI4H1uRBxKLiwzLn98OTYiuJ1aNLYtYZi0wjbjnCx7KzArw8yke/9kBXG+dozcmi0c/dZR/NUvqggoy7naIpDAVqYrRPTkXRecUzvALOiaTTQvILfjILTib2uKQjQ6a6eRYC2XgviboIi+E+5kzJiMhjwNnA0SKyG7gZJ5vsMOBZcf6jXlXVb6nqZhF5AngLx40281DOLEsk4+sTcZQLJGatxL6g8vIoH9s+HeEK2hL+zT2yYGQsgnGLLTUbolpKq04elvFCk9H2p/QPwKzh05m/cyltvtCEAuWzJZ9LSdEl4qLwylCK5n9PdsFPZsHJ1jfgRGVINzOtkMjneymG+5jT7LJscyhll30i0FYGR7Sm39MlSDDj6+j90FhexSOjzufAidu6dcBsOKI57PmmqhYCHl+7fardgvjB7KzI7LIVZ8KSXj9NS34vvBRhWUCZP2w6U86+lRWrbmTxjqXs8TmK58IjJ7Fw3blRkwSCu+UzmZmVyUyvRDOxMp0RFcoPl23isdf+TqcqJSJc9pnBUdOojcKgYNovFzppKZkTRqW8XyOXxM3wCr6HKOm60XwwXs3DPinx8eD5AV4YE2LwRpyjLBBgREv31svRUoy9F/3US70kQmhmWtCCmXL2rZ5zoy34QRZdegrgvWM+coEuhAU/FtlIDc7XezHS41BJYc4vRaBgwFEyMTO8RGIGtb1Pqp4ZX706A1z8IrwQ+iXUIxur4Yhmhu0Zl1CKcSY3JXaJROxKBn9pmYG2zGBgVTnXTh7BlBiLXSyXV2QgPtYCnUxzrHy5PLKRGlwMKbVGbjElU2SEViGOZpkEcKyDSGuhVwD2ewTC+3Vo3GKTsWgqFd5JIsU41XTkSOK1Gw7SlbLY3MrsJRuZv3xzV/ZXJNHOJ8D8iw5mS8RboJNdbAt9L0iiFENKrZFbki9Y1EMpqYpfSTffRKYR94piffXrUM/KwwMbo9fPair3fv97E6iunEpvlnQZWFXOzjumsPr6c6JWFY5Gc2t71PpPXvWpguVZspVO3JNItxKy0fMwS8blmBt+QP3c7+fkWsEluc0P7SVwhLt5MloGmQIflsPDXwiJwyicECUWEq3oYixXVe9R65j9+mMcFmOTpnPd7jGZVNOOJx57FG81fMi+iCyqcn8J44ZU8uqOfZ79RSKzleZOHhHWrjcRYu0uh/RdV8WwfyEbFENKbTTa29vZvXs3bW0em8x6CGVlZQwaNAi/P71Nt8lggf8QcpFhFnq3Pyxz0o5Xjy5h4uZO/rVWPWuGBQT+e2r3QH+/dmeBj1QagGdw/aKXP8U/rd1HdWsz+w/vxbLPfcIfTirpel3fD9Zx2Z890p5VEfDMLvOKp8SLkQTZdccUoHsA2qsoYpBo9biWbahj/vLNXbvY+7gb2GIVkQzWf8oGh3IAvNBrjUVj586dHHnkkfTt2xdJd1dqAaKq7N27lw8//JBhw4aFHbPAfw5oqa3NyXVCP7oVbfDd5cp3lnewtyJ6d0mfBmt7dYYpmmixkGOP+363vSunvq1MfWVnl6VS9Y9PmPEMtJQGWD26hP3911PXT3jpxO4Za/06lHe2/6Rb/GQ/sLfcz6JLR3dTEkvW/D2mZRFaZj6R8ihB2qJ0hPSKacTb+JhNq6IY9i9ki2KNL7W1tTF06NAeqWAARIS+ffvS1NSU0+uaknF577Yf5+W6QTdZ9X4nYB/t4x3aVjhIRSB8Z3owVbfRI7h/+SoNc4VFnrPN56NN1NMdduxHp/NBb383t5bfJ10B9MhFZfynjgqzLCJp7+yuLILfgGMF8pPJVArOuaV2s6dLLtsunGJdbA9leqqCCZKP92eBf5fO5uZ8i4CP2G6myEyv/T7paroV2pTLK+MsoewxccvEqKNsggkDz733ZTbcNIlFl54S1ijq0gmDWbByK8OuX8HEO54PC6RPGzuQjTdPivpeIut3hTZqikddc2vCTZumjR3oKfuh4LYyjELALJkCIxjP8Pq+EZnppSJOd0eiF4IM8kGF09gr3jkdIaSrP4rjHnNUX+g380T2gSTTvS9eo6ZIUmmwZUrFKHSOOOIIPvroo5Ree/fdd7No0SLeeecdmpqaOProozMsXWqYJZMjnIhKYngFzj0zvThYmj5q5WDXIll18jDaSsIzSqKdE8ILS3rNiLUPBA4qoWhURZSUTza1N/RahpEPlm2oY+Idz3ta8vlg4sSJ/OlPf+JTn/pUXuWIxJSMS7b3yQjx3WGR83Hn7y+L3YkymOnlRTBo/2DfmSw+5WLeK68iADQf3ovHJ+F0o/Qg9Hw+n3T7B4q3DySWZRKM5YQSLQgfy4Xc0/ecGIVLqHtXOWjJZ1LRLFiwgNNOO42TTjqJm2++GYBdu3YxcuRIrrjiCk444QQuvvhiDhxwCtiPHTuWoUOHZuz6mcKUjMsxN/wg69cIBvmTSRoX4ONexCx+GUwljrbRMsiqwafytck/ZMq0n3LZF37Mkl4/ZfSe+K/rDGg3qyGaUvCJMOz6FTFjKwv++eRuriuvTZAQu9pPT99zYhQu8Sz5dHnmmWfYtm0ba9asYePGjaxbt44XX3wRgK1bt3Lttdfy9ttvU1FRwb333puRa2YLUzIulVOn5uxagpNJFgD2lzsVlWMRs7SLKo2lwt7q9Yxoqeq2yz9eTbBXmy/1rA4Q+bq65tYwt0A0pdDpVl6OxsCq8qhlVW7/0piu4HxJnCyYYtngZ/RMsl3R4ZlnnuGZZ55h7NixjBs3ji1btrBt2zYABg8ezMSJEwH4yle+wksvvZSRa2YLC/znCQEunefc/ombO7nqGY3aNtkzOB9RbbnRL+yvdApVvtMyI6maYInWEgt1C9z+pTHc/qUxXftAfCKeu/NDiacYQoPzw65fEXXewENoz4lRmGS7ooOqMm/ePL75zW+Gje/atatbGnKhp12bJeOSq82YXqweXcLHvbwVjAKPfi78SFkgQEVnjP70WSZ0r8rq689h5x1TCMRQMKmkDUf7Zw32WDEFY+QTL0s+k9b15MmTeeihh7oyzerq6mhsbATgb3/7G6+88goAjz76KGeeeWZGrpktTMm4NC5clNPrfRixhsZyiX00sE83d9aHJfGzwrKJV892L4KFLOdOHhF1T40X2f4nNox0iHTvZnrv1aRJk7j88ss544wzGDNmDBdffDEffvghACNGjOCee+7hhBNOYN++fXz7298G4K677mLQoEHs3r2bk046iW984xsZkSVdcla7TEQeAi4EGlX1RHfsKGAJMBTYBVyiqvvEsf8WAxcAB4CvqWrcr+jF0rSsvQTunRKeLXbPPR2efe/fK6/ia5N/2G082GEykuD+lkxQ7i/hsFKf5679yK6NsWp1QWJNviIp1hpYRnHy9ttvc8IJhd0hd9euXVx44YW8+eabKZ/D631ms3ZZLi2ZR4DzIsauB55T1eOB59znAOcDx7s/1wD/k23hSmtqsn0JFGiq6K5gwNmv0hYRIWsr8fPIqPM9z5VINlk6BL+Zzb9odEIWRaxvdqlm4oS648xFZhjFSc4C/6r6oogMjRj+InC2+/jnwCrgOnf8F+qYWa+KSJWI1KhqQ7bk6zdndsZK/av7E6rB20pj73Vxxp2+90fvh8byKh4ZdT6rBp/qOT8bHSZjWReJWBTRdtUfqr1VDCPTDB06NC0rJh/kO7vsmBDFsQc4xn08EPh7yLzd7lg3JSMi1+BYOwwZMiRlQSqnTqX+BzdAe/TS8ImiwH9fJFy+yqNsfgxWjy5h9WgQVfZv6e4iC9Lb76PP4Yexpjm1DpPBEvfLNtSx/IUf8m7FGppKhWM6wd8yHbg1bH66JVmiZeIoTsVlc4MZRs+lYAL/rtWSdFBEVe9X1fGqOr66ujotGaou/nJar++SSRyFMXNmKTPmlTJzZmlcBRNKvE6TB9oDfH5ktec+lVCi7TUJBun9LT9jU5+/0Oj3oSLsKRXm71zKilU3JixrIkTbUwPZ2SltGEbhkG8l856I1AC4vxvd8TpgcMi8Qe5YVvnozy9m5Dw+hcdv7+CeezqYuNmjtEqMBINE4yor3mjoioFA9/Tncn8Jl31mcMx4yuIdS2nzRaZBC4t3LI17/WQIjdd4YXXIDKPnkm8lsxy40n18JfDbkPGvisPpQEs24zFBOurrM3KeYJ2y6v1OszFPReOBTzWhXfpAV3+U1defw647prDQo5T9f0wbEzPNck+Uv3608XQIBvGjJVhbfMYweiY5i8mIyGM4Qf6jRWQ3cDNwB/CEiFwNvAtc4k7/PU768nacFOarsi1ftjZjejUbA8diiWyPnKiCCRLavCta3CRWPOWYTtjj8Qk4JvGK+0mT7Z3ShlHMpFPq/4orrmDt2rX4/X4mTJjAfffdh9/vj//CLJMzS0ZVL1PVGlX1q+ogVX1QVfeq6rmqeryq/h9V/cCdq6o6U1WPVdUxqpra5pckyGZnTK+NlonUC4tHIg2+YjG45TTPNOjBLaeldd5Y2CZLo8fwxhOw8ESYX+X8fuOJvIpzxRVXsGXLFjZt2kRraysPPPBAXuUJku/ssoIhm50xI2uP+Ui8Xlg8lm2oSzkz6/nGi5nwcUe3NOgXWi5OUZr4BGW1TZZGUfPGE1D7XWh3v+i1/N15DnDSJdFflwQLFizgiSee4OOPP2b69Onccsst7Nq1i/POO49TTz2V9evXM3r0aH7xi1/Qu3dvLrjggq7XTpgwgd27d2dEjnQxJZNlujUGU+X4Az4yZZol2u8+kmUb6hC8lV20AH2msC6VRtHz3I8OKpgg7a3OeAaUTGipf1Xloosu4sUXX2TIkCFs3bqVBx98kIkTJ/L1r3+de++9l+9973sHxWhv55e//CWLFy9OW45MkO/Af8EgGWxa1ilOGf+mCo8NmCLs65W5oEeqAfMFK7d65osLmOvKMOLREsVKiDaeJOmU+r/22ms566yz+Kd/+qeMyJIuZsm41Nzwg4zs+FfgH2Xw8Bdid7JMhliNzlINmEdTTgpmZRhGPCoHOS4yr/EMkGqp/1tuuYWmpibuu+++jMiRCcyScclU0zIBKlrh27XKA4s6PPfLHNmZ3J7Tzx57lOe4v0S6rI5k+43HqppsGEYczr0J/BH/K/5yZzwDpFLq/4EHHmDlypU89thj+HyFs7QXjiQFQOmAARk7Vy91lI3XfplkegxVlftZ/7eWbuOHlfo4vFcpc5Zs5JRbnmHuk68n1W/csrwMIw1OugSm3gWVgwFxfk+9K2NB/1RK/X/rW9/ivffe44wzzuCUU07hRz/6UUZkSZeclfrPBemU+gdnr0ymimR6sb8cvjG71K1NdmfUeRMqH49b+DKWCy309f0DMGv4dKacfWu3ebkspZ/otay8v5EvrNR/dkr9W0wmhMqpU2m47cdokunMindXy0iObHVaLb85UojWo+zM/j/m9aoWEMfIbPQL+/uvZwKEKZpYCmZn//VdGz0bSmD+TqdMTKSiyVWWV2SvmaClFZQh2XmGYRQP5i6LoOaGHyBlZQnPDyTh+hKc3f//EEcZBJlQ+TjHHvd9jhx5natgUm+rvLd6fVglAef1Tj2yZOM2mSLRfjKp9p0xjEOFYiz1b0omgsqpU6mcPi3hwEkgSW9j3/3QEaI0gpZHo9/nXDPKdRPNSIs2b4/P6U6ZTNwmFskorET7yVjfGcPoeZiSiaCltpaWJ59KuBVzKYm5yoIEd/8HlYGX5eFFvPL/fp/Qp7c/6rzqDs2YlRB0ayWqsKJlskWOJzrPMIziwZRMBI0LF6EZaFwG3eMmobv/g8ogIQtFtVv5/z69/WHVlRf888lsuGkS/3bclyiLMK/KAsrRUdoHpGIlJOvWSjSTzTLeDKPnYYH/CDoaMttRoKmCbt0x/QGlTaBi5HUxs8QAUOXk5kpeCgn6l/tLuHnqaM9geDC4v3jHUvb46Mou+/F7nwcyU/04WbdWovXKkqlrZllohlEcmJKJoKSyMmPFMt+vgJkzw2+xqKIo+0sdI1LBcc1JeH0zgH5u+nKoghmYwII65exbu2WStVeGZ25B6lZCKuX6E81kS2SeZaEZPZV0Sv1fffXVrF27FlXl05/+NI888ghHHHFEhiVMHnOXRRCIPwV158Wa260wJoAqR3YqHZExGBF8ql1l///v4ZPoeOenvLP9J11py+X+EhZdegqrrz8npYU0tDulVwOzZMi3W8uy0IxCYMWOFUx6chIn/fwkJj05iRU7VuRVnoULF/L666/zxhtvMGTIEO6+++68yhPELJkItKX77vpI3q+A71xbwqN3eBe6VDwKYwIVncqHJd4xGAX2b7mTI6vKGXLqCA57a3PXQtqntz+qeywZMrUvJt/l+i0Lzcg3K3asYP7L82nrbAOg4R8NzH95PgBThk/JyDWSLfVfUeFkFakqra2t3Wqc5YuCsGREZI6IbBaRN0XkMREpE5FhIvKaiGwXkSUi0isXspRUVsY8HuhVwpNnCQGRbn1igrxfQTcFUxYIMPyD0+gfxfyp7lDK/SV8fmQ1857eRHPrweSDtvZE7KvcEmynvPOOKSlbV6liWWhGvlm8fnGXggnS1tnG4vWZKa8fWup/48aNrFu3jhdffBGArVu3cu211/L2229TUVHBvffe2/W6q666iv79+7Nlyxa+853vZESWdMm7khGRgcB3gfGqeiJQAswA7gQWqupxwD7g6lzIE3M5F+GTQCff/J1yzz0drD3OcYuF4tU/prLT6Xz5//b+M4OaT/PI/grwqf0TuP1LY3hhSxOt7Z1dGzQrRl7HgE/9O8tf+KGnSPnaYJlP8u2uM4w9/9iT1HiypFrq/+GHH6a+vp4TTjiBJUuWZESWdMm7knEpBcpFpBToDTQA5wBPusd/DkzLhSAx3WWqlHUcLHp53npQgf1lEf1jRvnAja+c0DCWur/+BIBjj/s+a4/6C4epUtHptF6u6VTmD/sSD/3bw0wbO5D65tawDZoqQqPfx6Y+a1ix6sYwcZLdr1KIpKIkMxlfMoxU6H94/6TGkyVY6n/jxo1s3LiR7du3c/XVzvfsWKX+AUpKSpgxYwZPPfVURmRJl7wrGVWtA34K/A1HubQA64BmVe1wp+0GcrKClNbUJDxXgPJ26NUB/32RMHNmqeMmE6EmAM99YzN1chWnRSiNlhIfnwjcPnQ6z3z9zbBMsAFV5VFKw/hYvGNp2FixB8DTUZL5dNcZxqxxsygrCS8/VVZSxqxxszJy/mRL/asq27dvBxwFtXz5ckaOHJkRWdIl70pGRPoAXwSGAQOAw4Hzknj9NSKyVkTWNjU1pS1Pvzmzk6pdBlDW4dQkC2WPe2frmlsTVhrguIJilYYJpdgD4MWuJI1DlynDpzD/s/OpObwGQag5vIb5n52fsaB/sqX+VZUrr7ySMWPGMGbMGBoaGrjppsz0tkmXQsgu+z/ATlVtAhCRp4GJQJWIlLrWzCDA8+utqt4P3A9Oqf90hQk2L2tcuIiO+vqEX9c3oqxy/4DzTV2IXU8skmljB3LPetjj8ZeJTBpIZb9KIVHsStI4tJkyfErGlEqQ0D0ys2bNYtascMto165dlJaW8qtf/arba1evXp1RWTJF3i0ZHDfZ6SLSWxzn4rnAW8ALwMXunCuB3+ZKoMqpUzn++ecYsOAnCVs1oZlmZQFl1vDpLFi5FSV63bFomWazj53uWRpm1vDpYWPFHgC3LDHD6PnkXcmo6ms4Af71wCYcme4HrgP+TUS2A32BB3MtW+XUqdTcGr+7XFsp/OEsCQnkO03Czn/np/zq+e9x108D3VoweymNIFPOvpX5w6ZT06ndzhlKZAC8T28/h5X6mLNkY1FkmhW7kjSMXFOMpf6tM2YCbDvnXE/XmeLsifnDWcLtP30r7NiqO6+k6pdrOKzj4FhbKdx3vrBthPBvx33Js1tlqkSWWgFnwS70rCurQWYUCsXQGTMTWGfMAqTfnNk03HgT2nZw81VbqZOuvO4EH/OHdbdI/E+FKxhwEgS+8mfl/cufZUqGF9JYQfRCXrRz1Z3TMIz8YEomAUKTAdrr69lXAb/6nLBjpM/TjQVQFaW/cp/9cGYWFlULohuGUYiYkkmQyqlTu5QNOOlvsWiugKM8FE1zlFI06VLsmWaGYfRM8h7476m0f3kCH0eo8I9LnfFsYEF0wyh+MlGa/7vf/W5BlPgPYkomS5x93c9p/pcJfFDhlJz5oAKa/2UCZ1/386xcz0qtGEZuaamtZds55/L2CaPYds65tNTW5lsk1q5dy759+/ItRhjmLotDS22tszGzoYHSmhr6zZkd5jYLsmLVjd26UU657udOInYaJJN9ZUF0w8gNLbW1YclAHfX1NNzo7LD3Wh9SIdlS/52dncydO5dHH32UpUu7VxPJF2bJxCD4QeqorwfVrg9S5DeWFatuZP7OpTSUCCpCQ4kwf+fSbgUtk6UnFMA0jJ5I48JFYdmmANrWRuPCRRk5fyql/u+++24uuugiapKov5gLTMnEINEP0uIdS2nzhZeOafOJZ22yZLDaXoZRmHQ0NCQ1nizJlvqvr6/nN7/5TcH0kAnF3GUxSPSD5FWDLNZ4olhasmEUJqU1NZ4btJOp4h6LYKn/b37zm2Hju3bt8iz1v2HDBrZv385xxx0HwIEDBzjuuOO6KjPnE7NkYhDtAxM5Hq0GWbTxRLHaXoZRmHhVa5eyMvrNmZ2R8ydb6n/KlCns2bOHXbt2sWvXLnr37l0QCgZMycQk0Q/SrOGJFbRMFktLNozCJFjXsHTAABChdMAAam79UcaC/smW+i9krHZZHNLKLstAbTKr7WUYuaEYapft2rWLCy+8MK0imVa7rMCI3OkfjSln35rRgpdBLC3ZMIxixtxlhmEYRUIxlvo3JWMYhuHSk8IHXuTj/ZmSMQzDAMrKyti7d2+PVTSqyt69eylLsNtvprCYjGEYBjBo0CB2795NU1NTvkXJGmVlZQwaNCin1ywIJSMiVcADwIk4DSe/DmwFlgBDgV3AJapaWJXfDMPoMfj9foYNG5ZvMXocheIuWwz8UVVHAicDbwPXA8+p6vHAc+5zwzAMo4jIu5IRkUrgLOBBAFX9RFWbgS8Cwbr4Pwem5UdCwzAMI1XyrmSAYUAT8LCIbBCRB0TkcOAYVQ0WCdsDHOP1YhG5RkTWisjanuxLNQzDKEbyvuNfRMYDrwITVfU1EVkM7Ae+o6pVIfP2qWqfOOdqAt6Nc8mjgffTFDsfmNy5p1hlN7lzS0+Q+1OqWp2NixRC4H83sFtVX3OfP4kTf3lPRGpUtUFEaoDGeCdK5CaJyNpslU/IJiZ37ilW2U3u3GJyxybv7jJV3QP8XUSCVR/PBd4ClgNXumNXAr/Ng3iGYRhGGhSCJQPwHeDXItIL2AFchaMAnxCRq3FcYJfkUT7DMAwjBQpCyajqRsDLbDs3C5e7PwvnzAUmd+4pVtlN7txicscg74F/wzAMo+eS95iMYRiG0XMxJWMYhmFkjUNGyYjIeSKyVUS2i0jeStSIyC4R2SQiG0VkrTt2lIg8KyLb3N993HERkbtcmd8QkXEh57nSnb9NRK4MGT/VPf9297WShqwPiUijiLwZMpZ1WaNdI02554tInXvfN4rIBSHH5rkybBWRySHjnp8ZERkmIq+540vchBVE5DD3+Xb3+NAk5R4sIi+IyFsisllEZsW6H4Vyz2PIXdD3XETKRGSNiLzuyn1LqtfK1PtJU+5HRGRnyP0+xR3P7+dEVXv8D1ACvAMMB3oBrwOj8iTLLuDoiLGfANe7j68H7nQfXwD8ARDgdOA1d/wonCy8o4A+7uM+7rE17lxxX3t+GrKeBYwD3sylrNGukabc84Hvecwd5X4eDsOpPvGO+3mJ+pkBngBmuI9/BnzbfXwt8DP38QxgSZJy1wDj3MdHAn915Svoex5D7oK+5+49OMJ97Adec+9NUtfK5PtJU+5HgIs95uf1c5LzRTYfP8AZwMqQ5/OAeXmSZRfdlcxWoMZ9XANsdR/fB1wWOQ+4DLgvZPw+d6wG2BIyHjYvRXmHEr5YZ13WaNdIU+75eC94YZ8FYKX7efH8zLj/dO8DpZGfreBr3cel7jxJ497/FvhCsdxzD7mL5p4DvYH1wGeSvVYm30+acj+Ct5LJ6+fkUHGXDQT+HvJ8tzuWDxR4RkTWicg17li0Om3R5I41vttjPJPkQtaE6talwL+67oKHQsz8ZOXuCzSraoeH3F2vcY+3uPOTxnXFjMX5llo09zxCbijwey4iJSKyEaeiyLM4lkey18rk+0lJbj1YMeU2934vFJHDIuVOUL6Mfk4OFSVTSJypquOA84GZInJW6EF1viIURV55LmTN4DX+BzgWOAVoAP4zA+fMCiJyBPAUMFtVi3snFAAABTJJREFU94ceK+R77iF3wd9zVe1U1VOAQcAEYGSeRUqISLlF5EQcK2kkcBqOC+y6LMuQ0OfkUFEydcDgkOeD3LGco6p17u9GYCnOB/s9ceqzIeF12qLJHWt8kMd4JsmFrNGukTKq+p77jxkA/hfnvqci916gSkRKI8bDzuUer3TnJ4yI+HEW6l+r6tPucMHfcy+5i+Weu7I2Ay/guK6SvVYm30+qcp+nqg3q8DHwMKnf74x+Tg4VJfMX4Hg3o6MXTtBuea6FEJHDReTI4GNgEvAm0eu0LQe+6maHnA60uKbqSmCSiPRxXRCTcHy6DcB+ETndzQb5Kpmv+ZYLWTNety74j+EyHee+B681w80cGgYcjxP09PzMuN/eXgAujnIPgnJfDDzvzk9URsHpq/S2qv5XyKGCvufR5C70ey4i1eJ05UVEynHiSG+ncK1Mvp9U5d4SsvgLTv+t0Pudv89JKsGmYvzBybD4K47P9YY8yTAcJ8PkdWBzUA4cH+1zwDbgT8BR7rgA97gybwLGh5zr68B29+eqkPHx7ofrHeBu0gs8P4bj5mjH8ctenQtZo10jTbl/6cr1hvuPUhMy/wZXhq2EZONF+8y4f8c17vv5DXCYO17mPt/uHh+epNxn4rgf3gA2uj8XFPo9jyF3Qd9z4CRggyvfm8BNqV4rU+8nTbmfd+/3m8CvOJiBltfPiZWVMQzDMLLGoeIuMwzDMPKAKRnDMAwja5iSMQzDMLKGKRnDMAwja5iSMQzDMLKGKRnDMAwja5iSMQ4pROSjHF1nmoiMinIsWJL9WyFjX3FrTm0Wp4T7A8ENd1HOcaWIPBYxdrSINLmbAn8tIh+IyMXRzmEYucCUjGFkh2k4JeCjMVdVfwZOzxFgDs4mvtE4bQpeJnbxwaXAF0Skd8jYxUCtqn6sqleQh6oWhhGJKRnjkEVE5orIX1wLItj4aaiIbHEtgbdF5MmIhTzyHLtE5CfiNHhaIyLHichngYuABeI0jzo2jig34JTED9a161TVh1R1q3uNU0Xkz+JU7l4pIjXqFKD8MzA15DwzcKodGEbBYErGOCQRkUk4NaYm4FQJPlUOVsQeAdyrqicA+3GaVcWiRVXH4JTfWKSqL+NYEXNV9RRVfSfO60fj9ATxktMP/DdOn5BTgYeA29zDj+EoFkRkAPBpnNIihlEwmJIxDlUmuT8bcBb4kThKB+DvqrraffwrnNpcsXgs5PcZ6QglImNc6+cdEbkUR+GdCDwrTv+QH3KwQu4KYKKIVACXAE+pamc61zeMTFMaf4ph9EgEuF1V7wsbdJpuRRb0i1fgT6M8TpTNOHGYF1R1E3CKiNwNlLtyblbVbspLVVtF5I84FY5nAP+WwrUNI6uYJWMcqqwEvi5Ooy1EZKCI9HOPDRGR4KJ+OfBSnHNdGvL7Fffxhzj97hPhduCnIhLaw6Pc/b0VqA7KIyJ+ERkdMu8xHOVyTMi1DaNgMEvGOCRR1WdE5ATgFadlBh8BXwE6cRb2mSLyEPAWTofHWPQRkTeAj3H6oQM8DvyviHwXJ54SNS6jqr8XkWrgDyJSAjTjlFlfqaqfuGnId4lIJc7/7CIc6weclsG/AB5UK6luFCBW6t8wQnDdZb9T1RMTnL8Lpz/H+0lc4xH3Gk+mIGLC5Oo6hhELc5cZRu5pAW4N3YyZaUTk18DngLZsXcMwEsEsGcNIABFZCgyLGL5OVVfmQx7DKBZMyRiGYRhZw9xlhmEYRtYwJWMYhmFkDVMyhmEYRtYwJWMYhmFkjf8Pbv3l8E4WkNcAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x720 with 3 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "start = time.time()\n",
     "\n",
-    "# cut on invariant mass of Z boson candidate 1\n",
-    "#def cut_mZ1(mZ1):\n",
-    "# want invariant mass of same-type-opposite-charge lepton pair that's closest to Z mass (91 GeV) to be in range 50 < m < 106 GeV\n",
+    "#\n",
+    "# Get data\n",
+    "#\n",
+    "data = get_data_from_files()\n",
     "\n",
-    "# cut on invariant mass of Z boson candidate 2\n",
-    "#def cut_mZ2(mZ2):\n",
-    "# want invariant mass of remaining lepton pair that's closest to Z mass (91 GeV) to be in range 17.5 < m < 115 GeV\n",
-    "# advanced: vary the lower range monotically from 17.5 at mllll=120 to 50 at mllll=190, and constant above mllll=190\n",
+    "#\n",
+    "# Random forest for feature selection\n",
+    "#\n",
+    "nn_input = forest_regression(data)\n",
     "\n",
-    "# cut on deltaR\n",
-    "# want to throw away leptons that are separated from all other leptons by deltaR = math.sqrt(delta(lep_eta)**2 + delta(lep_phi)**2) < 0.2\n",
-    "# want to throw away leptons that are separated from other leptons of the same type by deltaR = math.sqrt(delta(lep_eta)**2 + delta(lep_phi)**2) < 0.1\n",
+    "#\n",
+    "# Deep Neural Network (for Background Rejection)\n",
+    "#\n",
+    "# add variable to distinugish between signal and background\n",
+    "data[r'$H \\rightarrow ZZ \\rightarrow \\ell\\ell\\ell\\ell$']['isSignal'] = \\\n",
+    "     np.ones(len(data[r'$H \\rightarrow ZZ \\rightarrow \\ell\\ell\\ell\\ell$']))\n",
+    "data[r'$Z,t\\bar{t}$']['isSignal'] = np.zeros(len(data[r'$Z,t\\bar{t}$']))\n",
+    "data['ZZ']['isSignal'] = np.zeros(len(data['ZZ']))\n",
     "\n",
-    "# example of returning list where every element passes minimum lep_pt requirement\n",
-    "#def cut_lep_pt_min(data):\n",
-    "#    return [data.lep_pt[i] for i in range(len(data.lep_pt)) if data.lep_pt[i] > 6000]\n",
+    "# combine all dataframes\n",
+    "all_data = pd.concat([data[r'$H \\rightarrow ZZ \\rightarrow \\ell\\ell\\ell\\ell$'],\n",
+    "                      data[r'$Z,t\\bar{t}$'], data['ZZ']])\n",
+    "mc_data = remove_variable_length_columns(all_data)\n",
     "\n",
-    "# cut on minimum lepton pt\n",
-    "# want to throw away muons with lep_pt < 6000\n",
-    "# want to throw away electrons with lep_pt < 7000\n",
+    "model = generate_neural_network(mc_data, nn_input)\n",
     "\n",
-    "# cut on maximum lepton etcone20\n",
-    "# want to throw away muons with lep_etcone20/lep_pt < 0.3\n",
-    "# want to throw away electrons with lep_etcone20/lep_pt < 0.2\n",
+    "#\n",
+    "# Make cuts on measurement data using the neural network\n",
+    "#\n",
+    "meas_data = remove_variable_length_columns(data['data'])\n",
+    "X_meas = meas_data[nn_input].values\n",
+    "Y_meas = model.predict(X_meas)\n",
+    "fail = Y_meas < 0.5\n",
+    "data_indices = data['data'].index.values\n",
+    "drop_indices = [data_indices[i] for i in range(len(fail)) if fail[i]]\n",
+    "data['data'].drop(drop_indices, inplace=True)\n",
     "\n",
-    "# cut on maximum lepton d0\n",
-    "# want to throw away muons with lep_trackd0pvunbiased/lep_tracksigd0pvunbiased < 3.5\n",
-    "# want to throw away electrons with lep_trackd0pvunbiased/lep_tracksigd0pvunbiased < 6.5\n",
+    "#\n",
+    "# Plot events histogram\n",
+    "#\n",
+    "hists = calc_hists(data)\n",
+    "plot_data(hists)\n",
     "\n",
-    "# example of cutting on length of list passing minimum requirements\n",
-    "#def cut_n_lep_min(lep_pt_min):\n",
-    "#    return len(lep_pt_min) < 4"
+    "# Display the significance\n",
+    "sig = calc_significance(hists[-1])\n",
+    "\n",
+    "elapsed = time.time() - start\n",
+    "print(\"Time taken: \"+str(elapsed))"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "scrolled": true
-   },
+   "metadata": {},
    "outputs": [],
-   "source": [
-    "if __name__==\"__main__\":\n",
-    "    start = time.time()\n",
-    "    data = get_data_from_files()\n",
-    "    plot_data(data)\n",
-    "    elapsed = time.time() - start\n",
-    "    print(\"Time taken: \"+str(elapsed))"
-   ]
+   "source": []
   }
  ],
  "metadata": {