NB_CVII-logreg_SUSY.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Notebook 5: Introduction to  Logistic Regression, Pandas, and TensorFlow #\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Learning Goals##\n",
    "This notebook will serve as an introduction to the logistic regression as well as the new extremely powerful TensorFlow library for Machine Learning (ML) from Google. We will also learn how to use the versatile Pandas package for handling data. For those of you familiar with the `R` language, the Pandas objects are extremely similar to the dataframe objects in `R`.\n",
    "\n",
    "## Overview##\n",
    "Throughout, we will work with the [SUSY dataset](https://archive.ics.uci.edu/ml/machine-learning-databases/00279/SUSY.csv.gz). It is available from the [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/datasets.html), which is a very comprehensive repository of useful datasets relevant to ML.\n",
    "\n",
    "Here is the description of the SUSY dataset we will be playing around with for this notebook:\n",
    ">The data has been produced using Monte Carlo simulations and contains events with two leptons (electrons or muons). In high energy physics experiments, such as the ATLAS and CMS detectors at the CERN LHC, one major hope is the discovery of new particles. To accomplish this task, physicists attempt to sift through data events and classify them as either a signal of some new physics process or particle, or instead a background event from understood Standard Model processes. Unfortunately we will never know for sure what underlying physical process happened (the only information to which we have access are the final state particles). However, we can attempt to define parts of phase space that will have a high percentage of signal events. Typically this is done by using a series of simple requirements on the kinematic quantities of the final state particles, for example having one or more leptons with large amounts of momentum that is transverse to the beam line ($p_{T}$). Here instead we will use logistic regression in order to attempt to find out the relative probability that an event is from a signal or a background event and rather than using the kinematic quantities of final state particles directly we will use the output of our logistic regression to define a part of phase space that is enriched in signal events. The dataset we are using has the value of 18 kinematic variables (\"features\") of the event. The first 8 features are direct measurements of final state particles, in this case the $p_{T}$, pseudo-rapidity ($\\eta$), and azimuthal angle ($\\phi$) of two leptons in the event and the amount of missing transverse momentum (MET) together with its azimuthal angle. The last ten features are functions of the first 8 features; these are high-level features derived by physicists to help discriminate between the two classes. You can think of them as physicists attempt to use non-linear functions to classify signal and background events and they have been developed with a lot of deep thinking on the part of physicist. There is however, an interest in using deep learning methods to obviate the need for physicists to manually develop such features. Benchmark results using Bayesian Decision Trees from a standard physics package and 5-layer neural networks and the dropout algorithm are presented in the original paper to compare the ability of deep-learning to bypass the need of using such high level features. We will also explore this topic in later notebooks. The dataset consists of 5 million events, the first 4,500,000 of which we will use for training the model and the last 500,000 examples will be used as a test set.\n",
    "\n",
    "This dataset comes from this interesting paper by the UCI group: <cite> P. Baldi, P. Sadowski, and D. Whiteson. \"Searching for Exotic Particles in High-energy Physics with Deep Learning.\" Nature Communications 5 (July 2, 2014)</cite>.\n",
    "\n",
    "## Categorical data/Classification Tasks ##\n",
    "\n",
    "So far, we have largely focused on supervised learning tasks such as linear regression, where the goal is to make predictions about continuous labels. Often, we are also interested in classification tasks -- where the goal is to assign samples to categories. The training data consists of a set of features and discrete labels. This type of data is called categorical data (the data comes in different categories). \n",
    "\n",
    "Initially, we will focus on a binary classification task. In the SUSY dataset, the goal is to decide whether a data point represents signal \"potential collision\"- labeled 1, or \"background\"(Standard Model processes which produce final states with similar constituents as SUSY processes) - labeled 0. This is done by looking at 18 features - the first 8 of which are \"low-level\" features that can be directly measured and the last 10 features are \"higher-order\" features constructed using physics intuition. In more detail:\n",
    ">The first column is the class label (1 for signal, 0 for background), followed by the 18 features (8 low-level features then 10 high-level features):: lepton 1 pT, lepton 1 eta, lepton 1 phi, lepton 2 pT, lepton 2 eta, lepton 2 phi, missing energy magnitude, missing energy phi, MET_rel, axial MET, M_R, M_TR_2, R, MT2, S_R, M_Delta_R, dPhi_r_b, cos(theta_r1)\n",
    "\n",
    "Our goal will be to use either the first 8 features or the full 18 features to predict whether an event is signal or background.\n",
    "\n",
    "## Logistic Regression##\n",
    "\n",
    "\n",
    "One of the best understood and canonical methods for performing such a task is Logistic Regression. We will see that a deep understanding of Logistic regression will introduce us to many of the ideas and techniques at the forefront of modern Machine Learning. In Logistic regression, each set of features $\\mathbf{x}_i$ is associated with a category $C_i\\in\\{1,0\\}$, with $i=1\\ldots n$. It is helpful to re-define $\\mathbf{x}$ to be an extended vector $\\mathbf{x}\\rightarrow (1,\\mathbf{x})$ (which just accounts for an intercept, see Sec. VI of the review). Then, the Likelihood function for Logistic regression is given by the sigmoid function\n",
    "\n",
    "$$\n",
    "P(c_i=1)=1-P(c_i=0)= {1 \\over 1+ e^{-\\mathbf{w}\\cdot \\mathbf{x}_i}},\n",
    "$$\n",
    "\n",
    "where $\\mathbf{w}$ are the weights that define the logistic regression. Notice that this is just the Fermi function with $\\beta E=-\\mathbf{w}\\cdot \\mathbf{x}$.\n",
    "\n",
    "\n",
    "As in Sec. VI of the review, we will maximize the Log-likelihood of the observed data. Let us define the function\n",
    "$$\n",
    "f(a)={1 \\over 1+ e^{-a}},\n",
    "$$\n",
    "Notice that the derivative with respect to $a$ is given by\n",
    "$$\n",
    "{df \\over da}= f(1-f).\n",
    "$$\n",
    "\n",
    "Define $f_i \\equiv f(\\mathbf{w}\\cdot \\mathbf{x}_i)$. Then, the Likelihood of the data $\\{ \\mathbf{x}_i, C_i \\}$ is given by\n",
    "$$\n",
    "P(Data|\\mathbf{x})= \\prod_{i=1}^n f_i^{C_i}(1-f_i)^{1-C_i}\n",
    "$$\n",
    "and the log-likelihood is given by\n",
    "$$\n",
    "\\log{P(Data|\\mathbf{w})}= \\sum_{i=1}^n C_i \\log f_i + (1-C_i)\\log(1-f_i)\n",
    "$$\n",
    "\n",
    "The negative of the log-likelihood gives us the cross-entropy error function\n",
    "$$\n",
    "\\mathrm{Cross\\,Entropy}=E(\\mathbf{w})= -\\sum_{i=1}^n C_i \\log f_i + (1-C_i)\\log(1-f_i).\n",
    "$$\n",
    "\n",
    "Using the formula above notice that\n",
    "$$\n",
    "\\nabla E(\\mathbf{w})=\\sum_{i=1}^n (f_i-C_i)\\mathbf{x}_i.\n",
    "$$\n",
    "In other words, the gradient points in the sum of training example directions weighted by the difference between the true label and the probability of predicting that label.\n",
    "\n",
    "\n",
    "\n",
    "## Finding the MLE Estimate ##\n",
    "\n",
    "Notice the Maximum-Likelihood Estimation (MLE) is the same as minimizing the cross-entropy. There is no closed form expression for this. One strategy is to start with an arbitrary $\\mathbf{w}$ and then update our estimate based on our error function. In particular, we would like to nudge $\\mathbf{w}$ in the direction where the error is decreasing the fastest. This is the idea behind gradient descent. Furthermore, we can show that the cross-entropy error function used in logistic regression has a unique minimum. Thus, we can perform this procedure with relative ease (However, as a word of caution, note there is a generic instability in the MLE procedure for linearly separable data).\n",
    "\n",
    "Theoretically, one nice method for doing this is the <i> Newton-Raphson </i> method. In this method, we iteratively calculate the gradient \n",
    "$$\n",
    "\\mathbf{w}^{new} \\leftarrow \\mathbf{w}^{old} - \\mathbf{H}^{-1} \\nabla E(\\mathbf{w}),\n",
    "$$\n",
    "where $\\mathbf{H}$ is the Hessian matrix which is the second derivative of the energy function. For OLS linear regression, one can show that this procedure yields the right answer.\n",
    "\n",
    "<b> Exercise: </b> Show that for OLS Linear regression the formula above produces right answer.\n",
    "\n",
    "\n",
    "\n",
    "More generally, there are a number of generalizations of this idea that have been proposed. We will refer to these kinds of methods as generalized gradient descent methods and discuss them extensively in what follows.\n",
    "\n",
    "\n",
    "## Importing the SUSY data set with Pandas\n",
    "\n",
    "<b> Exercise:</b> In what follows, use Pandas to import the first 4,500,000 examples and call that the training data and import the last 500,000 examples and call that the test data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Users\\b74\\anaconda3\\lib\\site-packages\\tensorflow\\python\\compat\\v2_compat.py:107: disable_resource_variables (from tensorflow.python.ops.variable_scope) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "non-resource variables are not supported in the long term\n"
     ]
    }
   ],
   "source": [
    "# Importing the SUSY Data set\n",
    "import sys, os\n",
    "import pandas as pd\n",
    "\n",
    "import numpy as np\n",
    "import warnings\n",
    "#Commnet the next line on to turn off warnings\n",
    "#warnings.filterwarnings('ignore')\n",
    "\n",
    "\n",
    "seed=12\n",
    "np.random.seed(seed)\n",
    "#import tensorflow as tf\n",
    "import tensorflow.compat.v1 as tf\n",
    "tf.disable_v2_behavior()\n",
    "# suppress tflow compilation warnings\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'\n",
    "\n",
    "#tf.random.set_seed(seed) # \n",
    "tf.set_random_seed(seed)\n",
    "\n",
    "# Download the SUSY.csv (about 2GB) from UCI ML archive and save it in the same directory as this jupyter notebook\n",
    "# See: https://archive.ics.uci.edu/ml/machine-learning-databases/00279/\n",
    "#filename=\"SUSY.csv\"\n",
    "filename=os.path.expanduser('~')+'/ML_review/SUSY_data/SUSY.csv' \n",
    "\n",
    "columns=[\"signal\", \"lepton 1 pT\", \"lepton 1 eta\", \"lepton 1 phi\", \"lepton 2 pT\", \"lepton 2 eta\", \n",
    "         \"lepton 2 phi\", \"missing energy magnitude\", \"missing energy phi\", \"MET_rel\", \n",
    "         \"axial MET\", \"M_R\", \"M_TR_2\", \"R\", \"MT2\", \"S_R\", \"M_Delta_R\", \"dPhi_r_b\", \"cos(theta_r1)\"]\n",
    "\n",
    "# Load 1,500,000 rows as train data, 50,000 as test data\n",
    "# filename\n",
    "df_train=pd.read_csv(\"https://archive.ics.uci.edu/ml/machine-learning-databases/00279/SUSY.csv.gz\",names=columns,nrows=4500000,engine='python')\n",
    "df_test=pd.read_csv(\"https://archive.ics.uci.edu/ml/machine-learning-databases/00279/SUSY.csv.gz\",names=columns,nrows=500000, skiprows=4500000,engine='python')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "rslt_df = df_train[df_train['missing energy magnitude'] > 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run logistic regression using Linear Model functions in TensorFlow##\n",
    "\n",
    "We now will run logistic regression using MLE. \n",
    "\n",
    "<b>Exercise:</b> Using the tensor flow tutorial [here](https://www.tensorflow.org/versions/r0.9/tutorials/wide/index.html#setup), we will run logistic regression on the SUSY data for both the simple features (first 8 features) and the full feature space. First we will start with only the low-level features. We will also investigate the use of Ridge Regression by testing the results as as function of the regularization parameter $\\alpha$. \n",
    "\n",
    "Let us define some functions to do the actual training for us and will let them take the number of features as an input parameter.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import sys\n",
    "#import ml_style as style #optional styling sheet\n",
    "#mpl.rcParams.update(style.style) #optional styling sheet\n",
    "\n",
    "def getTrainData(nVar, dataset=df_train):\n",
    "    designMatrix = dataset.iloc[:,1:nVar+1].values\n",
    "    #now the signal\n",
    "    labels = dataset['signal'].values # labels (0 or 1)\n",
    "    return (designMatrix,labels)\n",
    "\n",
    "def getTestData(nVar):\n",
    "    designMatrix = df_test.iloc[:,1:nVar+1].values\n",
    "    #now the signal\n",
    "    labels = df_test['signal'].values\n",
    "    return (designMatrix,labels)\n",
    "\n",
    "# define\n",
    "def build_roc_curve(probs, signal_bit, threshes):\n",
    "    # Convert things to a pandas series to build a DataFrame\n",
    "    # which will make ROC curve logic easier to express\n",
    "    signal_probs = pd.Series(probs[:,1])\n",
    "    signal_true = pd.Series(signal_bit)\n",
    "    signal_df = pd.DataFrame(signal_probs, columns=['sig_prob'])\n",
    "    signal_df.loc[:,'sig_true'] = signal_true\n",
    "    Acceptance = []\n",
    "    Rejection = []\n",
    "    for thresh in threshes:\n",
    "        # define acceptance\n",
    "        signal_df.loc[:,'accept'] = signal_df['sig_prob'] > thresh\n",
    "        # sum over data frame with slicing conditions\n",
    "        nSigCor = len(signal_df[(signal_df['accept']) & (signal_df['sig_true']==1.)])\n",
    "        nSig = len(signal_df[signal_df['sig_true']==1.])\n",
    "        nBkgCor = len(signal_df[ (signal_df['sig_true']==0.) & (~signal_df['accept'])])\n",
    "        nBkg = len(signal_df[signal_df['sig_true']==0.])\n",
    "        Acceptance.append(nSigCor/nSig) # False positive rate\n",
    "        Rejection.append(nBkgCor/nBkg) # True positive rate\n",
    "\n",
    "    return Acceptance, Rejection\n",
    "    \n",
    "# let's define this as a function so we can call it easily\n",
    "def runTensorFlowRegression(nVar,alpha,dataset=df_train):\n",
    "\n",
    "    #make data array placeholder for just first 8 simple features\n",
    "    x = tf.placeholder(tf.float32,[None,nVar])\n",
    "    #make weights and bias\n",
    "    W = tf.Variable(tf.zeros([nVar,2])) #we will make y 'onehot' 0 bit is bkg, 1 bit is signal\n",
    "    b = tf.Variable(tf.zeros([2]))\n",
    "\n",
    "    #make 'answer variable'\n",
    "    y = tf.nn.softmax(tf.matmul(x, W) + b)\n",
    "    #placeholder for correct answer\n",
    "    y_ = tf.placeholder(tf.float32, [None, 2])\n",
    "    #cross entropy with L2 regularizer\n",
    "    cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=y,labels=y_)+alpha*tf.nn.l2_loss(W))\n",
    "    \n",
    "    #define training step\n",
    "    train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)\n",
    "    #initialize variables \n",
    "    init = tf.global_variables_initializer()\n",
    "    #setup session\n",
    "    sess = tf.Session()\n",
    "    sess.run(init)\n",
    "\n",
    "    #ok now everything is setup for tensorflow, but we need the data in a useful form\n",
    "    #first let's get the variables\n",
    "    Var_train, Sig_train_bit1 = getTrainData(nVar, dataset=df_train)\n",
    "    #now the signal\n",
    "    Sig_train_bit0 = Sig_train_bit1.copy()\n",
    "    Sig_train_bit0 = 1 - Sig_train_bit0\n",
    "    Sig_train = np.column_stack((Sig_train_bit0,Sig_train_bit1))\n",
    "    \n",
    "    ######## ------- TRAINING ----------############\n",
    "    #Now perform minibatch gradient descent with minibatches of size 100:\n",
    "    n_data = len(Sig_train_bit1)\n",
    "    minibatch_size = 1000\n",
    "    n_minibatch = n_data//minibatch_size\n",
    "    print('\\t Training with %i minibatches, dataset size is %i'%(n_minibatch,n_data))\n",
    "    for i in range(0, n_minibatch):\n",
    "        sys.stdout.write(\"%.3f %% completed \\r\"%(100*i/n_minibatch))\n",
    "        sys.stdout.flush()\n",
    "        start = i*minibatch_size\n",
    "        end = (i+1)*minibatch_size-1\n",
    "        \n",
    "        batch_x = Var_train[start:end]\n",
    "        batch_y = Sig_train[start:end]\n",
    "        sess.run(train_step, feed_dict={x: batch_x, y_: batch_y})\n",
    "    \n",
    "    \n",
    "    # Accuracy function:\n",
    "    correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))\n",
    "    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n",
    "    \n",
    "    ######## ------- TESTING ----------############\n",
    "    # Setup test data\n",
    "    Var_test = df_test.iloc[:,1:nVar+1].values\n",
    "    \n",
    "    # Now the signal\n",
    "    Sig_test_bit1 = df_test['signal'].values\n",
    "    \n",
    "    Sig_test_bit0 = Sig_test_bit1.copy()\n",
    "    Sig_test_bit0 = 1 - Sig_test_bit0\n",
    "    Sig_test = np.column_stack((Sig_test_bit0,Sig_test_bit1))\n",
    "    print(\"\\t Accuracy for alpha %.1E : %.3f\" %(alpha,sess.run(accuracy, feed_dict={x: Var_test, y_: Sig_test})))\n",
    "    \n",
    "    # Get the weights\n",
    "    weights = W.eval(session=sess)\n",
    "    # Get probabilities assigned (i.e. evaluate y on test data)\n",
    "    probs = y.eval(feed_dict = {x: Var_test}, session = sess)\n",
    "    # now let's get the signal efficiency and background rejection on the test data\n",
    "    print('\\t Computing ROC curve ...')\n",
    "    # build ROC curve by scanning over thresholds of probability of being\n",
    "    # a background event and calculating signal efficiency/background rejection\n",
    "    # at each threshold\n",
    "    threshes = np.arange(0,1,0.01)\n",
    "    Acceptance, Rejection = build_roc_curve(probs, Sig_test_bit1, threshes)\n",
    "\n",
    "    return (probs,Acceptance,Rejection)\n",
    "\n",
    "\n",
    "def runTensorFlowRegressionNeural(nVar,alpha,n_hidden, dataset=df_train):\n",
    "\n",
    "    #make data array placeholder for just first 8 simple features\n",
    "    x = tf.placeholder(tf.float32,[None,nVar])\n",
    "    #make weights and bias\n",
    "    W = tf.Variable(tf.zeros([n_hidden,2])) #we will make y 'onehot' 0 bit is bkg, 1 bit is signal\n",
    "    b = tf.Variable(tf.zeros([2]))\n",
    "    \n",
    "    w_h = tf.Variable(tf.truncated_normal([nVar,n_hidden], stddev=0.001)) \n",
    "    b_h = tf.Variable(tf.zeros([n_hidden]))\n",
    "    h = tf.nn.relu(tf.matmul(x, w_h) + b_h)\n",
    "\n",
    "    #make 'answer variable'\n",
    "    y = tf.nn.softmax(tf.matmul(h, W) + b)\n",
    "    #placeholder for correct answer\n",
    "    y_ = tf.placeholder(tf.float32, [None, 2])\n",
    "    #cross entropy with L2 regularizer\n",
    "    cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=y,labels=y_)+alpha*tf.nn.l2_loss(W))\n",
    "    \n",
    "    #define training step\n",
    "    train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)\n",
    "    #initialize variables \n",
    "    init = tf.global_variables_initializer()\n",
    "    #setup session\n",
    "    sess = tf.Session()\n",
    "    sess.run(init)\n",
    "\n",
    "    #ok now everything is setup for tensorflow, but we need the data in a useful form\n",
    "    #first let's get the variables\n",
    "    Var_train, Sig_train_bit1 = getTrainData(nVar, dataset=df_train)\n",
    "    #now the signal\n",
    "    Sig_train_bit0 = Sig_train_bit1.copy()\n",
    "    Sig_train_bit0 = 1 - Sig_train_bit0\n",
    "    Sig_train = np.column_stack((Sig_train_bit0,Sig_train_bit1))\n",
    "    \n",
    "    ######## ------- TRAINING ----------############\n",
    "    #Now perform minibatch gradient descent with minibatches of size 100:\n",
    "    n_data = len(Sig_train_bit1)\n",
    "    minibatch_size = 1000\n",
    "    n_minibatch = n_data//minibatch_size\n",
    "    print('\\t Training with %i minibatches, dataset size is %i'%(n_minibatch,n_data))\n",
    "    for i in range(0, n_minibatch):\n",
    "        sys.stdout.write(\"%.3f %% completed \\r\"%(100*i/n_minibatch))\n",
    "        sys.stdout.flush()\n",
    "        start = i*minibatch_size\n",
    "        end = (i+1)*minibatch_size-1\n",
    "        \n",
    "        batch_x = Var_train[start:end]\n",
    "        batch_y = Sig_train[start:end]\n",
    "        sess.run(train_step, feed_dict={x: batch_x, y_: batch_y})\n",
    "    \n",
    "    \n",
    "    # Accuracy function:\n",
    "    correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))\n",
    "    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n",
    "    \n",
    "    ######## ------- TESTING ----------############\n",
    "    # Setup test data\n",
    "    Var_test = df_test.iloc[:,1:nVar+1].values\n",
    "    \n",
    "    # Now the signal\n",
    "    Sig_test_bit1 = df_test['signal'].values\n",
    "    \n",
    "    Sig_test_bit0 = Sig_test_bit1.copy()\n",
    "    Sig_test_bit0 = 1 - Sig_test_bit0\n",
    "    Sig_test = np.column_stack((Sig_test_bit0,Sig_test_bit1))\n",
    "    print(\"\\t Accuracy for alpha %.1E : %.3f\" %(alpha,sess.run(accuracy, feed_dict={x: Var_test, y_: Sig_test})))\n",
    "    \n",
    "    # Get the weights\n",
    "    weights = W.eval(session=sess)\n",
    "    # Get probabilities assigned (i.e. evaluate y on test data)\n",
    "    probs = y.eval(feed_dict = {x: Var_test}, session = sess)\n",
    "    # now let's get the signal efficiency and background rejection on the test data\n",
    "    print('\\t Computing ROC curve ...')\n",
    "    # build ROC curve by scanning over thresholds of probability of being\n",
    "    # a background event and calculating signal efficiency/background rejection\n",
    "    # at each threshold\n",
    "    threshes = np.arange(0,1,0.01)\n",
    "    Acceptance, Rejection = build_roc_curve(probs, Sig_test_bit1, threshes)\n",
    "\n",
    "    return (probs,Acceptance,Rejection)\n",
    "\n",
    "\n",
    "def runCutBased():\n",
    "    Sig_test_bit1 = df_test['signal'].values\n",
    "    \n",
    "#     probs = []\n",
    "#     for i in df_test[\"lepton 1 pT\"].values:\n",
    "#         if i>1: probs.append([0,1])\n",
    "#         else: probs.append([1,0])\n",
    "#     probs = np.array(probs)\n",
    "\n",
    "    probs = []\n",
    "    for i in df_test[\"missing energy magnitude\"].values:\n",
    "        x = 1/(1+np.exp(- (i-2) ))\n",
    "        probs.append([1-x,x])\n",
    "    probs = np.array(probs)\n",
    "\n",
    "    threshes = np.arange(0,1,0.01)\n",
    "    Acceptance, Rejection = build_roc_curve(probs, Sig_test_bit1, threshes)\n",
    "\n",
    "    return (probs,Acceptance,Rejection)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training and evaluating model\n",
    "Now let's run using the first 8 variables only (the low-level features). Note: this will take several minutes !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training for alpha = 1.00E-10\n",
      "\t Training with 4500 minibatches, dataset size is 4500000\n",
      "\t Accuracy for alpha 1.0E-10 : 0.771\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 4500 minibatches, dataset size is 4500000\n",
      "\t Accuracy for alpha 1.0E-10 : 0.782\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 4500 minibatches, dataset size is 4500000\n",
      "\t Accuracy for alpha 1.0E-10 : 0.779\n",
      "\t Computing ROC curve ...\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# We sweep the L2 regularizer strength (alpha) over 10 decades\n",
    "alphas = np.logspace(-10,-1,11)\n",
    "fig = plt.figure(dpi=100)\n",
    "ax = fig.add_subplot(111)\n",
    "it=0\n",
    "for alpha in alphas:\n",
    "    print(\"Training for alpha = %.2E\"%alpha)\n",
    "    c1 = 1.*( float(it) % 3.)/3.0\n",
    "    c2 = 1.*( float(it) % 9.)/9.0\n",
    "    c3 = 1.*( float(it) % 27.)/27.0\n",
    "    probsSimple,accep,rej = runTensorFlowRegression(8,alpha)\n",
    "    probsSimple2,accep2,rej2 = runTensorFlowRegressionNeural(8,alpha, 5)\n",
    "    probsSimple3,accep3,rej3 = runTensorFlowRegressionNeural(8,alpha, 10)\n",
    "    \n",
    "    ax.plot(accep,rej,\"-ok\",label='No hidden layer', markersize=4)\n",
    "    ax.plot(accep2,rej2,\"-ob\",label='With hidden layer (5)', alpha=0.8, markersize=4)\n",
    "    ax.plot(accep3,rej3,\"-or\",label='With hidden layer (10)', alpha=0.8, markersize=4)\n",
    "\n",
    "    it+=1\n",
    "    break\n",
    "    \n",
    "ax.set_xlabel('signal efficiency')\n",
    "ax.set_ylabel('background rejection')\n",
    "plt.legend(loc='lower left', fontsize = 'small');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training for alpha = 1.00E-10\n",
      "\t Training with 4500 minibatches, dataset size is 4500000\n",
      "\t Accuracy for alpha 1.0E-10 : 0.771\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 4500 minibatches, dataset size is 4500000\n",
      "\t Accuracy for alpha 1.0E-10 : 0.790\n",
      "\t Computing ROC curve ...\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# We sweep the L2 regularizer strength (alpha) over 10 decades\n",
    "alphas = np.logspace(-10,-1,11)\n",
    "fig = plt.figure(dpi=100)\n",
    "ax = fig.add_subplot(111)\n",
    "it=0\n",
    "for alpha in alphas:\n",
    "    print(\"Training for alpha = %.2E\"%alpha)\n",
    "    c1 = 1.*( float(it) % 3.)/3.0\n",
    "    c2 = 1.*( float(it) % 9.)/9.0\n",
    "    c3 = 1.*( float(it) % 27.)/27.0\n",
    "    probsSimple,accep,rej = runTensorFlowRegression(8,alpha)\n",
    "    probsSimple2,accep2,rej2 = runTensorFlowRegression(18,alpha)\n",
    "    probsSimple3,accep3,rej3 = runCutBased()\n",
    "    \n",
    "    ax.plot(accep,rej,\"-og\",label='Simple variables regression', markersize=4)\n",
    "    ax.plot(accep2,rej2,\"-om\",label='All variables regression', alpha=0.8, markersize=4)\n",
    "    ax.plot(accep3,rej3,\"-ob\",label='Rectangular kinematic requirements', alpha=0.8, markersize=4)\n",
    "\n",
    "    it+=1\n",
    "    break\n",
    "    \n",
    "ax.set_xlabel('signal efficiency')\n",
    "ax.set_ylabel('background rejection')\n",
    "plt.legend(loc='lower left', fontsize = 'small');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training for alpha = 1.00E-10\n",
      "\t Training with 4500 minibatches, dataset size is 4500000\n",
      "\t Accuracy for alpha 1.0E-10 : 0.771\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 4500 minibatches, dataset size is 4500000\n",
      "\t Accuracy for alpha 1.0E-10 : 0.790\n",
      "\t Computing ROC curve ...\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# We sweep the L2 regularizer strength (alpha) over 10 decades\n",
    "alphas = np.logspace(-10,-1,11)\n",
    "fig = plt.figure(dpi=100)\n",
    "ax = fig.add_subplot(111)\n",
    "it=0\n",
    "for alpha in alphas:\n",
    "    print(\"Training for alpha = %.2E\"%alpha)\n",
    "    c1 = 1.*( float(it) % 3.)/3.0\n",
    "    c2 = 1.*( float(it) % 9.)/9.0\n",
    "    c3 = 1.*( float(it) % 27.)/27.0\n",
    "    probsSimple,accep,rej = runTensorFlowRegression(8,alpha)\n",
    "    probsSimple2,accep2,rej2 = runTensorFlowRegression(18,alpha,dataset=rslt_df)\n",
    "    \n",
    "    ax.plot(accep,rej,\"-o\", color=\"orange\", label='Full training dataset', markersize=4)\n",
    "    ax.plot(accep2,rej2,\"-o\", color=\"brown\", label='Filtered training dataset', alpha=0.8, markersize=4)\n",
    "\n",
    "    it+=1\n",
    "    break\n",
    "    \n",
    "ax.set_xlabel('signal efficiency')\n",
    "ax.set_ylabel('background rejection')\n",
    "plt.legend(loc='lower left', fontsize = 'small');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An accuracy of 77% is pretty good! More important to physics analysis is the ROC curve above which allows physicists to define a part of phase space that has more or less signal acceptance, but also less or more background rejection. It is up to the individual analysts in particular searches to decide on the best working point for them.\n",
    "\n",
    "As you can see, using just the kinematic variables of the final state objects there is no need for regularization and in fact as we turn off the relative weights of the variables we lose discrimination power.\n",
    "\n",
    "<b> Question:</b> Why do you think this is the case?\n",
    "<br><span style=\"color:blue\"> \n",
    "When there is a large number of tunable parameters (degrees of freedom), the models tend to be more susceptible to overfitting.\n",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t Training with 4500 minibatches, dataset size is 4500000\n",
      "\t Accuracy for alpha 1.0E-05 : 0.771\n",
      "\t Computing ROC curve ...\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:ylabel='Frequency'>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\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 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# now let's investigate how mixed the events are\n",
    "probsSimple,accep,rej = runTensorFlowRegression(8,.00001) # train the model for 8 variables and alpha=.00001\n",
    "Signal = df_test['signal'].values\n",
    "\n",
    "df_test_acc = pd.DataFrame({'PROB':probsSimple[:,1]})\n",
    "df_test_acc['SIG']=Signal\n",
    "df_test_acc_sig = df_test_acc.query('SIG==1')\n",
    "df_test_acc_bkg = df_test_acc.query('SIG==0')\n",
    "df_test_acc_sig.plot(kind='hist',y='PROB',color='blue',alpha=0.5,bins=np.linspace(0,1,10),label='Signal')\n",
    "df_test_acc_bkg.plot(kind='hist',y='PROB',color='red',label='Background')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see that the classification is pretty certain about its prediction (the majority of events are at the extremes of the probability), but also that a fair amount of signal events look lot like background events. This is often just a fact of life in HEP analysis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now let's try to train the same model using the full set of 18 features:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t Training with 4500 minibatches, dataset size is 4500000\n",
      "\t Accuracy for alpha 1.0E-10 : 0.790\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 4500 minibatches, dataset size is 4500000\n",
      "\t Accuracy for alpha 1.3E-09 : 0.790\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 4500 minibatches, dataset size is 4500000\n",
      "\t Accuracy for alpha 1.6E-08 : 0.790\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 4500 minibatches, dataset size is 4500000\n",
      "\t Accuracy for alpha 2.0E-07 : 0.790\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 4500 minibatches, dataset size is 4500000\n",
      "\t Accuracy for alpha 2.5E-06 : 0.790\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 4500 minibatches, dataset size is 4500000\n",
      "\t Accuracy for alpha 3.2E-05 : 0.789\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 4500 minibatches, dataset size is 4500000\n",
      "\t Accuracy for alpha 4.0E-04 : 0.787\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 4500 minibatches, dataset size is 4500000\n",
      "\t Accuracy for alpha 5.0E-03 : 0.775\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 4500 minibatches, dataset size is 4500000\n",
      "\t Accuracy for alpha 6.3E-02 : 0.745\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 4500 minibatches, dataset size is 4500000\n",
      "\t Accuracy for alpha 7.9E-01 : 0.637\n",
      "\t Computing ROC curve ...\n",
      "\t Training with 4500 minibatches, dataset size is 4500000\n",
      "\t Accuracy for alpha 1.0E+01 : 0.541\n",
      "\t Computing ROC curve ...\n"
     ]
    },
    {
     "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": [
    "alphas = np.logspace(-10,1,11)\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "it=0\n",
    "for alpha in alphas:\n",
    "    c1 = 1.*( float(it) % 3.)/3.0\n",
    "    c2 = 1.*( float(it) % 9.)/9.0\n",
    "    c3 = 1.*( float(it) % 27.)/27.0\n",
    "    probsSimple,accep,rej = runTensorFlowRegression(18,alpha)\n",
    "    ax.scatter(accep,rej,c=[[c1,c2,c3]],label='Alpha: %.1E' %alpha)\n",
    "    it+=1\n",
    "    \n",
    "ax.set_xlabel('signal efficiency')\n",
    "ax.set_ylabel('background rejection')\n",
    "plt.legend(loc='lower left', fontsize = 'small');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Interestingly the accuracy barely improved! This suggests (as noted in the paper cited above) that machine learning is already doing a good job of capturing the information present in the complex variables using only the low-level variables as input. \n",
    "\n",
    "One thing that does change is that varying $\\alpha$ now has some visible differences in the performance. It looks like increasing $\\alpha$ simply degrades performance so the result is telling us we are most likely not undersampled."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's now try the same with scikit packages. First we will define our function to run the regression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "\n",
    "def runSciKitRegressionL2(nVar, alpha):\n",
    "    X_train, y_train = getTrainData(nVar)\n",
    "    X_test, y_test = getTestData(nVar)\n",
    "    clf = SGDClassifier(loss=\"log\", penalty=\"l2\",alpha=alpha,max_iter=5,tol=None)\n",
    "    clf.fit(X_train,y_train.ravel())\n",
    "    predictions = clf.predict(X_test)\n",
    "    print('Accuracy on test data with alpha %.2E : %.3f' %(alpha,clf.score(X_test,y_test)) )\n",
    "    probs = clf.predict_proba(X_test)\n",
    "\n",
    "    #get signal acceptance and background rejection\n",
    "    thresholds = np.arange(0,1,.01)\n",
    "    Acceptance, Rejection = build_roc_curve(probs, y_test, thresholds)\n",
    "    return (probs, Acceptance, Rejection)\n",
    "\n",
    "\n",
    "def runSciKitRegressionL1(nVar,alpha):\n",
    "    X_train, y_train = getTrainData(nVar)\n",
    "    X_test, y_test = getTestData(nVar)\n",
    "    clf = SGDClassifier(loss=\"log\", penalty=\"l1\",alpha=alpha,max_iter=5,tol=None)\n",
    "    clf.fit(X_train,y_train.ravel())\n",
    "    predictions = clf.predict(X_test)\n",
    "    print('Accuracy on test data with alpha %.2E : %.3f' %(alpha,clf.score(X_test,y_test)) )\n",
    "    probs = clf.predict_proba(X_test)\n",
    "\n",
    "    #get signal acceptance and background rejection\n",
    "    thresholds = np.arange(0,1,.01)\n",
    "    Acceptance, Rejection = build_roc_curve(probs, y_test, thresholds)\n",
    "    return (probs,Acceptance,Rejection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on test data with alpha 1.00E-10 : 0.690\n",
      "Accuracy on test data with alpha 1.26E-09 : 0.664\n",
      "Accuracy on test data with alpha 1.58E-08 : 0.638\n",
      "Accuracy on test data with alpha 2.00E-07 : 0.756\n",
      "Accuracy on test data with alpha 2.51E-06 : 0.767\n",
      "Accuracy on test data with alpha 3.16E-05 : 0.768\n",
      "Accuracy on test data with alpha 3.98E-04 : 0.768\n",
      "Accuracy on test data with alpha 5.01E-03 : 0.767\n",
      "Accuracy on test data with alpha 6.31E-02 : 0.748\n",
      "Accuracy on test data with alpha 7.94E-01 : 0.541\n",
      "Accuracy on test data with alpha 1.00E+01 : 0.541\n"
     ]
    },
    {
     "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": [
    "alphas = np.logspace(-10,1,11)\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "it=0\n",
    "for alpha in alphas:\n",
    "    c1 = 1.*( float(it) % 3.)/3.0\n",
    "    c2 = 1.*( float(it) % 9.)/9.0\n",
    "    c3 = 1.*( float(it) % 27.)/27.0\n",
    "    probs,accept,rej = runSciKitRegressionL1(8,alpha)\n",
    "    ax.scatter(accept,rej,c=[[c1,c2,c3]],label='Alpha: %.1E' %alpha)\n",
    "    it+=1\n",
    "\n",
    "ax.set_xlabel('signal efficiency')\n",
    "ax.set_ylabel('background rejection')\n",
    "plt.legend(loc='lower left', fontsize = 'small');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "This regression shows significantly more dependence on $\\alpha$, in particular the total sample accuracy depends on $\\alpha$, which is also manifested as being able to see clearly the differences in the ROC curves. It also has a slightly lower overall accuracy.\n",
    "\n",
    "The group of points in the middle is indicative of the regression not being able to differentiate well between signal and background events while also having its classification categories well separated. What we mean is that the likelihood that the algorithm comes up with is very 'certain' about its classification, but not accurate. It is understandable that this would happen at large values of $\\alpha$ in L1 regularization because it is turning off most of the input variables and so the classification is basically drawing a line in the distribution of just a few (or even one) input features and saying signal events are on this side while background events are on that side.\n",
    "\n",
    "Let's check and see:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on test data with alpha 5.00E-01 : 0.541\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:ylabel='Frequency'>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\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 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# now let's investigate how mixed the events are\n",
    "probsSimple,accep,rej = runSciKitRegressionL1(8,.5)\n",
    "Signal = df_test.iloc[:,0:1]\n",
    "\n",
    "df_test_acc = pd.DataFrame({'PROB':probsSimple[:,1]})\n",
    "df_test_acc['SIG']=Signal\n",
    "df_test_acc_sig = df_test_acc.query('SIG==1')\n",
    "df_test_acc_bkg = df_test_acc.query('SIG==0')\n",
    "df_test_acc_sig.plot(kind='hist',y='PROB',color='blue',alpha=0.5,bins=np.linspace(0,1,10),label='Signal')\n",
    "df_test_acc_bkg.plot(kind='hist',y='PROB',color='red',label='Background')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exactly as we thought, the events have been distributed into two bins. What is interesting is that we have disfigured the model to such an extreme point that the background test data looks more like signal than the signal test data (recall that the reference point is the signal <i> train</i> data).\n",
    "\n",
    "Now let's check running LASSO regression with the full set of features:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on test data with alpha 1.00E-10 : 0.683\n",
      "Accuracy on test data with alpha 1.26E-09 : 0.706\n",
      "Accuracy on test data with alpha 1.58E-08 : 0.729\n",
      "Accuracy on test data with alpha 2.00E-07 : 0.756\n",
      "Accuracy on test data with alpha 2.51E-06 : 0.784\n",
      "Accuracy on test data with alpha 3.16E-05 : 0.789\n",
      "Accuracy on test data with alpha 3.98E-04 : 0.789\n",
      "Accuracy on test data with alpha 5.01E-03 : 0.783\n",
      "Accuracy on test data with alpha 6.31E-02 : 0.748\n",
      "Accuracy on test data with alpha 7.94E-01 : 0.541\n",
      "Accuracy on test data with alpha 1.00E+01 : 0.459\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABP2klEQVR4nO2deXyU1fX/32dmErKwhRAFgQRcq4JrBCUGBouIKFpaEQPq16U/RNRv1fotWKw7AnW3yGKrbbUYiiIKiqKoASyKSF3AHcWwYxIIgUxgkpn7+2MWZpKZyUyYyXrer9e8kuc+z3Ofc4M+Z+4953yuGGNQFEVR2i6WpjZAURRFaVrUESiKorRx1BEoiqK0cdQRKIqitHHUESiKorRxbE1tQKx07drV9O7du6nNUBRFaVGsW7eu1BiTFepci3MEvXv35pNPPmlqMxRFUVoUIlIc7pwuDSmKorRx1BEoiqK0cdQRKIqitHHUESiKorRx1BEoiqK0cRKWNSQizwEXAz8bY/qGOC/Ak8AIwAFcY4z5byJsuazHVXge58EYwxVrKjC4AQHCC+8JFgxu/89Q19e+JtzPNGsWfTteTU66PRHDVBRFaRCSKPVRERkE7AeeD+MIRgC34HEEA4AnjTED6us3NzfXxJI+6nMCtR2BMYYxa8qj7icRJFs6YAxUm31+Z+F0g9u4aWexeG02QdeBYIzB6TaICMkWTz8HXU7gAAfdnn/PdhbBXW2wIpAkOM2hfmtMOz4vr+IXHSDdJjhqDBWlB+jYNYU0m1BZY3h31wEqaiDFYkg76KZz6UGKu6Zga2fB4XLz0x4n522v4qAL5nVKxtHOQlcXXFF+kH01bhZ0TqEqWbAeMLi+2E2OI4OpBZMYlz+qKf/kitJmEZF1xpjckOcSKUMtIr2B18M4grlAkTGm0Hv8LWA3xuyI1GesjmB0z6uDnIAPYwyXf7Qn6n5aG8aYOs6x9jGAw2XYXuXiqFQraVYJebzFUUPPNBvpVo8T+aaiml90TCLdJlS6DJ/tcbK9yoXTDWIMSVah2u2ZX/kc1jd7nXx1wE0Ht8FtoNIqtPc6tf0WoUuNYWxFNfmu9gw4bxI5J45o1L+XorR0IjmCpiwo6wFsCTje6m2r4whEZDwwHiA7O7tRjGvt1HaO4Y7TbcKx7SXi8QkdkvzH7ZOEM7skHzq2Ced0bUe129DO4nEc6/dWA9CvU5LfmeSU27gA6Nc5mXRv26d7nGyqrKGdRXC6oRjDTouwYM8jyOpHOOAyfL63mm0OF24IchyZLkPB3mqG246gb94t6jgUJQJN6Qjqfk0Ps1hvjHkGeAY8M4JEGqXUJVqnEe7YKoLVeshxnNUlGQxYLYfa+me2q9N2dmY7jkyxBs0+ajuR37gMX5Q7+WG/C4PxOw2DYWdOGn/nILLnEQ6sepgv9lazZ38NbqDSIlgAN9DVZfgfZzq39P+9OgylTdKUjmAr0CvguCewPd4P8S1xhIoRKE2DVaTO14BQbTaLcGx7W9DsI5QTOatLO7q2q6njMLY4XP4uU21C/y7J0CXZ7yjaWQSD57Ffu9zk//AQ29Y/gBvo4AY3hkqLqKNQWj1NGSO4CLiZQ8Hip4wx/evrM9YYATR91lB9z2gK6osRtDRq21/jNnyyxwkEL0H5HES4PoCQjsLhMnxT7uTnShf7dTahtECaJFgsIoWAHegK7ALuAZIAjDFzvOmjM4HheNJHrzXG1PuGb4gjaA4UVxaxoeJ5HK4Sv4NorllDUHcGdTjHTcVBl8EqnpmFj4Y4CB+hHEXgvYHOYazDxu0D/6jOQWk2NFnWUCJoqY6gJXHIaZWSZu1Kt3ZnsfPg2qDjnxyrcJl9OFxuSg9YOCIFUqyGA24LFnMUbraRYvU4LJuIfykHwGVM0PJOuLbDdSjh7k+Eg6gxnjEEziKqXIbv9jj5/oDb7ySOsKTy2FmTGJdzQYPHpSgNQR2B0qTUdix9O14N4G+z0J71e53sr9nHKZ2SSbHidzA90sAWUP8ei8OItT3eDsL3LAg9i/BkOwlHJnXk0TNuU+egJBR1BEqLJbITKaHKJWxzVNM73RbkMGrchhpjSLHWVVGJp4OIxhmEwhjDQbfhs/IatlS5wP//odAjuRMzTr9VHYMSV9QRKK2ecA5jXflMXOag/7oat6HGbUixHb6DqKxxs35vdYNmCoF9Q/i4Q6bLcH3a6cy4dHbUfSpKKNQRKG2WZSumsSPtXdKOTMGx6wDr5/wAQO7kE7GlWgOutHHQVUM7a90+IjkIl4nvTCGwb/+MwVHjb9csJaWhqCNQ2iwTzz6B0m1b6rT3GnYk/SYcQ9qRKaQnHRF2BmHcVioPVNM+re4Mwm0MlgTNFPzPjzBjcOyr0dmCEjXqCJQ2y5js9HqLBxdscfh/j3aJyek0JCXVraKGxM4UAp8BBDmZrm7hrpxf8btz/hCXZyiti+aqNaQoCSfzqJ4hZwThyEm3h5UJD3QQ/Y+82h+wro3bDTZrsIOwWYR+HZPYUllDr3TbYc8WAqutB3RJ5rTOnmWkW7cs4tYti8h0GQaXWrh14J3knzkypr6VtofOCJRWzapF8/nL/14X8ZrAGUEsFFcW1ZkpWKVd0HEgbmN48d2fueK8IxIWVwDfLMETW0h3G36508Ud+XerQ2jj6NKQ0qaJ5Awa6gR8hFpKCjdTKNntqUfI6pJc51xltZulWxz06mijX+fkuMUWQlU+ZxkLU7Iv1SWkNoY6AkVpRMLNFM7sfDMf73mMULpTbmP4y7xibhyTTXLSocB0PGYLdWYK3rqF9m54MGeUOoQ2QiRHoHsWK0qcyUm3c2bnm0mzZgFCmjWLMzvfTE66nTRr15D37NnrYuyIo4KcAHhjC52SqK5y4T7gapByrm+HvnSbhQFdkrisRwojuqeQ0d7GrVsWIQvOoeerFzKveFlDh6y0cHRGoCiNSENnC1f8/nPyzujM2BFH0TUjCUeN4Yu9TrZWuRtsS6jq5s7WNGbm/kGrmlshOiNQlGZCQ2YLZXuqyTujMzdcnk2Wd/e39CQLZ3ZK5ggavr+GiJBiDZ4ldGjn5Mo199Lh3wN58sM/H95glRaDzggUpZkQbrZwcNfZ7Gv3Hhmd6pY9l+x2ctODX9HrhA70O7craR08GeENVW31xCSqg/SPeiR3Vu2jVoDWEShKC8BXv1A7Cymnh52Xtq4k1LJRZkYSANnpVi7qnkpmRhLl+2tYX17NLmM8O7TF4BRsFmFAlyT6uWz+wPK26r1c99G9lG7/XAPLrRSdEShKC+CNHdeFTUl9cel2brg8m5TkQyu9B5xu5i7YzOZKV4NnCrWzjbY5arhpt5MLbEfQN+8W1TpqYWj6qKK0cA5n2chHrxM6cLo9i+RUa8xLR/4lI68AXlcX3NVbU09bEhosVpQWTrggc8EZd5DRKfQKr2/ZyMeWb/exeO6PrHlzJ5UV1Z5v/FF+EfQtGY3onkKvNBulNuHWLYtIKxzI3UXTD3d4ShOjMQJFaSGE00FKs3YNuWxUtqfa/7sv9TQzI4myPdW8uHQ7S/9bHhRkrm+W4KlF8DiEAST5l4we+Pk1HljwGkcmddKd1looOiNQlBZO345XY5V2QW1WaUdGzflkdsgISj21iJDVJZkbLs8m74zObPl2H0uf3cSaN3dSUx1dTUJggVpuRhK90mwgwq6aCq776F4mvXZjIoapJBCNEShKKyCU5pFv9hAp0Fw7htCQwLIxJki+wmIMd7Q7TfdJaGZo+qiitHIiyWc7XKUh20PFELZ8uw+gQUtGud7+tlS5+PPBz5j90iBm95+iS0UtAF0aUpRWTqSK5XA0ZMnIH1Du1o5eaTb2UcN1H93LhNm5LFv6YINsVxoHdQSK0sqJJobw9F0nMf/RU3n6rpPIO6Oz/7ot3+7jk3d2+bOM6ltKDoodpFpxWoS5mUlcufd1Ln3iLFatW5KIISqHiS4NKUorJ1LF8sCncllT9gRi8chc+wLJAP/5bzkQeskovUMSRFgxClWh/FZ3wb3iHgDdJKeZocFiRWnDRBtIrs2xJ2eSe/6RuKSm3mfU1i/q6jKMddi4feAftTq5EdGCMkVRQhJtILk2G78s48O3tpFqOtT7jNqxg1Kbhac6uOj7+f2aatpMUEegKG2YcIHkvRWeALFEWP8p/mYvLzzxXz5augNXTWyxA0TYb7XwxIHP1Bk0A3RpSFHaMJE2yslJt1P430fYY3snqCLZFzsIpNcJHTjl3CxPDUI95Qe16w4whiMsqTx21iRNNU0gWkegKEpIwgaS0+0UVxbR7siPyDLJQOhAsg9fQDnnF504Z3iPiLGDUHUHP5sDXLfmPpW6biLUEShKGydcMdqGiueDZgoAKckWxo44KuSsADzLRUlWGwPP702V7Iv4XM9+zDbPrABwCty+ZRGAOoNGJqExAhEZLiLfishGEZkc4nwnEVkiIp+LyJcicm0i7VEUJXoOJ5D8/BPr2LjqAFYT+btmmlU8QeRUj4y2W4Q/bF7Eb/4yUGsOGpGEOQIRsQJPAxcCJwEFInJSrctuAr4yxpwK2IFHRSQ5UTYpihI9hxNIBvj0k8188s6uiJlFdYLIgNMivHKk4eJvpqrEdSORyBlBf2CjMeZHY4wTmA9cWusaA3QQj5hJe2A3UH9isqIoCSdcRfIFvf+AWbCFF255Equl7oY4gWz8sox5T33GGa7zSba0C3tdUIqpN6uoItnCjF2vaVZRI5DIGEEPYEvA8VZgQK1rZgKLge1AB2CMMaaOsImIjAfGA2RnZyfEWEVRgokUSAYYlz8KS/oPlCctp0tnW9isIpfbxQNznuNPE65jc+rnlDp/Dvm8UEFkp0V4zvEp5y19kAtG3JWoobZ5EukIQs0ba+eqXgB8BpwHHAO8IyKrjDEVQTcZ8wzwDHjSR+NvqqIooYikaurLKupqPC/uSFlFDmcVc158lZ9mfcTEdQVhnQHUDSKXWoXXN78CS1FnkCASuTS0FegVcNwTzzf/QK4FXjEeNgKbgF8k0CZFUeJEpKyiUBSXbqP3xLPJrjo14jIR1Aoii/BMRjsWF7+iKqYJIpGOYC1wnIj08QaAr8CzDBTIZuCXACJyJHAC8GMCbVIUJU40JKuouHQbD8x5jr7Vg+iafETY60KpmM7KbMe4va9rADkBJMwRGGNqgJuBZcDXwAJjzJciMkFEJngvewAYKCLrgXeBScaY0P91KYrSrAiXVSQ17UlLTg17n2+ZaNaZhdxy7J31BpH7dfKuYItQZtMAciJQiQlFURpEJHmKD/67hymFMygu3Rb2/pyuPZhaMInsX3SgcPOzYeMGvneUylIcHpEkJtQRKIrSYCLtlQwwauZgzh+UElarKC05lWdumMG4/FH1BpGhlqQ10A4Lz/b/kzqDKFBHoChKo1NcWRS06Q3AAaebuQs2BzmDnK49+GnWR6wqWc7cHx/D6T4YordDVNa4Wbrz0DVHSAq7Lnsv7va3NnQ/AkVRGp0NFc8HOQEInVVUXLoNy5hsrrrnLn8QOVLVcm1Zip/dVRpAPkzqdQQikici74jIdyLyo4hsEhHN7FEUJSKxZBUZY/wZRXmOy/n3OcvDZhWF2ttAA8iHRzQzgmeBx4BzgbOAXO9PRVGUsITLKirbUx32HoeziimFMwAoyL4+6owiXwWy1hk0jGgcwV5jzJvGmJ+NMWW+T8ItUxSlRRNKq8i4rbyz8gAeebHQ+ArPNn+zjxuOvj1ivUGa9VA/pVZh3N7XmVe87PCNb2NE4wjeF5GHReQcETnD90m4ZYqitGhy0u2c2flm0qxZgJBmzWJA5q0sunkF7n9vJqdrj7D3FpduY/zcSWz+Zh+zziyM6AwCK5DLbBau//gBdQYxUm/WkIi8H6LZGGPOS4xJkdGsIUVpHRT+95F6BeuizSiqnVaqmUR1OaytKo0xQ+JvkqIobZloBes2l3nkyfKzhgLwwnd/oVz2Qa2lpdpCdT+7q+jw4kBuO+oS7rfX2RNLqUU0WUOdROQxEfnE+3lURDo1hnGKorROohWss4gFy5hsek88m/8uWM7wu/4bts/aQnX7k2Dartc0tTQKopGhfg7YAFzuPb4K+Dvw60QZFQvV1dVs3bqVAwcONLUpbY7u3bvTuXPnpjZDaYFEm1rqcnu+4ReXbmNS0TzGW5yk7anG0aXuRoah9jOosQhPbV/M/eisIBLROIJjjDG/CTi+T0Q+S5A9MbN161Y6dOhA7969I2YiKPGlqqqKbdu2qSNQGkSatSsOV0md9r0VbkQEi1j8TsDHQYHCTjYmLd3Bust74UoOvaBRe5lor81wd9F0XSKKQDRZQ1Uicq7vQETygKrEmRQbBw4cIDMzU51AI5OSkkJ1dfh8cEWJRKRtMN3/3oy77kaFAJRZhZxPyzlzwRbSdjshTLJLYFqpFpzVTzSO4EbgaRH5SUSK8WwvOaGeexoVdQKNj/7NlcMhVGrpmZ1v9gvWZWeG3twm0+357y7n03Iumvo1aRGK0wJlKLTgLDL1OgJjzGfGmFOBU4B+xpjTjTGfJ9605svAgQOZNm2a//jee+/l9ddfD3t9bm7IjK2oufbaa8nKymLmzJkhzz/++OPk5eVx8cUXs3fvXgDsdjv5+fnY7Xbsdjv79+8PuueVV17hF7/4RZBtNTU1XHvtteTn5/O73/3usGxWlPrISbdzUffnGN1zMRd1fy5ItXRqwaQ6exok25KoSU1jTI8UJnZrx6pUK32X7sDqrDt7qCNDgWc2sfPLl1i1bklCx9USCesIRORK78/bReR24LfAbwOOWxTz5s2jd+/eWCwWevfuzbx58xrUz5YtW8jJyeHdd9+Ns4Xheeihh3j44YdDnispKWHJkiV88MEHFBQU8PTTT/vPvfnmmxQVFVFUVET79u2D7hs8eDBffPFFUNuSJUvo0aMHq1atwuFwsHr16vgPRlGi4NwzMvj7A2fw70dP5em7TmL4wB4YA+VOB0aEUpuFuRlJbP5mX8RlokAZCgPc0TOVJ1ZPq3NdWyfSjCDd+7NDiE/7cDc1R+bNm8f48eMpLi72iFsVFzN+/PgGOYOXX36ZK6+8kqOPPpoffvgh6NxPP/1Efn4+v/nNbzj99NP58MMPAXC73dx4440MGDDAP5N45513OO+88+jfvz/Tp3vS23bu3Mk999xT55ndu3cPa8/atWux2+2ICMOHD4/65Z2ZmUlycnDmxYcffsiwYcMAYupLUeKJb8MbSapERMjqksyVl3Sl/6npQdc5LUJhJ5t/mSgc/niB14G8foTReEEtwjoCY8xc76/LjTH3BX7wbCvZYpgyZQoOhyOozeFwMGXKlJj7evfddxk2bBgFBQW8/PLLdc5v3bqVwsJCXnvtNf70pz8BUF5ezuTJk/nwww+ZP38+AHl5ebz33nusWbOGV199laqqKrp168Z9990Xkz3l5eV07NgRgE6dOrF7927/uQsvvBC73c7FF1982H0pSmMRqsYgOVnq1BiAZ7nHRyzxgmcdn+oSUQDRBIv/EmVbs2Xz5s0xtYdj69atfPHFF4wcOZJp06aFjAv07duX5ORksrOz/ev1GRkZ5OTkYLFYSE31rHt++umnDB06FLvdzo8//sjPP0femSkcGRkZVFRUAJ4XeZcuXfznfEtDPjuHDRuG3W7nq6++irkvRWksYpGvznQdWg6KNV4w4ttpqknkJVKM4BwR+T2Q5YsLeD/3AtZGszAOZGdnx9Qejpdffpknn3ySt956i7fffpsTTjiBTZs2BV3z5Zdf+ovcOnXyFGCHyrCZPn06Tz31FO+//z7Z2dk0dKe43NxcioqKAFi2bBl5eXlhr3377bcpKiripJNOCnn+7LPP5u23346qL0VJFOHkq3eX1wRfl5yKvftxTOzWjjE9Upixo4r0V7dFFS/wVR6rQJ2HSDOCZDyxABvB8YEK4LLEmxY/pk6dSlpaWlBbWloaU6dOjamfhQsXMnjwYP/xeeedV2d5qEePHowePZqRI0fywAMPhO3rN7/5DWPGjOHKK68kPd2z9hkuRnDnnXfy8MMPM3PmTH7/+98DHkeyadMmsrKyGDlyJHl5eRQWFjJx4kT/fb6lIbvdzs6dO4P6LCoqYujQoXz33XcMHTqUXbt2MXLkSLZu3Up+fj6pqamcc845Mf19FCUehKsx6Fw9lJyuPRARcrr24H/sl7F073ZKbRZ/APmFLQ46PvZd2L6D6guAg7i5fe2MhIyjJRGN+miOMaa4keypl9rqo19//TUnnnhivffNmzePKVOmsHnzZrKzs5k6dSrjxo2Lq20//fQTd9xxR8jYQWsk2r+9osRKcWURGyqex+EqJc3alb4drw5KLwXoPfFsiku31bm3a42bi64/OqQMhTEGh8uwfm+Nv/IYYzCXf5iIYTQrDkt9FPibiIw2xpR7O8sA5htjLoijjQln3LhxcX/xK4qSGHLS7XVe/LXxKZPWpswq9A0jQxFKj8gCTHrtRmZcOjseprdIogkWd/U5AQBjzB4g/C4RbZjevXu3mdmAojQ1YauPXaZeGYrAeIFbhCcOfNamU0qjmRG4RSTbGLMZPEtFeGozFEVRmoTiyiL+/H+9wdaV0oBNbdoZKNjrCSrnfFpOzqflvPTIKSH7CIwX+FJK22q0IBpHMAX4QERWeI8HAeMTZ5KiKEp4DhWcHQTEv6lNVvsudE/Jo3DpP5nZJYlMl6Fgb01Y2WqHK/j77G6rsGrdEvLPHNlII2k+RKM19BZwBvBvYAFwpjFG860URWkSwm1qU3BRd/5Z9HJQFtHcjCRsy3fVqS8wxgRvZINnmWPUd1Pb5BJRNDuUCTAcOMMYswRIE5H+CbdMURQlBOEKzrDtx+EMVsh3WoTXiiuD4wXGICJ1C81EKLNZeOLAZzz54Z8bYSTNh2iCxbOAc4AC7/E+4Onwl7d+mpP6aGlpKXl5eQwePJghQ4awfbsnk6I+9dEdO3Zw/vnnM3DgQJ5//nkAKioquOSSSxgyZIi/XkFRmhvhCs5Kw0hM+PYw8MtWh9nv2IfTIjxY/Grc7G0JROMIBhhjbgIOgD9rqO6CWzNn1aL5TDz7BMZkpzPx7BNYtWh+g/ppbuqjGRkZrFy5khUrVnDNNdfw7LPP+s9FUh+dPn06kyZNYuXKlcyePZuqqirmzp3LpZdeyvvvv09VVRVr1qxJ6LgUpSGEKzh7Z2Xo7WoDZSgcIWQqoG6hWZnFtCktomgcQbWIWPFmColIFhB6+6BaiMhwEflWRDaKSMh94kTELiKficiXAQHpuLJq0XzmTrqJ0m1bMMZQum0Lcyfd1CBn0NzUR61WK1arZ42zoqKCvn37RjWOtWvXct5552Gz2cjNzeXLL7/kxx9/5LTTTgPgjDPOYNWqVVH1pSiNSbhNbS479dY6exikWpP8WUQQXpiuduBYoE3JVUfjCJ4CFgFHiMhU4APgofpu8jqPp4ELgZOAAhE5qdY1nfEsPV1ijDkZGB2T9VFSOOMenFW11g6rqiicUfelWx/NTX0UYP369QwYMICZM2dy+umn+9sjqY/W1NRgsXj++X1KoyeeeCLvvfceAMuXL6e8vDxmWxSlMQi1qc24/FE8c8OMIBmKv058lBHdjvXfF0qYzmUMVoHLeqT4g8dukTYlV11v+qgxZp6IrAN+icdR/soYE178+xD9gY3GmB8BRGQ+cCkQKH05FnjFV6NgjGmYBGc9lG3fGlN7OALVR91uN1VVVUyaNCnomkjqo0CQ+ug999xDdXW1X33Ud02s9OvXjzVr1rBgwQKmT5/OnDlzAM/SUOCS0LBhw3A6ncyaNYukpCRcLhdWq9WvNPrb3/6WiRMnMnToUPr06UO3bt0aZI+iNBXj8kcxLn9UcGP+KF7K7wauGnI+LQdgw4juODKSSK50cTDNSorV86WodtXxs45PubgNpJRGUh/t6P3ZBfgZKAReBHaJSIb3G38kegBbAo63etsCOR7IEJEiEVknIleHsWW8iHwiIp+UlJTU89i6ZB7VM6b2cDRH9VGn0+n/vVOnTn4Bu1AEqo/m5uby/vvvU1NTw7p16+jbty9paWn84x//YPny5Rhjot7HQFGaE8WVRbyx4zpe2noJb+y4juLKIpwPzQ5SKe342HeMvuMLbE43YgkfPN5tFQqXPtYUw2hUIs0IXgQuBtbhiQ9IwE+A9iLyV2PMH8PcH2p389pvOxtwJp7ZRirwoYh8ZIwJkg80xjwDPAMe0bkINoekYNJ9zJ10U9DyUHJqKgWTYluGWbhwIa+99pr/OJL6aHFxMbNmzQrbl099tF+/fkHqo7Nnz66zPHTnnXeyePFiXC4XmzZt4tFHH2X69OmMGTOG3bt3c9ttt2G1WklLSwsKFl944YX++MH8+fODvuFPnjyZq666irvvvpsbb7yRlJQUPvvsM2699VasVitXX301vXv3junvoyhNja/YzFdn4HCVsKbsCZ5bs4VSm+d7b6lNmOv91l9f8LiLy1C2Z0cjWN601Ks+GvZGz4xggzEmpPykiJwD3OsTpxOROwGMMdMCrpkMpBhj7vUePwu8ZYx5KdxzG6o+umrRfApn3EPZ9q1kHtWTgkn3kT/qiihGGj2qPqooTcsbO67D4aq7alCy28lNDwZvyBRJpbSyxs3SHZ4spEyX4fq001u8KF0k9dGoCspE5EoR+ZP3OFtE+htjXOGcgJe1wHEi0kdEkoErgMW1rnkNyBcRm4ikAQOAaOIPMZM/6gpmffQt/95cyayPvo27E1AUpemJZXczn0pp2Krj7in0SrP5i8xac+A4loKysd7jqArKjDE1wM3AMjwv9wXGmC9FZIKITPBe8zXwFvAF8DHwN2PMhphH0UxQ9VFFaVrCFZuVhUgbDalSGqbq2CdK11pJaEGZMWapMeZ4Y8wxxpip3rY5xpg5Adc8bIw5yRjT1xjzROxDUBRF8RCq2My4rSx8O3imEFhfEG3VsU+UrjWS0IIyRVGUxiRUsdmAzFu5bsBddeoLBptghxFN4HjugrtapTOIRoa6dkHZZcBdCbVKURSlgYTa3Swnnzr1BcWTXHx83wT/cUS5amMoswpvnZZK1eppra6uIOKMQEQswCbgD8A0YAeegrKwWT1tgeYkOgewYcMGLrjgAgYPHszcuXOBhonOVVVVcfHFFzN48GCGDh3K7t27D8tuRWnO5FxwGUf/+lr/cbSB49ePMK1OnTSiIzDGuIFHjTHfGGOeNsbMjLKquNlRvOxl3hh1Gi/lZfHGqNMoXtawoG5zE50DT53BSy+9xIoVK7jhhhv87bGKzr355pv07duXFStWMGbMGF544YWEjUlRmgPfDBjI/x6d6S80S391W1SB49amThpNjOBtEfmNhCqPbSEUL3uZddNvw7FrKxiDY9dW1k2/rUHOoLmJzv34449UV1dz5ZVXcsEFF/DNN99ENY5QonPHHXccDocD8OgjZWVlRdWXorQUAquOF2y6gufWPMhOp8O/kc0LWxx0fOy7egPHrU2dNBpHcDvwEnBQRCpEZJ+IVCTYrriyYc6DuA4Gi865DlaxYc6DMffV3ETndu3axZdffsm//vUvHn30UW6//Xb/uVhF54455hg2bNhA3759ef755/nVr34Vky2K0pzxVR17Cs4MklTJNb/uRt4Znf3XOC1CYSdbVIHj1iQ9Ec1WlR2MMRZjTLIxpqP3uGNjGBcvHD9vi6k9HIGic9OmTQsZF4gkOmexWIJE54YOHYrdbveLzjWEzp07k5ubS8eOHenbty+lpYfS5HxLQz47hw0bht1u56uvvvKLzgF+0bl//vOf2O12NmzYwH333cf999/fIJsUpTkSbovLsSOOCmors0pkuWpjOCBQnNp6YmjRzAhaPGlH1Na6i9wejuYoOnfcccdRUlLif2bHjuF9dH2icwBdunQBPA5GZaiV1kS0VcedawwnL92O5aArqL3GbVi/twZEqLRaWN4rrdVUG0eTPtri6TvhLtZNvy1oecjaLpW+E2LLgm2OonN9+vTh9ttvZ8iQIbjdbp566in/fbGKzo0bN86/5FVTU8Nzzz0X099HUZozadauIXWIgqqOa9zsWbeHP7xaRa/vK+k34WjSu6fidLlxAwO6JNHPZWP93ppWJVPdYNG5pqKhonPFy15mw5wHcfy8jbQjetB3wl3kXHBZXG1T0TlFab7UViYFT9Vx4eI9vLriB3C4YP1e2BIcT1z58zs8/t1D2ALkqmvchk/2VLPVUcOEb1OY9af3G20cDSWS6FzYGYF3H4KwGGNa1AJZzgWXxf3FryhKy8FXZLah4nkcrlLSrF3pm3E1l99sR24JnxRZuPnZICcAhzKIHPuqW4VMdaSlocB9CLKBPd7fOwObgT6JNq6loaJzitK8CVV1XB9lztCbYaVZhTKr8O5ZnZn02o0tWqY6bLDYGNPHGHM0HvXQkcaYrsaYTDyb1bzSWAYqiqI0JZnJoetpHC4DIq1CpjqarKGzjDFLfQfGmDeBwYkzSVEUpXEJFys1xlCQfT3JlmCBOn8GkZeWLlMdTdZQqYjcBfwLz1LRlUBZQq1SFEVpZH7a/74/fmCq0yh8YweWMdlkZx7FhLG/YnPq55Q5SzjgcmMwdTKIdltbrPhCVDOCAiALjwLpq8AR3rY2S2OKzlVWVjJs2DAGDRrEkCFD+Omnn+pc8/jjj5OXl8fFF1/sL2JriOjc4sWL/dfn5OTw5JNPNthuRWlJhKo6/vWI9gw8vRPFpdt4YM5z5Dku5+ZjJ2MTSLFa6mgQdXG1rAzMQKKpLN5tjPmdMeZ07+d3LS1jCGDeqkX0nng2ljHZ9J54NvNWLWpQP40tOmez2fj73//OypUrufPOO+uIz5WUlLBkyRI++OADCgoKePrpQ5vHxSo6d8kll/ivP/7447n00ksbZYyK0tTUV3XscFYxpXAGhZufxRoig+iUTjbydrlarP5QNHsWHy8iz4jI2yLynu/TGMbFi3mrFjF+7iSKS7dhjKG4dBvj505qkDNobNG5du3a0aOHpwI6KSkJmy14NW/t2rXY7XZEhOHDh7N69eqoxhFKdM5HaWkplZWV9O7dO/o/jKK0YKKpOt5ctj1sBlGqVVhylI1R301tkUHjaJaGXgI+xbMZzf8FfFoMUwpn4HAGF4n4PHysNJXoXHV1Nffffz//+7//G9ReXl7ul5Xwicf5iFV0zscrr7zCqFGj6tyjKK2VaPY6zs48KmIGkQnIIGpp+xVE4whqjDGzjTEfG2PW+T4JtyyObC7bHlN7OJpSdG78+PFMmDCBY445Jqg9IyODigqPGKxPPM5HrKJzPl5++WUuu0yL75S2Q6i9jg843by41POOSEtOZWrBpKgziKZufo2WRDSOYImITBSR7iLSxfdJuGVxJDvzqJjaw9FUonMPPvggffr0YcyYMXXO5ebmUlRUBMCyZcvIy8sL2080onOlpaXs27ePPn20XlBpO9Te69hUp/PK0v2s/nQvOV178MwNMxiXP4r8rKHccPTtdE0+AozhoMtQYzwZRCO6taNXqkfbq1Ra1rbu0aSP/o/3Z+BykAGOjr85iWFqwSTGz50UtDzk8/Cx0BSic9u3b+e+++7zLyWdc845TJs2LUh0buTIkeTl5ZGRkcG8efP898YqOgewaNEiXRZS2iS1q44vvxm4ue51+VlDyc8ayt8+fpg3q9/E6l1iTbcJud6YgmNfNatakBhdmxGdm7dqEVMKZ7C5bDvZmUcxtWBSnc2sDxcVnVOUtsPEdQWUOusu6Tpq3LjX7KZ3VZdmJUbXING5gJuvDtVujHn+cA1rTMblj4r7i19RlLZLpAyi93ukIttaTpZ9VBITAZ984F7gkgTa1GJR0TlFaTtEyiAqs3k2rmkp2UPRFJTdEvD5f8DpQHLiTVMURWl6Aje8f2PHdRRXFgHUm0HktAgPFr/ayNY2jIZsVekAjou3IYqiKM2N2tITDlcJ68pnUlxZFJRBZIyhssbNJ3uq2VJ1aIvLMotpEdXG0VQWLxGRxd7PG8C3QMtKklUURWkAoaQnXOYgGyo8IdL8rKHMOrOQr8s8hWe100i7uAyFSx9rXKMbQDQzgkeAR72fh4BBxpjJCbWqmdPcROc6dOjgF4tbv3490DDROfCkmZ533nkMGjSIjz/+uMF2K0prIJz0RGD7qpLl9O2aQrotWIiuT4qF/tuqWsQOZvVmDRljVojIkXiCxQDfJ9akxLBq3RIKlz5G2Z4dZGZ0p2DE7Q3K8Q0UnbvzzjsTYGkwPtG5Hj168Pbbb/Pwww8HCcsBnHDCCf6iskDefPPNOmJzPnyicz6HMXr0aPbs2cNrr73Gu+++G7IITlHaGuE2vDfVafSeeDaby7Yz8rfH0K598Hdqm0Xo39HGry1woEcaxV8vJefEEY1ldsxEszR0OfAxMBq4HFgjIi1Kf2DVuiXMXXAXpXu2YzCU7tnO3AV3NWjtrrmJzgH88MMPDBo0iBtvvJEDBw5ENY5QonNvvfUW7dq14/zzz+eqq66qM4tQlLZGKOkJ47Yyd+H3fhHL5PTQX5pcSRau6JnG749K5tFV91L89dKQ1zUHolkamoJnl7L/McZcDfQH/hRN5yIyXES+FZGNIhJ2OUlEzhIRV6IcTOHSx3BWB78gndUHGrR219xE5wA2btzIypUr6d69e1A1c6yic7t27aK8vJx33nmHgQMHMnPmzJj/PorSmqgtPZFmzaJw8R7e+/hQIZljX03Ie31CdKU2C3M7WXls9UONZHXsRCMxYTHGBJbPlRHdTMIKPA2cD2wF1orIYmPMVyGum4Fnb+SEEG6NLta1u0DRObfbTVVVFZMmBctURBKdA4JE5+655x6qq6v9onO+a0IRTnQOIDMzE4DRo0cHxS5qLw0NGzYMp9PJrFmz/KJzVqvVLzrXuXNnhgwZgohw3nnnMXXq1Jj+PorSGqktPTFyVXbQ+fUflJJ7/pHYkg69FkMJ0b2YVkNz3eopmhnBWyKyTESuEZFrgDeAaOY4/YGNxpgfjTFOYD4QaqeTW4CFQGT5zcMgM6N7TO3haI6ic5WVlX4V0ZUrV3LssceG7ac+0bm8vDw+++wzwOOojj66xchJKUqjUVuscsu3+/jknV1Uljsx7ghCdM14K8uIjkA8b7CngLnAKcCpwDPGmGjU2noAWwKOt3rbAvvvAYwC5tRjx3gR+UREPikpCV3WHYmCEbeTnJQS1JaclELBiNtj6mfhwoUMHjzYfxxJdG7kyJE88MADYfvyic5deeWVQaJztWMEPtG59957D7vd7g9QT58+nU2bNvH9999z1llnMWjQIJYuXcrvfvc7/72+pSG73c7OnTuD+p08eTLTp0/3xxZSUlI45ZRT6N69O3a7nX/+858hl6EUpa0ztWASacmpQW1bvtzL0hvWsea+r7CG2cqyU03zdQT1is55hYrOjLljkdHABcaY33qPrwL6G2NuCbjmJeBRY8xHIvIP4HVjTESNhoaKzsUraygSKjqnKG0Dn4hlcclWcLhg/V7YUsWIheeQ3j21zvWOGjf71lTx4JApTaZIeliic8BHInKWMWZtjM/dCvQKOO4J1N4JJheY71066QqMEJEaY8yrMT6rXvLPHNliJGEVRWnejMsfxblnZLDs62l0OiKJsu1VvDj9G9KOTAl5fapV+KgH/HmFZ8bf3N5F0cQIhgAfisgPIvKFiKwXkS+iuG8tcJyI9BGRZOAKYHHgBcaYPsaY3saY3sDLwMREOIHGQkXnFKVt4JOeyOiWjMUiZPVM44Y/n8KR1aE3pPEJ0b3dox1PrJ4W8pqmJJoZwYUN6dgYUyMiN+PJBrICzxljvhSRCd7zEeMCiqIozZVQ0hMpaTZOy0zh3Qo3LsshvaHaQnQruja/3cuicQT7omyrgzFmKbUyjMI5AGPMNdH0qSiK0tSEk57olJHMxG7/S+HmZyk5uAuHy+MEAoXodjfD7KFolob+C5QA3+GRlygBNonIf0Uk5iCyoihKSyfN2jVsu0+IrmjzAdbvraFfJxuX9Ujxp5J2cTU/RdKo6giAEcaYrsaYTDxLRQuAiUD4TXlbMY0pOgcwaNAg7HY7AwcOZMOGDUHnNm/ejN1uZ/DgwVx44YWUl5cDDROdKyoqolevXtjtdn75y18els2K0poJJT1hlXb07XhoQ8fxOf3JzUiqI0Y38KCrwRI3iSIaR5BrjPFX/Rpj3sajQPoR0C78bc2L4q+X8sbfLuSlx0/njb9d2GDdj0DRucbi3XffpaioiGnTpvH4448HnevYsSOvvPIKK1asYNSoUfz1r3/1n3vzzTcpKiqiqKiojvicT3Ru5cqVzJ49m6qqKgDGjBlDUVFRo45PUVoaoaQnzux8c1AF8p7kXdgswctANouQ0jOtwRI3iSIaR7BbRCaJSI738weg3CsN0fyiHiEo/nop65bfj2PfDsDg2LeDdcvvb5AzaGzROfCIzQFUVFTQr1+/oHOdO3emS5cu/utCidKFIpToHHiK5vLz83nyyeZaDK8ozYOcdDsXdX+O0T0Xc1H354KcAITf09ikWdl/VEqzkqeOxhGMxVMD8Kr30wsowJMJdHmiDIsnG/7zF1w1waJzrpoDbPjPX2LuqylE50pKSsjLy2PixIkMGjQopF179+5l7ty5XHPNNf62WEXncnNz+fbbb3n33Xd56623WLduXcx/H0VRPETa0/jdXmnU9OnSyBaFJ5qvj+0Dq4HBoxbqLTDbmBiz4otj386Y2sPRVKJzWVlZ/Oc//+Hjjz/mj3/8I2+99VbQ+erqasaOHcsjjzxCRkaGvz1W0bnAay+55BI+//xzzjxT8wEUpSEUZF/P3B8fw+k+lGbqSyV1WoSVof1EkxDNjOAVryYQACIyCHgucSbFn7QO3WJqD0dTiM7V1NTgdntW4Dp16uTXJQpk4sSJXH755Zx77rkR7a9PdK6iosJ/7apVqyIK2CmKEhnfnsaVNe6QexqXWSLL+zQm0TiCG4BXRaSbiIzAI0LXfLfaCUHfvFuw2oJLv622FPrm3RLmjtA0hejcrl27GDJkCEOGDGHixIl+aWif6NyHH37Iiy++yN///nfsdnvQ2n6sonMLFiygf//+DBw4kB49eoRdhlIUJTrys4aydruTl7cdYOnOg0H1BM0pjbRe0TkAETkHjwLpAeAiY0zsEqBxoqGic8VfL2XDf/6CY99O0jp0o2/eLXHfOk5F5xSlbVNcWcSGiueprCmhvMLFC0u2UkUKu09O5sTOSaRZBYfL8HV5Nb/4dh+9q7ow60/vN4ptDRKdE5ElQKCXSAP2As+KCMaYS+JrZmLJOXFEs94zVFGUlo1Pf8hlDiICGZ2sjL+8Fy+vLKFPRjLirShOtwm5XZI5NTOZPT/samKrPUQKFj/SaFa0ElR0TlHaLiH1h5It/GpQFm/uqrWXuEX46Nj25Bx0N4uN7cM6AmPMCgAR6QPsMMYc8B6nAkc2jnmKoigtg3D6Q+lJobWFUqzCXzOSsa5+iCeb2BFEEyx+ieDCMZe3TVEURfESTn+osjp0HNbhMv69jJs6aByNI7B59xwGwPt7cuJMUhRFaXmE0h864HTz6soSamrtUxAoTV1qlSaXm4jGEZSIiD8wLCKXAqHnQG2ExhadA4+4XLt27eqIzgE8/vjj5OXlcfHFF/uL2BoiOudj2rRpcbFZUdoSgfpDxsCevS6eWbCFzz+20N9yAQdchKwn6FDtbnK5iWgqiycA80RkJiB4NqS/OvItzY95xcuYsmEOmx0/k512BFP7TmBczgUx9xMoOufbSL4xmDFjBnl5eXXaS0pKWLJkCR988AEvvvgiTz/9NH/84x+BupXFgfhE53wOY/To0aSmprJv376QzkZRlPrJSbcHaQ6NP/nQuXnFp3PtR/fRLd1Kv042BnRJosplqPx2H5kZ3Rvf2ADqnREYY34wxpwNnAScZIwZaIxpEdISPuYVL2P8uukUO3ZhMBQ7djF+3XTmFS+r/+ZaNIXo3KZNmxARsrOz65xbu3YtdrsdEWH48OGsXr06qnGEE5178sknuemmm6L/gyiKEsSqRfOZePYJjMlOZ+LZJ7BqkUdfbFzOBdzY/awgaeo0m4WsEzqwL9PZpHGCaJaGEJGL8Ow/cJuI3C0idyfWrPgyZcMcHK7gtC6H6yBTNsS+W2ZTiM7NmDGDO+64I6Q95eXldOzYETgkHucjVtG5vXv3sn79egYOHBjjX0VRFPA4gbmTbqJ02xaMMZRu28LcSTf5nUF1+s91pKmxWag6MalJ9yio1xGIyBxgDHALnqWh0UBodbRmymbHzzG1hyNQdG7atGkh4wKRROcsFkuQ6NzQoUOx2+1+0blQ+GYdvXv3Dnk+IyPDrxHkE4/z4duPwGfnsGHDsNvtfPXVV37RucD7nnjiCW6++eaY/iaKohyicMY9OL17e/hwVlVROMMz0w8nTS3tLOzOosmCxtHMCAYaY64G9hhj7gPOwSNF3WLITjsipvZwNIXo3Oeff86XX37J8OHDeeedd5gwYQLV1dX+87m5uRQVFQGwbNmykHEEH/WJzm3cuJGpU6cyfPhwvv/+e/+SlaIo0VG2fWudtl7DjqT/X3rx0tZLuOioNHqlWetc43AZPu6R2mRB42iCxT735hCRo4AyoE/iTIo/U/tOYPy66UHLQ2nWdkztOyGmfhYuXMhrr73mP44kOldcXMysWeF38vSJzvXr1y9IdG727NlBy0O//vWv+fWvfw3ANddcwx133EFSUhLTp09nzJgx9OnTh5EjR5KXl0dGRgbz5s3z33vhhRditXr+o5s/fz7duh1SW508eTJXXXUVd999t1907oUXXvCfz83NZfLkyTH9fRSlrZN5VE9Kt23xH/cadiS5k0/ElmoFDKlWyM1IBpxscXhm5L5U0t1WabKgcb2icyLyJ+AvwC+Bp/HoD/3VGNMkcYKGis7FK2soEio6pyhtG1+MwLc8NOKVgaR3T61z3f5qN0t3VOFweZzAlioXmTVuFh0/hfwzRybEtgaJzvkwxvi0lBeKyOtAijFmbzwNbAzG5VwQ9xe/oihKIPmjrgA8sYKy7VtJOzIl5HXpNmHN7mp/GukpLhtJPx0IeW1jEE2wOEVEbheRV4AXgetEJPTo2jgqOqcoSv6oK5j10bf8e3Ml6Umh45DVriTOqpVGmtQ7hVn/ub9JMoeiCRY/D5yMZ3loJnAi8ELEOxRFUZSQshNWacf3lVasIdJIq/ulN0nmUDTB4hOMMacGHL8vIp8nyiBFUZTWgq/KeEPF8zhcpaRZu9K349X8e/ODIa+XdhaKU8sa0UIP0TiCT0XkbGPMRwAiMgD4T2LNUhRFaR3Ulp0AyEyeS6mzbu2Qw2VY06NucDnRhF0aEpH1IvIFMABYLSI/icgm4ENAN7NVFEVpIAXZ11PjDs7YDEwjbWwixQguBkYCw/HUDQwG7N7fL0q4Zc2YxlYfPe644/wqou+8806d8/FSH33nnXc499xzOffcc7nqqqv8lceKosSX/KyhfLe7msoadx1F0qbY1D7SDmXFjWlIollVspzCzc9S5iwhMzmLguzryc8aGnM/TaE+2qlTJ3/1cG3iqT46ePBgPvjgAwCuvfZaVq9eTX5+fkLGpChtFd8G93ef1pmygy7e2ulJG/WlkVp+2M/cBXcBJKymoDZRic41FBEZLiLfishGEalTpioi40TkC+9ntYicGqqfw2VVyXLm/vgYpc6fMRhKnT8z98fHWFWyPOa+mkJ9dP/+/QwePJixY8cGicpBfNVHk5M9+w0ZYzDG0KdPiyogV5Rmj2+De4erBBHommLliuw0ftExyZ9GmnJMe5zdGnezmoQ5AhGx4qlEvhCPhHWBiJxU67JNwGBjzCnAA8AzibClcPOzON3B6qNO90EKNz8bc19NoT76n//8hxUrVjB8+HDuvffeoHPxVB8FeOGFFzj55JMpKSkhKysr5r+PoijhCbXBvc0i9OuUFNiA+7TOjao7lMgZQX9gozHmR+/2lvOBSwMvMMasNsbs8R5+BPRMhCHhFP/CtYejKdRHATIzMwEYPXo0n332WdC5eKqPAlx11VV89dVX9O7dm0WLFsX091EUJTLhNrhPqxUglnYWavp0CXltIkikI+iBZzczH1u9beG4Hngz1AkRGS8in4jIJyUlsb28ATKTQ3+zDdcejqZQH3U6nRw86PkGsXLlSo499tig8/FUH/U9B6Bjx45+MTxFUeJDuA3uHS5T53hl18g6cPEkkY4gVA5UyJGJyBA8jmBSqPPGmGeMMbnGmNyGLFcUZF9PsiW4ui/Z0o6C7Otj6mfhwoUMHjzYfxxJfXTkyJE88MADtbvw41MfvfLKK4PUR2vHCPbs2cPAgQMZNGgQjzzyiH/paPr06WzatImsrCy/+mhhYSETJ0703+tbGrLb7ezcuTOo38mTJzN9+nQGDRrkVx99/vnnsdvtDB48mN27d3PRRW06OUxR4k6oSmNP2mh1reMayqw0WvZQveqjDe5Y5BzgXmPMBd7jOwGMMdNqXXcKsAi40BjzXX39NlR9NF5ZQ5FQ9VFFUeqjuLKIZT/9mU4dLZTtqaao3EmleJaHaquRXr4xlVl/ej8uzz0s9dHDYC1wnIj0AbYBVwBjaxmWDbwCXBWNEzgc8rOGxv3FryiKEis56XYm3H+1fzn4uJM6UnxiR45MtwWpkVp+2N9oAeOEOQJjTI2I3AwsA6zAc8aYL0Vkgvf8HOBuIBOY5V1HrwnnsVoCqj6qKEo0ZGceRXHpNgC+/6qCETlppPRM9QvRpdkEjmlPujN0HVC8SWgdgTFmqTHmeGPMMcaYqd62OV4ngDHmt8aYDGPMad5Pi3UCiqIo0TK1YBJpyYc0hWw9UkOqkVadlNwo9iTUESiKoih1GZc/imdumEFO1x6ce0YGo47vwGU9UxnRPSVoT+MaSzVPfvjnhNujjkBRFKUJGJc/ihUPT+e2q473b1CTbrOQm5HsdwYOl+HB4lcTbos6ggbQ2KJzW7du5ZJLLsFut9epPC4tLSUvL4/BgwczZMgQtm/fDjRMdG7p0qUMHDiQc889l5tvvvmwbFYUpX4iVRr700gtia8nSGTWULPCJ/QUuDlEbY3waGgK0bn/+7//Y/bs2fToUbceLyMjg5UrV2K1WvnnP//Js88+65e2iFV0rm/fvqxcuRKbzcbYsWNZu3YtZ511VkLHpihtmUiVxj410kxX4h1Bm5gRBAo9gcHhKmFd+UyKK4ti7quxReeqq6v56aef+P3vf895551XR1TOarVitXqmkRUVFfTt2zeqcYQSncvOzsZm83w3SEpK8v+uKEpiiFRp3K+TjT4pFgaXJv413SYcQajpl8scZEPF8zH31diic6WlpXzxxRc88sgjvPjii9x66611nrl+/XoGDBjAzJkzOf300/3tDRGdA1i3bh2lpaVBfSmKEn8iVRqn2yyc1iWZDr0yE25Hm/jKF276Fa49HIGic263m6qqKiZNClbFiCQ6BwSJzt1zzz1UV1f7Red81wTSuXNnjj/+eHr29Ojx2Ww2ampqgr6t9+vXjzVr1rBgwQKmT5/OnDlzgLpLQ8OGDcPpdDJr1iy/6JzVag0Sndu6dSu/+93vVHBOURqBwD2NK2tKcLjcrN9bzRaHRxDSZhFKM/cz6bUbmXHp7ITZ0SZmBOGmX+Haw9EUonOpqal07tyZvXv3UllZidPpDHICTqfT/3unTp0iCsXVJzq3f/9+xo4dy5w5c1SCWlEaiZx0Oxd1f46FW6tYuuOA3wn4SLUKzzo+TagNbWJG0Lfj1awrnxm0PGSVdvTteHVM/SxcuJDXXnvNfxxJdK64uJhZs2aF7csnOtevX78g0bnZs2fXWR6aOnUqF198MdXV1X4hu+nTpzNmzBh2797NbbfdhtVqJS0tjWefPbTHwoUXXuiPH8yfP59u3br5z02ePJmrrrqKu+++2y86N23aNH744Qd/xtB9990XJLKnKEriyEzOCruhfaL3MU6Y6FyiaKjoXLyyhiKhonOKojSUVSXLeWXrDE7NSPYL0H2+x8nCbQdw7KumtOCjw+q/qUTnmhU56fa4v/gVRVHiRXaajQGZKVi9C/bpNqF/ZjtqDOzb3Dmhz24TMYLGQkXnFEVpKBsqnvc7AR82i3Bml2Qqu1byt48fTtiz1REoiqI0AyIVl4lVWOZYmrBnqyNQFEVpBtS7jWVy4gLG6ggURVGaAfVtY1l7X+N4oo6gATSm6JzT6fQLxw0YMCBkte9tt93GoEGDGDVqFBUVFUDDROd++OEHTj/9dFJSUupcryhKYslJt3Nm55spP+jCGENljZtP9jjZ4vAc73bUJGwP4zbjCObNW0Xv3hOxWMbQu/dE5s1b1aB+AkXnGoPk5GSKioooKirilltu4Ve/+lXQ+bVr11JaWsrKlSspKChg9uxD1Ydvvvmm/97a4nM+0bmVK1cye/Zsqqqq6N69O0VFRZx99tmNMTRFUWqRk27H8bOdP39VwRvbq/zFZSJCj/Qk/r7usYQ8t004gnnzVjF+/FyKi0sxxlBcXMr48XMb5AwaW3QukJdeeonRo0cHtf3444+cdtppAJxxxhmsWhXdmEKJzqWlpfmroRVFaRp+d84fOLdrMhcdlRq0WY3FKpQfm5jloTbhCKZMKcThcAa1ORxOpkwpjLmvxhad87Fv3z62bNnCSSedFNR+4oknUlRUhDGG5cuXU15e7j/XUNE5RVGajuLKIgZkpYTcrMaakphXdpsoKNu8uSym9nA0heicj8WLF3PJJZfUaT/llFPIy8tjyJAhDBgwIEhGoiGic4qiNC1rfp6DLSk4Q8i3Wc03FdWsWreE/DNHxvWZbWJGkJ0dWsY1XHs4mkJ0zkeoZSEfkydPpqioiBNPPLFODCGQ+kTnFEVpBthCJ2qkWYXdjhoKl8Y/TtAmHMHUqQWkpSUHtaWlJTN1akFM/SxcuDBIhC2S6NzIkSP9AnGh8InOXXnllUGic6FiBPv27WPz5s2cfPLJ/rbp06f7nZDdbmfo0KGsX7+esWPH+q/xLQ3Z7XZ27twZ1OfkyZOZPn06gwYN8ovO7dmzh6FDh/L5558zcuRI3n777Rj+OoqixIPSPdUh2x0uQ8/2SZS2L4/7M9uM6Ny8eauYMqWQzZvLyM7OZOrUAsaNy4+rbSo6pyjK4TJq5mBGj2hPUvKh7+k1bnMolfSgm5fs78fcr4rOAePG5cf9xa8oihJvLjv1Vp595UGuuqwbaVbBAFaBfp2SANicgC/vbWJpqLFQ0TlFUQ6XcfmjuG7AXXyy24nLgEWkTvbQqpLlcX2mOgJFUZRmxrj8UZzaKQmbpW720Cmdk/nbpqfj+jx1BIqiKM2QTsmhX89pVsFRszeuz1JHoCiK0gyxujuEbHe6PZ94oo6gATSm6BzAtddeS1ZWFjNnzgx5/vHHHycvL4+LL77YX8RWn+hcbb766ivy8/M555xzWL7cs/64evVq+vbtG1SkpihK45Db9QZcIQLDNoHe6da4PqvNOIJVi1Yz8ezbGZP9P0w8+3ZWLVrdoH4aW3QO4KGHHuLhh0PvTlRSUsKSJUv44IMPKCgo4OmnD60dhhOdKyoq4h//+EdQP3/84x957rnnWLZsGXfffTcAJ598Mh9//DE9e/aM/6AURYlITrqdanddR2C1CKdnJIe4o+G0CUewatFq5k76O6XbyjAGSreVMXfS3xvkDJpCdK579+5h7Vm7di12ux0RYfjw4axe3TAHt2PHDo477jg6duxIZmYmpaWldOrUibS0tAb1pyjK4dPOEnozmjSrsGzpg3F7TkIdgYgMF5FvRWSjiEwOcV5E5Cnv+S9E5IxE2FE442WcVcGic84qJ4UzYk/1bCrRuXCUl5fTsWNHoK54XCTRudoEFhaqCJ2iNA98m9H8e0BnFpydEfR5pfN7cXtOwgrKRMQKPA2cD2wF1orIYmPMVwGXXQgc5/0MAGZ7f8aVsu2hxeXCtYejKUXnwpGRkcHGjRsB6ojH1Rade/bZZ3nhhRcoLy/nwIED/OMf/+D8889nypQpfiXSUP0oitI0fLLbyc6R3RBvLUEgZaN7wLb4PCeRM4L+wEZjzI/GGCcwH7i01jWXAs8bDx8BnUUk/DpIA8k8KrS4XLj2cDSl6Fw4cnNzKSoqAmDZsmXk5eWFvfb666+nqKiIJ554wi9UN2XKFAC6devG999/T0VFBbt376Zr19D7pyqK0nis2EVIJxCq7XBIpCPoAWwJON7qbYv1GkRkvIh8IiKflJSUxGxIwaTLSE4NDq4kpyZTMOmymPppKtG5O++8k4cffpiZM2fy+9//HjgkOpeVlcXIkSPJy8ujsLCQiRMn+u+LJDpXm4ceeojrrruOCy64wL889fXXXzN06FC+++47vxidoiiNx+ST7miU5yRMdE5ERgMXGGN+6z2+CuhvjLkl4Jo3gGnGmA+8x+8CfzDGrAvXb0NF51YtWk3hjJcp215G5lGZFEy6jPxRAxs6vJCo6JyiKPFmdM+rQ377N8bw0tbno+6nqUTntgK9Ao57AtsbcE1cyB81MO4vfkVRlETj+7Ie6AyMMQ1eTg5FIpeG1gLHiUgfEUkGrgAW17pmMXC1N3vobGCvMWZHAm1KKCo6pyhKvHl52wv+F3/g5+VtL8TtGQmbERhjakTkZmAZYAWeM8Z8KSITvOfnAEuBEcBGwAFc28BnxTVwotRPS9vHQlFaMvF86YciofsRGGOW4nnZB7bNCfjdADcdzjNSUlIoKysjMzNTnUEjcuDAAZKSkpraDEVR4kCL35imZ8+ebN26lYZkEymHR6SKZ0VRWg4t3hEkJSXRp0+fpjZDURSlxdImtIYURVGU8KgjUBRFaeMkrKAsUYhICVDcwNu7AqVxNKcloGNuG+iY2waHM+YcY0xWqBMtzhEcDiLySbjKutaKjrltoGNuGyRqzLo0pCiK0sZRR6AoitLGaWuO4JmmNqAJ0DG3DXTMbYOEjLlNxQgURVGUurS1GYGiKIpSC3UEiqIobZxW6QhEZLiIfCsiG0VkcojzIiJPec9/ISJnNIWd8SSKMY/zjvULEVktIqc2hZ3xpL4xB1x3loi4RCS2LemaIdGMWUTsIvKZiHwpIisa28Z4E8V/251EZImIfO4dc4NUjJsLIvKciPwsIhvCnI//+yuUznVL/uCRvP4BOBpIBj4HTqp1zQjgTUCAs4E1TW13I4x5IJDh/f3CtjDmgOvew6OCe1lT290I/86dga+AbO/xEU1tdyOM+Y/ADO/vWcBuILmpbT+MMQ8CzgA2hDkf9/dXa5wR9Ac2GmN+NMY4gfnApbWuuRR43nj4COgsIi1ZSrPeMRtjVhtj9ngPP8KzG1xLJpp/Z4BbgIXAz41pXIKIZsxjgVeMMZsBjDEtfdzRjNkAHcSjQ98ejyOoaVwz44cxZiWeMYQj7u+v1ugIegBbAo63ettivaYlEet4rsfzjaIlU++YRaQHMAqYQ+sgmn/n44EMESkSkXUicnWjWZcYohnzTOBEPNvcrgd+Z4xxN455TULc318tXoY6BKF2p6mdIxvNNS2JqMcjIkPwOIJzE2pR4olmzE8Ak4wxrlayaVE0Y7YBZwK/BFKBD0XkI2PMd4k2LkFEM+YLgM+A84BjgHdEZJUxpiLBtjUVcX9/tUZHsBXoFXDcE883hVivaUlENR4ROQX4G3ChMaaskWxLFNGMOReY73UCXYERIlJjjHm1USyMP9H+t11qjKkEKkVkJXAq0FIdQTRjvhaYbjwL6BtFZBPwC+DjxjGx0Yn7+6s1Lg2tBY4TkT4ikgxcASyudc1i4Gpv9P1sYK8xZkdjGxpH6h2ziGQDrwBXteBvh4HUO2ZjTB9jTG9jTG/gZWBiC3YCEN1/268B+SJiE5E0YADwdSPbGU+iGfNmPDMgRORI4ATgx0a1snGJ+/ur1c0IjDE1InIzsAxPxsFzxpgvRWSC9/wcPBkkI4CNgAPPN4oWS5RjvhvIBGZ5vyHXmBas3BjlmFsV0YzZGPO1iLwFfAG4gb8ZY0KmIbYEovx3fgD4h4isx7NsMskY02LlqUWkELADXUVkK3APkASJe3+pxISiKEobpzUuDSmKoigxoI5AURSljaOOQFEUpY2jjkBRFKWNo45AURSljaOOQGnxiMjfROSkBPS7P8brR4vI1yLyvve40KsOeZuI3C8iQyPcmysiTx2uzYrSEDR9VFHCICL7jTHtY7j+LTwqmO+LSDc8qpA5ibNQUeKDzgiUFoOIpIvIG17d+Q0iMsbbXiQiud7frxeR77xtfxWRmd72f3g13FeLyI++vQlEpL2IvCsi/xWR9SISSsG0th1XisjHXs3/uSJiFZG78eg3zRGRh4G3gSO81+R7n+975lleOz739tNBPHsIvB4wzudEZK2IfOqzSUSuEZFXROQtEfleRP4cYNNw7xg+947H4r0my3veIh79+q7x+xdRWgutrrJYadUMB7YbYy4Cz4YkgSdF5CjgT3i03Pfh2Yfg84BLuuN5Wf8CT5n+y8ABYJQxpsL7kvxIRBabMFNlETkRGAPkGWOqRWQWMM4Yc7+InAfcYYz5RESeBl43xpzmve96789k4N/AGGPMWhHpCFTVeswU4D1jzHUi0hn4WESWe8+dBpwOHAS+FZG/eMfwV2CQMWaTiHQxxrhF5F/AODzie0OBz1tyxa2SOHRGoLQk1gNDRWSGiOQbY/bWOt8fWGGM2W2MqQZeqnX+VWOM2xjzFXCkt02Ah0TkC2A5HjnfIwnPL/Goe64Vkc+8x0fHMIYTgB3GmLUAxpgKY0xt7fxhwGRv/0VACpDtPfeuMWavMeYAng1ocvBsTrLSGLPJ26dPy/45wCdDfR3w9xjsVNoQOiNQWgzGmO9E5Ew8OivTRORtY8z9AZfUpzV9MMS14/DsanWm9xv+T3hevOEQ4J/GmDtjsz7o/voCcwL8xhjzbVCjyACCx+DC8/9wyD6NMVtEZJd3pjIAz1gVpQ46I1BaDN6lH4cx5l/AI3iWgAL5GBgsIhkiYgN+E0W3nYCfvU5gCJ5v2JF4F7hMRI7w2tRFRGIJCH8DHCUiZ3nv7+C1NZBlwC0iHnVAETm9nj4/xDPuPj6bAs79DfgXsMAY44rBTqUNoTMCpSXRD3hYRNxANXBj4EljzDYReQhYg0ef/Sug9vJRbeYBS0TkEzybm3wT6WJjzFcichfwtohYvHbcBBRHMwBjjNMb5P6LiKTiiQ/UTit9AM+6/hdeZ/ATcHGEPktEZDzwitemn4HzvacX41kS0mUhJSyaPqq0KkSkvTFmv/db9iI8ssWLmtqupsKbTfW4MSa/qW1Rmi+6NKS0Nu71Blk3AJuAV5vUmiZERCYDC4GGxjOUNoLOCBRFUdo4OiNQFEVp46gjUBRFaeOoI1AURWnjqCNQFEVp46gjUBRFaeP8f2E8XKTLuCv4AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "alphas = np.logspace(-10,1,11)\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "it=0\n",
    "for alpha in alphas:\n",
    "    c1 = 1.*( float(it) % 3.)/3.0\n",
    "    c2 = 1.*( float(it) % 9.)/9.0\n",
    "    c3 = 1.*( float(it) % 27.)/27.0\n",
    "    probs,accept,rej = runSciKitRegressionL1(18,alpha)\n",
    "    ax.scatter(accept,rej,c=[[c1,c2,c3]],label='Alpha: %.1E' %alpha)\n",
    "    it+=1\n",
    "\n",
    "ax.set_xlabel('signal efficiency')\n",
    "ax.set_ylabel('background rejection')\n",
    "plt.legend(loc='lower left', fontsize = 'small');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the full set of variables there is more reasonable behavior versus our regularization parameter. To try to understand this, we can think of the underlying data. In our case, every input variable is important and when using just the eight low level variables we are removing too much valuable information when our regularization parameter is strong. When moving to the full set of variables, we recover some of the underlying information that we were killing off because of the fact that they are simply functions of those underlying variables.\n",
    "\n",
    "Let's test L2 now with the first 8 variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on test data with alpha 1.00E-10 : 0.693\n",
      "Accuracy on test data with alpha 1.26E-09 : 0.651\n",
      "Accuracy on test data with alpha 1.58E-08 : 0.693\n",
      "Accuracy on test data with alpha 2.00E-07 : 0.686\n",
      "Accuracy on test data with alpha 2.51E-06 : 0.766\n",
      "Accuracy on test data with alpha 3.16E-05 : 0.767\n",
      "Accuracy on test data with alpha 3.98E-04 : 0.768\n",
      "Accuracy on test data with alpha 5.01E-03 : 0.767\n",
      "Accuracy on test data with alpha 6.31E-02 : 0.756\n",
      "Accuracy on test data with alpha 7.94E-01 : 0.687\n",
      "Accuracy on test data with alpha 1.00E+01 : 0.542\n"
     ]
    },
    {
     "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": [
    "alphas = np.logspace(-10,1,11)\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "it=0\n",
    "for alpha in alphas:\n",
    "    c1 = 1.*( float(it) % 3.)/3.0\n",
    "    c2 = 1.*( float(it) % 9.)/9.0\n",
    "    c3 = 1.*( float(it) % 27.)/27.0\n",
    "    probs,accept,rej = runSciKitRegressionL2(8,alpha)\n",
    "    ax.scatter(accept,rej,c=[[c1,c2,c3]],label='Alpha: %.1E' %alpha)\n",
    "    it+=1\n",
    "\n",
    "ax.set_xlabel('signal efficiency')\n",
    "ax.set_ylabel('background rejection')\n",
    "plt.legend(loc='lower left', fontsize = 'small');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's try the full set of variables with L2 regularization:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on test data with alpha 1.00E-10 : 0.668\n",
      "Accuracy on test data with alpha 1.26E-09 : 0.764\n",
      "Accuracy on test data with alpha 1.58E-08 : 0.751\n",
      "Accuracy on test data with alpha 2.00E-07 : 0.771\n",
      "Accuracy on test data with alpha 2.51E-06 : 0.787\n",
      "Accuracy on test data with alpha 3.16E-05 : 0.790\n",
      "Accuracy on test data with alpha 3.98E-04 : 0.789\n",
      "Accuracy on test data with alpha 5.01E-03 : 0.784\n",
      "Accuracy on test data with alpha 6.31E-02 : 0.760\n",
      "Accuracy on test data with alpha 7.94E-01 : 0.733\n",
      "Accuracy on test data with alpha 1.00E+01 : 0.459\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABWk0lEQVR4nO2de1zUVf7/n+8ZGGDwAgLlFbDLtpV2pSwJxTJvq5W7mRHVdvuqa/Vra9uwte26pNZ2N2+7tV2WcMuycrOsLBKzTN0umt1MBdFUQEFlwGFmzu+PuTgDMzCDM1zP8/GYB/M5n/M5n/cZ4POec97v8zqilEKj0Wg0XRdDWxug0Wg0mrZFOwKNRqPp4mhHoNFoNF0c7Qg0Go2mi6MdgUaj0XRxotragFBJTk5W6enpbW2GRqPRdCg2bNhQoZRK8XeuwzmC9PR01q9f39ZmaDQaTYdCREoCndNTQxqNRtPF0Y5Ao9FoujjaEWg0Gk0XRzsCjUaj6eJoR6DRaDRdnIhlDYnI88B4YK9SapCf8wI8BYwDLMB1Sqn/RcKWy/v9HpEj4noK2FPnoEe0YDYKFrtiY7WNHbU2QLyuVJ7jbgkOpv4tjpycoew+vA6LvQKzMZlBPa4lLT4bgOKlayics4TKXZUk9U0iJ+9ysiYO9WtTcfmHFJY+R6W1nCRTCjmpN5KVMjIS3ddoNJomkUipj4rIMOAQ8FIARzAOuBWnIxgCPKWUGtJcuxkZGSqU9FG3E3D6nSMo5VtmcyjW769nR629idYUMWaINilqqoVuCc52aqqFE5OiODUmmqgGbf4gVvpfaOXLj6Ko2AVJfR1clSdYHVaWPBpNxS4hqa8i5656RITCOVFU7jKQ3BeuzLMybGI0H71Rz2uPRFGxS0juCzl59Vz0OzNWhxWlDqNQCFBrB5MhCqPYsdgd/Fhppdemag47FF8N7AYmAxa7g1/qzFzRfySlli+otJbTU7pxuGI/+3oaiDUKdTZFb0kl2mylwrqXOjuUWWz0izMQZxSUVfF9bRTfHqohyQ5XVh3G6lD8JyGWA9GQaj6W/EHTyE0bHfTvSaPRRBYR2aCUyvB7LpIy1CKSDvw3gCNYCBQppQpdxz8A2UqpX5pqM1RHMKn/tY2cQCBqbA6W7z4cdNvejOsdQ3xU45k2Z5t1eI80oqIVCrDXN11milNkX26naIkRa61v+dQ59WRNtFO81OhyHi6Hkmcja6LTma16w8DiR3ydzZBL7SgUMQbB6sDz/rDD+XfQsNxiV+yqtdM3zug1eqqntMYGgNUBoDB56jroG2fAbBTqHQqHq027TeEwQLTBWW5UYHC199N+K2U1dmqNQrJdMdhi58tYI1XRzuPfW+O59dw/kXbyuBb9bjQaTdOOoC0XlPUDdngdl7nKGjkCEZkCTAFITU2NmEFmY3AOI5RrneW+52z1jev6K7PWCh++YsRhl0blhXOcv7qFedEeJ1GxU1iYF+2pt2jGkXOVO4VFM0yI1HscRYwRQJp0JvFRwgndBBHvemaS+iou/3M9Qy+z+XUYDZ3Jxup6dlicbZq8Pqv4KOH05BhOT8bnmmFe739yKG6tfJSYNX/3TNbV2RU/7LfyU52Dbi5ndMggdHM5tBqDgb6mnsw58496ZKLRNENbOgJ/T06/wxOl1CJgEThHBJEyyGJvedMWuyI+qnGXjqZNAEeAmarKXU5n4D1SAF8nEeic+yEPULzUGNCZuOu5nUDDes/fbSLaIGRNtPs4DHA6meKlUT4O5sq76jn7EluTDsPf6MPpQJztunsU53Yg+DoQ3/eH+c+O2by5c46nrf2HnCOiGoNgABxAN5twe99LeDB7Rgt+QxpNx6ctHUEZMMDruD+wK9w3UUqA4GIEG6ttLb7PxmobGYnRRBnC1yaAwejfGST1VVTu8j8KCVTu71xTzsTbYQRTz/vz9Oc4Fs0wMVWECy7zdRjux3tDZxIfJZzTy8QZCY0f8t5OwruNQO/jo4QhvUzYEsGuGre3wb6C1P/+lyqXozhkEAwIDoE0HfPQdHLa0hG8DdwiIotxBourm4sPtIQlO1/k8n6/x3uw0ZKsoeZwB5kH94xq0Ka9UTvhiBHk5NkonBNFxc7G9iX1dfa1qXNugnUmoTqdYB1MQ1a/GRVwmqrhg93bSTQ9mnAiIkQLRDfhKOh15Ld1xFFU80rpbO7e+BA7LXYcQHcHKBFqDDo4run4RDJ9tBDIBpJFpAy4D4gGUEotAJbjzBjagjN99PpI2bJk54tHdX1BQTEzZxZSWlpJr17dAMW+fTUk9IrBZq/jULWiW4JQpey8u8dGtwQBBYfqFMn94KwL7T5ZQ9fMMKKAf8+2e2UI1SMIr8wx+pQNmxjN8Rn+s4bAysI81chJXHmXDVAsmmHy60C8SeqrmnUYSqmg6nnTktFKMNNU3hhFMBqDG024HQPA4J7Rfp2F+1q3hYEcReORSQVXr72fGz+/n2i0c9B0PCKaNRQJQs0a6ux4O6nU1CTy83PIzc2ipKaIZ154jhdn1fqko170OzNKQb06hMnQjaI37My7y+HjMGLi4A+PCEMvq8VsTKZ3zDkUFq7hmT/XBcxeAlAK3LND08+LoWJn4yyq5H4O5n3uPzOrJdd401TQG5xTQigwek3f2ZWi3uE/qB0s7v+hxiOJI23WHrRxlSWKO4b+RWc/adqENksfjQTaEYSfQM7EX728u//FrrJDnpHNsIlG6tUhj8NwL7b77M045t2lOFx75PqGjqMhk1NjXTEdX0QU/ymta7IPDUcTwdzPHw0dQ3PTTcHg/h9zX++eXkq2K+0cNK2GdgSaNuGIg6kgua9wZd5hRl/ey8dhmAzdPCOUm8+Lo3xn47/HYEYERzuaCIS/pIJtNbYWOwelFDZ1JGDt6xyEfjrlVRMhtCPQdAgKCoqZMmUhFovVUxYXF8X0R40MubTax2mYDN2od1hQOB/ARzOacNPc1JKbhs7haKeX3P+D3lNKtXbFj1U2ttTZdbxBExa0I9B0GIKdpgIoqSli04GXsNgrghpNGIhCoTzOw5twTS3B0Y8a3DScUtp/yMYNNXoqSdMytCPQdHqaG024BQIBj/PwHlWEe2opEqOGww7FV1X17K2xE62gxih6tKAJGu0INF2CUEYTbtyjign9DgY1teSdGXU0OEUOrUc5SnCtU1GKbg6lRwuaJtGOQKNphvT06ZSUVDQq790/hn9+Ee2RHe8dcw4ltSuxq5YHoN0ctitsSrV4+shfbMFiV2yqrqe01qFXRGt80I5Ao2kGf1NLZrOJRYumNhpVeMcmGgatAVa9YWTxI6EHnSMTW7Bx8LCJuRl3aYfQxdGOQKMJgpZMLYGvY1j7Vk+e/XM9dbUOz/lQgs7+98kIfQrJuz04EnCuPeTgnrTLuO38u1rUnqbjoh2BRtNKBJpiSu6nmPe5d6yhsRBiII52Csn7noBrD4h6bk65RDuELoR2BBpNK2EwTMbf/5QILNvZzRNrqHfUUa8OBtVmJKaQvEcayQ7Ro4QugHYEGk0rEWhEkJaWzPbt8zzHJTVFbKia2+KgczimkJRSR7KPLDa6OeBvaRO1Q+ikNOUIGidOazSaFpOfn4PZbPIpM5tN5Ofn+JSlxWdzdsItmI0pgGA2pnCceRxGiQnqPg2nlaIMwhkJ0YzrE8vl/eMY1yeWAWZjs23ERxkY0iuay/vHMaxfLI9Vvk33xedx54sXUfLd8qBs0XR89IhAowkzLQ06g2/g2WxM5sPXa1xy5U1nIEH4RglwJLhcd8jBTD1t1CnQU0MaTQekoKCY//u/+dTWHtlDwhSnmDK7nmG/De7hbql38M4vtU6J7BBXwjkdSb2eNuokaEeg0XRAmlrk9uzntT7xhUBZSEopKvbXk5wYjcWm+KbaSplXamtzNIwjAPQzJWiF1A6IjhFoNB2Q0tJKv+V7dlobxRdMhh5+6yogpZfJGQ+INnB2TxP9TMH/2zeMI4zrE4sh6hA3fH6/jiN0Itpyz2KNRtMEqalJfkcEqalJpMVnkxaf7Snzl4WklMLQYJRgijZwWo9oTjMK8dHBp556bwGakRjNeuAJsWAtvp8/gdY36uDoEYFG004JNgMJ/GchBYoJxMca6GYyeL7tZySa6B9n8Lv+wR9RBmFIr2jG9Inlzb4m0jc+RP83x1JQsiLkPmraBzpGoNG0Y44mA+mdX27AYi8Pqm75Piv/eGsnx5+fhJiNQQeWG2YZVdU4eChVZxm1R3SwWKPpgmz47BG2HvMJxBwZ+DcXVE5KjKbqkI3vLXZ2WoMPKsORLKM9NTamHzLyRy2J3a7QwWKNpguy+5FXYMEWKK8Dh4LyOuRgvd+67qCyQYRe3aPJ6GXiGFzf+EOcMhrZN5bXj4WMrx7iqc8eCV+HNBFDB4s1mk6KZe9O2KPgU6/so8wkmHo8xB5ZdRwoqHxKfBTP/m0zA07qzplZyZi6RTU7ZeSMOwgZiSbWU89dpUsB9FRRO0dPDWk0nZR3Jp6BZU+ZT1lx+bEU7j2RyoPRzpXKf7BwwbWGZqeLKvfXs+J/+4k6Ph5jVHATCe41CJuq67m0rJbRUccwKPNWPV3URuipIY2mCzJo2j3AkQd8cfmxLNz6ayoOmFBKqNhpYOG9cax+yX8swHu6yLKuGwlzf4XhqgE4ph2LWhXX7JSROyvp7EQTb/aPY3yPKj1d1E7RjkCj6aSkjb6c4357HW5nUFh6HFaHrxCd1WGk8BET1PmuI/CeLipZYWLD7Hhq9xgRBMO+aOzzEvhlQT2qxtZs2mmUQTi3l4nL+8dxbv9Ynqp4WzuDdoZ2BBpNJ+bsOx/l3PvmY+rZi0prrN86lQeiYeHPvkFlr2f7pgVx2OsaqJ06jKRvSuWX9fvYsnIvytZ0hpFBxDNCOKOXiccq39ZrD9oR2hFoNJ2ctNGXc+m7P9L3mHi/55NMdc6A8s1fwpWfO39WHlmhbNnj/zFxuMLI1CtSiY8W1r6/h8MH64NalBZlEAb3jGZnfTX/t+5h7QzaAdoRaDRdhDmP39hopbLJYCcndWvjyq+UeqaLzMf6/7ZvPtZBrMnAVeP6suOHg7z9z22sfXc3Dnvz6w/MRmFc7xiSYx1c+8UD2hm0MdoRaDRdhNzcLBYtmkpaWjIikGyqZepx35OVsqdx5U8rPdNFg6ZaMMb4PtyNsYpB02oBSEqM9pTv+OEgX6zYQ63FGTtwBBghHJG3iKZfnJEb1j6g4wZtiE4f1Wi6MEX/77eUr1/VbL2Smr5sMg7GUmHEfKyDQdNqSRttBeDAIRuHrQ5Pmukry3fx6f+qADhzcE+OH3EMYgy8/uCI1LXeCCeStJnEhIiMAZ4CjMA/lVKzG5zvCfwbSMW5uO3vSql/NdWmdgQaTfh5bWhy85X8LEartzlQgMlrbUGd1cHCV0s9zuCMwT359dAk7HFGaGJBmrdExSOpehOccNMm6whExAg8C4wFTgFyROSUBtVuBjYrpU4HsoHHRMSERqNpVSatqaD7wJOaruQ1XeTOLrJZ7D5OAPDEDdx8tbGaT18qwVDbtNS1M4gchdUg3LFjqd7voBWJpMTEucAWpdRWABFZDFwKbPaqo4Du4lzW2A3YB9gaNqTRaCLPmIJPAXgtMyXwYrFPK30kK+IWn+e3mnfcAGBHrZ01ReUMGXUs0sTKZHcQeWO1jWeU3u+gtYhksLgfsMPruMxV5s1c4GRgF7ARuE0p1SjlQESmiMh6EVlfXh6crK5Go2kZkz4t57jfXh9cZa80U5/i/fVknpXAs/ecwuLHTufZe04hNd7YbJqpdxD52PgonkkwkvHVgzqQHGEi6Qj8TQY2/O2PBr4C+gJnAHNFpNGee0qpRUqpDKVURkpKSrjt1Gg0DTj7zkeDmy7ySjN1U2d1sH5zNVOvSPVIVKT0MjH1ilRS4428/c9tbFm5F2liEZp7mggRKqIM3FW6VDuDCBJJR1AGDPA67o/zm7831wNvKCdbgG3AryNok0ajCYExBZ9y7n0LAgd5G8YNKqzUfjOAcwclEmsKHDv4amM1PxaVNylR4Z4mGhBnxGoQ/lbyZji7pvEiko5gHXCiiAx0BYCvBN5uUKcUuAhARI4FTgL8rG7RaDRtRdroy5n0aTkpGcManSsuP5bpT/+KyWclMP1EoXhSGf1e/JykhGg/LfnGDr7aWM2SRVupr/EfRPaeJhoQZ6TCoDjmP5l6ZBABIp0+Og54Emf66PNKqXwRmQaglFogIn2BF4A+OKeSZiul/t1Umzp9VKNpO0pWLOF/j/wJW22NR83UW8jOZLAz9fjvGf3JEL/bZPpbc1BaYydz7ADsEjhPpMbmYPluZzwixqGYo9NLQ0ZvVanRaMJKyYolZFz6EhWHGwvZpcTVs678NjZUzcWujgSTm1pzUGZRDB9zArVy0O/9jiw6s7Gj1o5BKR4foJ1BKOj9CDQaTVhJG315QDXTirpo0uKzOTvhFszGFEBQ9fHUHVYB1xyUfF/NS09uoPZgcNNEDhEdQA4j2hFoNJoWkZrqfzWyuzwtPpvf9HmeSf3f5oqBi+ke73/Zknfc4Ovivdjqg8gmAmcAefsbvPPPsXrh2VGiHYFGo2kR+fk5jdRMzWYT+fk5fuubjf4dR+X+es/7HT8cZP0He6g5UB9wUZvZKFzeL5ZxvWOI6x7FdfH7eWL1g9oZHAXNOgIRyRSRD0TkRxHZKiLbRERn9mg0XRxfNVMhLS2ZRYumkpub5bf+oB7XYpQYnzL3moOGC8+WP7cN66HA00RHpopMxHWPZn4P4ZkvHgt7H7sKzQaLReR74HZgA+D5zSilKgNeFEF0sFij6biU1BSx6cBL1NjKqayqZ923VYw4N8lnzYE7gFxaY+eci4/FGN3091V3RlGyzcH6M+7VchQBONpgcbVS6l2l1F6lVKX7FWYbNRpNF8AdN7hiwDJ6VE1tcuHZjh8Osu6DPVgO2EDR7MKzuO5RZHz1kA4gt4BgHMHHIvKoiJwvIme5XxG3TKPRdGpysyY2u/Bsxw8Heee5rbzx9M+YbP6zlHyniaLI2/Gm3vEsRIJRHx3i+uk9pFDAheE3R6PRdCXMxmS/C8+8A8gAdoedLz7exVkjU1AG/1lF7oyi5bV2/vjZA1xgsetpoiBp1hEopUa0hiEajabrMajHtY0WnnkHkH13Pauke1w8Z2alcEAdQPzoH5ldO6FVGBQZXz3EPVWb9KKzIAgma6iniDzuloEWkcdcO4tpNBrNUeFv4dnq9dWMODepkXJp5lkJfLm+lAttv8dYF7jNcb1jGGCOoiJK9DRRkASTNfQ6sAl40VV0DXC6Uuq3EbbNLw2zhurr6ykrK6Ourom/DE1E6NOnDwkJCW1thqaT8eq2K5Homkbl5fus3Py3zZhNcUyfdCElvX6EKP+qqO5tL3fU2ukX3ZOyy96NtNntnqayhoKJERyvlPqd1/EDIvJVWCwLA2VlZXTv3p309HS/Q0VNZKitrWXnzp3aEWjCjkRb/Ja7A8gWay1PFL7H7Tlj2NH9R+yxNPrfd8cLdtTa2Wmt4qnPHtFTRE0QTNZQrYhc4D4QkUygNnImhUZdXR1JSUnaCbQysbGx1NfXN19RowmRYFYg2x125r32EROibw34v++OFyB6iqg5ghkR/AF40RUXEJz7Cl8XSaNCRTuB1kd/5ppIEUoAeWbhHMbdOJAK616/bbn3P96hM4mapNkRgVLqK6XU6cBpwGCl1JlKqa8jb1r7ZejQocyaNctzfP/99/Pf//43YP2MDL/TckFz/fXXk5KSwty5c/2ef+KJJ8jMzGT8+PFUV1cDkJ2dTVZWFtnZ2WRnZ3Po0CGfa9544w1+/etf+9hms9m4/vrrycrK4rbbbjsqmzWaluIdQFYKKvbX8/EXlX4DyP1Ta/h8ZSlG1fg7bUPF0kqD4ov379OaRH4I6AhE5GrXzztE5A7gJuAmr+MORUFBAenp6RgMBtLT0ykoKGhROzt27CAtLY2VK1eG2cLAPPzwwzz66KN+z5WXl7Ns2TJWr15NTk4Ozz77rOfcu+++S1FREUVFRXTr1s3nuuHDh/PNN9/4lC1btox+/fpRXFyMxWJhzZo14e+MRtMEBQXFpKdPZ2D3+dx8fiz1q+6iR9VUMk7pGXAF8pfrS1n/wR6i62P8CtW54wUKmH6MUWsS+aGpEUG862d3P69ugS5qjxQUFDBlyhRKSkpQSlFSUsKUKVNa5AyWLFnC1VdfzXHHHcfPP//sc2779u1kZWXxu9/9jjPPPJPPPvsMAIfDwR/+8AeGDBniGUl88MEHXHjhhZx77rnMnj0bgN27d3Pfffc1umefPn0C2rNu3Tqys7MREcaMGRP0wzspKQmTyVc58rPPPmPUqFEAIbWl0YSDgoJipkxZSElJhev/tIIpUxZCaTLJiSa/17gDyFu+reTTxfsC7q1sNgqIUBFl4JlYi5ahaEBAR6CUWuh6+6FS6gHvF9B6X4fDwMyZM7FYfDMRLBYLM2fODLmtlStXMmrUKHJycliyZEmj82VlZRQWFvLWW2/x17/+FYCqqipmzJjBZ599xuLFiwHIzMzko48+Yu3atbz55pvU1tbSu3dvHnjggZDsqaqqokePHgD07NmTffv2ec6NHTuW7Oxsxo8ff9RtaTSRZubMQiwWq0+ZxWJl5sxC4qNS/F7jHUAuqdhJnOrut54Cj3T1sfFR/G37Uj1F5EUwWUPPBFnWbiktLQ2pPBBlZWV88803TJgwgVmzZvmNCwwaNAiTyURqaqpnvj4xMZG0tDQMBgNxcXEAfPnll4wcOZLs7Gy2bt3K3r3+g13NkZiYyIEDBwDng7xXr16ec+6pIbedo0aNIjs7m82bN4fclkYTaUpL/WtZlpZWBpSwfmX5Lp+yNR9sbxQvUEph8JGujiauu5FzvsnXmUQumooRnC8ifwJS3HEB1+t+nJvRdxhSU1NDKg/EkiVLeOqpp3jvvfd4//33Oemkk9i2bZtPnW+//dazyK1nT+cCbH8ZNrNnz+bpp5/m448/JjU1NaCyYnNkZGRQVFQEwIoVK8jMzAxY9/3336eoqIhTTjnF7/nzzjuP999/P6i2NJpwk5qaFLDcXwB54aulfPq/KjLPSvDsZ3D7xGMx7rCSbDoGAIdSAdYYRFNuUNy49gE9TUTTIwITzlhAFL7xgQPA5ZE3LXzk5+djNpt9ysxmM/n5+SG18/rrrzN8+HDP8YUXXthoeqhfv35MmjSJCRMm8NBDDwVs63e/+x2TJ0/m6quvJj7eGY4JFCO4++67efTRR5k7dy5/+tOfAKcj2bZtGykpKUyYMIHMzEwKCwuZPn265zr31FB2dja7d+/2abOoqIiRI0fy448/MnLkSPbs2cOECRMoKysjKyuLuLg4zj///JA+H43maGhux7OGEtZuJzD1ilSfbKLR55j55bNdXGq7hUBJzu41BocFPU1EcBITaUqpklayp1kaSkx89913nHzyyc1eV1BQwMyZMyktLSU1NZX8/Hxyc3PDatv27du58847/cYOOiPBfvYaTbAUFBQzc2YhpaWVpKYmkZ+fE3DHs/Tp53HXtJ6k9GocSC7fZ+XPj2zjsiknUB99uNF592Y2AKIUyw4k8JubOrcMxdFKTPxTRCYppapcjSUCi5VSo8NoY8TJzc0N+4Nfo9GEl9zcrIAP/obk5+QRnfic33NJidFYrLV893k1v87qhg2b55xSyrOZzcZqGzstNlbYyvlNWHrQMQkmWJzsdgIASqn9wDERs6gDk56e3mVGAxpNW5ObNRFs/jPZ3dlEX64v5TT7CAy1CqWcL2kQOO5njmJhYnSXjhUE4wgcIuKJqopIGs5sLI1Go2lThhwzrdlsoocWPM8Zuy9Aah0BxemsBunSsYJgpoZmAqtF5BPX8TBgSuRM0mg0muBIi88GYO3eBRB1iIr99azfXM1V4/pya26aR5Nower3OfeaeL9tuAPHlUbY9OkzXVKLKBitofeAs4D/AK8CZyuldPKtRqNpF6TFZ3PFwMXUb7+RV5bv8qtJNCDV4kkp9ce43jH0Nxu5Ln5/l1xbEMwOZQKMAc5SSi0DzCJybsQt02g0mhDIzZrItRMG+NUkyhnXJwhxOhNx3aO58YuHupwzCCZGMA84H8hxHR8Eng1cvfPTntRHKyoqyMzMZPjw4YwYMYJdu5xzo82pj/7yyy9cfPHFDB06lJdeegmAAwcOcMkllzBixAjPegWNpiOR0MP/WtekxGgfcTp/afPueMFhHOR9+WSELW1fBOMIhiilbgbqwJM15F8Bqh1TvHQx0887icmp8Uw/7ySKly5uUTvtTX00MTGRVatW8cknn3Ddddfx3HNH0umaUh+dPXs2eXl5rFq1ivnz51NbW8vChQu59NJL+fjjj6mtrWXt2rUR7ZdGE26a0yRyi9M1t5nNLmt1ZAxspwTjCOpFxIgrU0hEUgBHMI2LyBgR+UFEtojIjAB1skXkKxH51isgHVaKly5mYd7NVOzcgVKKip07WJh3c4ucQXtTHzUajRiNzm9BBw4cYNCgQUH1Y926dVx44YVERUWRkZHBt99+y9atWznjjDMAOOussyguLg6qLY2mvRCMJlFp5a6A8QKL3TlSSLI7KN6wLHKGtjOCcQRPA0uBY0QkH1gNPNzcRS7n8SwwFjgFyBGRUxrUScA59XSJUupUYFJI1gdJ4Zz7sNb67q5pra2lcE7jh25ztDf1UYCNGzcyZMgQ5s6dy5lnnukpb0p91GazYTA4f/1updGTTz6Zjz76CIAPP/yQqqqqkG3RaNoSX00iRfk+q0eTyE1qUl9yUm8kisbidO6FZnHdo5j4Yz55b/2hlXvQNjSbPqqUKhCRDcBFOLeqvEwp9V0QbZ8LbFFKbQUQkcXApYC39OVVwBtKqVLXvVomwdkMlbvKQioPhLf6qMPhoLa2lry8PJ86TamPAj7qo/fddx/19fUe9VF3nVAZPHgwa9eu5dVXX2X27NksWLAAcE4NeU8JjRo1CqvVyrx584iOjsZut2M0Gj1KozfddBPTp09n5MiRDBw4kN69e7fIHo2mLUmLzyYtPpuC4qX8eWEeFmstmWclcNW4vp5tLh//z0MMOWMsP7CKGkMdiiPikPFRQkaiifUIT9Z8Rd8usPF9U+qjPVw/ewF7gULgFWCPiCS6vvE3RT9gh9dxmavMm18BiSJSJCIbROTaALZMEZH1IrK+vLy8mds2Jqlv/5DKA9Ee1Uet1iP67T179vQI2PnDW300IyODjz/+GJvNxoYNGxg0aBBms5kXXniBDz/8EKVU0PsYaDTtkdysiSyaOofLhh3XSJjut+O68cHnrzFS/R8Jhh5NLjTLL32rjXrQejQ1IngFGA9swBkfEK+fAN1E5B9Kqb8EuN5fNKbh0y4KOBvnaCMO+ExEPldK/ehzkVKLgEXgFJ1rwma/5OQ9wMK8m32mh0xxceTkhTYN8/rrr/PWW0f+KJpSHy0pKWHevHkB23Krjw4ePNhHfXT+/PmNpofuvvtu3n77bex2O9u2beOxxx5j9uzZTJ48mX379nH77bdjNBoxm80+weKxY8d64geLFy/2+YY/Y8YMrrnmGu69917+8Ic/EBsby1dffcUf//hHjEYj1157Lenp6SF9PhpNeyM3ayIJJyzDYvf9AhlrMvC7UcnMXDCHIdf4l6lwB44rJKiQaIemWfXRgBc6RwSblFJ+5SdF5Hzgfrc4nYjcDaCUmuVVZwYQq5S633X8HPCeUuq1QPdtqfpo8dLFFM65j8pdZST17U9O3gNkTbwyiJ4Gj1Yf1WjaH6+VXYI/VRyHUuTc+Q3T7sqkwtp4VtqtUGpQijtjzmDOpfNbwdrI0ZT6aFALykTkahH5q+s4VUTOVUrZAzkBF+uAE0VkoIiYgCuBtxvUeQvIEpEoETEDQ4Bg4g8hkzXxSuZ9/gP/Ka1h3uc/hN0JaDSa9kVBQTHp6dOZnBrL9PNiKF7qO5tdub/eEzg2GXwzjWwOxcZqp2KpQ4Qn677q1KJ0oSwou8p1HNSCMqWUDbgFWIHz4f6qUupbEZkmItNcdb4D3gO+Ab4A/qmU2hRyL9oJWn1Uo2kfFBQUM2XKQkpKKpw7mu00sDAv2uMM6qwOCpf/QknFTq657x4G1Q8j2XQMSilqbA621dgZ3DPKZ5/jzhwriOiCMqXUcqXUr5RSxyul8l1lC5RSC7zqPKqUOkUpNUgp9WToXdBoNBpfZs4sxGKx+pRZa4XCOVGU77Oy6NUdrP7ffsC56f1DC54n03IFKSsVm6rrGRhvJD7K4LvPcXyg/c46PsGoj7Z4QZlGo9G0BaWllX7LK3cZeWRBNSUV+xullC5Z9SR3jLuTHZbHiTI0ziI6rWc0xRuWkXX2hNboQqsSsQVlGo1G01akpiYFLC+t3OV3r+PfjutG6q+7E2f0/1iMNUqnXWTWpCMQEQOwDbgLmAX8gnNBWcCsnq5AexKdA9i0aROjR49m+PDhLFy4EGiZ6FxtbS3jx49n+PDhjBw5kn379h2V3RpNW5Gfn4PZ7DuDbTabyM/PITWpL1eN6+tXpXTTgZdIjgksP1EZZeiUgeMmHYFSygE8ppT6Xin1rFJqbpCritsdJSuW8M7EM3gtM4V3Jp5ByYqWBXXbm+gcONcZvPbaa3zyySdMnTrVUx6q6Ny7777LoEGD+OSTT5g8eTIvv/xyxPqk0USS3NwsFi2aSlpaMiJCWloyixZNJTc3i/ycPJITo/1eZ7FX+M0i8paf6IyB42Cmht4Xkd9JILm+DkDJiiVsmH07lj1loBSWPWVsmH17i5xBexOd27p1K/X19Vx99dWMHj2a77//Pqh++BOdO/HEE7FYLIBTHyklxb+So0bTEcjNzWL79nk4HP9h+/Z55OZmOcub2Ou4fN9hTxZRU/scd7bAcTCO4A7gNeCwiBwQkYMiciDCdoWVTQv+hv2wr+ic/XAtmxb8LeS22pvo3J49e/j222/597//zWOPPcYdd9zhOReq6Nzxxx/Ppk2bGDRoEC+99BKXXXZZSLZoNO0F94Pb++VNU3sdu7OIzth9AXV25Vd+4rSe0axYHvrzo70SzFaV3ZVSBqWUSSnVw3XcozWMCxeWvTtDKg+Et+jcrFmz/MYFmhKdMxgMPqJzI0eOJDs72yM61xISEhLIyMigR48eDBo0iIqKCs8599SQ285Ro0aRnZ3N5s2bPaJzgEd07sUXXyQ7O5tNmzbxwAMP8OCDD7bIJo2mLQk0eeFd3pxKqcVay4LV7wcMHMcZhf3fL+k0m90HMyLo8JiPaah113R5INqj6NyJJ55IeXm55549egT20c2JzgH06tULcDoYLUOt6cykxWfzmz7Pc+Wd33Dz3zb7SFWDa9+CAIHjGrvi1j6xPPPFY61gaeQJZh1Bh2fQtHvYMPt2n+khY0wcg6bdE1I77VF0buDAgdxxxx2MGDECh8PB008/7bkuVNG53Nxcz5SXzWbj+eefD+nz0Wg6IqlJfSmpcM4OeK8tqD7gIK1XJs/9/AYYj3yZc8tPVEQZeMZg4cySFeSmjW4r88NCi0Xn2oqWis6VrFjCpgV/w7J3J+Zj+jFo2j2kjb48rLZp0TmNpu1pKq/F3/OuoHgpUxbmceagGKZekeqTVmqUGA7uS+ejivVYYgxYHaBQxBgEi93pEAySzPbfLI1IX8JJU6JzAUcErn0IAqKU6lBJ5mmjLw/7g1+j0XR8crMmAlDT6x+N1hbY1WEOGzZzztbjeOTYH8lINBHlSrJwbmATzYb9FZR8t5y0k8e1uu3hoqkYwQZgvetnOfAj8JPr/YbIm9bx0KJzGk3bE2iWo6nZj9ysiST29P+9uGcPA3kfr+b0HtEBpCei2PDhgx06cBzQESilBiqljsOpHjpBKZWslErCuVnNG61loEaj0YSKO//f+9UcZmOy3/LK/fVYrLXERvmfcoo1CkXR9Wz69JmjsrktCSZr6ByllMfVKaXeBYZHziSNRqNpfQb1uDbg2gIAZbH7vc5iVyxMNLHCFvo2uu2FYBxBhYjcIyLpIpImIjMB/9J+Go1G00Fxry3YX23H4Wdtwd4v68DmO7JwZxBZDUJhQlDq/O2SYBxBDpCCU4H0TeAYV1mXpTVF52pqahg1ahTDhg1jxIgRbN++vVGdJ554gszMTMaPH+9ZxNYS0bm3337bUz8tLY2nnnqqxXZrNB2RtPhs4vf9Hzfc/aPP2gKzKY6p581gVMxYamwOzwY26/fXs6PWOVKoMCiKNyxrQ+tbTjAri/cppW5TSp3pet3W0TKGwJkilj79PAyTU0mffh4FxS1L92pt0bmoqCj+9a9/sWrVKu6+++5G4nPl5eUsW7aM1atXk5OTw7PPHtk8LlTRuUsuucRT/1e/+hWXXnppq/RRo2lP5GZNZNHUOaQl9+OCsxJZeN9g/jXrJBJOWMbFp57DtwcSWLKzjo3VNp9dzE6JNbDy/VnN36AdEsyexb8SkUUi8r6IfOR+tYZx4cKdJ1xSsROlFCUVO5myMK9FzqC1RediYmLo18+5Ajo6OpqoKN/MhnXr1pGdnY2IMGbMGNasWRNUP/yJzrmpqKigpqaG9PT04D8YjaYTkZs1kU8enc3t1/yKxJ5GRMBiL2dD1VxmDR5BWoxTfM57F7NTk2Iw963vkNlDwUwNvQZ8CdwD/Nnr1WGYWTgHi9VXdM5irWVm4ZyQ22or0bn6+noefPBB/t//+38+5VVVVR5ZCbd4nJtQRefcvPHGG0ycODGUj0Wj6XRsOvASdnXYp8yuDnPw4Huc1b1xKikGofi4bh1SdiIYiQmbUmp+xC2JIKWVu0IqD4S36JzD4aC2tpa8vDyfOk2JzgE+onP33Xcf9fX1HtE5dx1/TJkyhWnTpnH88cf7lCcmJrJlyxbgiHicm3fffddnSmjUqFFYrVbmzZvnEZ0zGo2NrluyZIlngxuNpqtisVf4Le/Zw4CxOnAq6TOxHU92IpgRwTIRmS4ifUSkl/sVccvCSGpS35DKA9FWonN/+9vfGDhwIJMnT250LiMjg6KiIgBWrFhBZmZmwHaCEZ2rqKjg4MGDDBw4sNnPQ6PpzDS5ruCgze85i11hNQh/+t8TkTQt7ATjCH6PcypoDc4Vxe4Vxx2G/Jw8zKY4nzKzKY78nLwAV/jn9ddfZ/jwI0somhKdmzBhAg899FDAttyic1dffbWP6FzDGMGuXbt44IEH+Oijj8jOzubuu+8GnI5k27ZtpKSkMGHCBDIzMyksLGT69Omea91TQ9nZ2ezevdun3RkzZjB79myGDRvmEZ0DWLp0qZ4W0mhoel3BxtUVOGwOn3PuVFKAPfXVHSpW0GVE5wqKlzKzcA6llbtITepLfk6eR2MkXGjROY2mc/HU84t48J732b9bSOitSM76hZ9UKQBnZqTS7zwTsVHSSIxu+34rD5XYOXvkve1Gg6hFonNeF1/rr1wp9dLRGtaa5GZNDPuDX6PRdF4KCor5y62rsFicEyf7fxH2v94bzq7BfKKFP51/J//a8Dgbj1OcleQrRndqUgxbqw4R8+kz7cYRNEUwweJzvN7HAhcB/wM6lCNoDbTonEbTeZg5sxCLxepbaDfSa8cJzF9ymPioZfy510QW7n3bbwbR+jQzaf/znZJtrzTrCJRSt3ofi0hP4OWIWaTRaDTtgNJS/0o6+3eLZ12BMWENA20mdvjRIbJHG1jdI55JkTY0DLRkq0oLcGK4DdFoNJr2RGpqkt/ypL5H4qp2dZjTE2L91rPYFS/GOfyea28Es7J4mYi87Xq9A/wAvNXcdRqNRtORyc/PwWz2FZIzxSly8nxTR2MNDmwO/2J01VGqQ2QPBTMi+DvwmOv1MDBMKTUjola1c9qb6Fz37t09aaIbN24EWiY6B869jS+88EKGDRvGF1980WK7NZqOTm5uFosWTSUtLRkRIaWfMHVOPVkTfaeBKvbX8/Xew37F6JLtqkNsWhNMjOATETmWI0HjnyJrUmQo3rCMwuWPU7n/F5IS+5Az7g6yzp4QcjveonPunP5I4had69evH++//z6PPvqoj7AcwEknneRZVOZNw5XF3rhF59wOY9KkSezfv5+33nqLlStXNrnvq0bTVcjNzSI3NwuAkpoiNlTNxa6OOAL3uoKqahsrTk+gb7coBveMYkivaE6zR9F7Zy12Wx2b2nn2UDBTQ1cAXwCTgCuAtSLSoTb/Ld6wjIWv3kPF/l0oFBX7d7Hw1XtaJBnb3kTnAH7++WfPwrC6urqg+uFPdO69994jJiaGiy++mGuuuabRKEKj6cq49yswG1Ma7Vew7+dD/KriMOd4CdGZowzU9DdTkmTCcrB9Zw8FMzU0E+cuZb9XSl0LnAv8NZjGRWSMiPwgIltEJOB0koicIyL2SDmYwuWPY633fUBa6+soXP54yG21N9E5gC1btrBq1Sr69OnDvHnzPOWhis7t2bOHqqoqPvjgA4YOHcrcuXND/nw0ms5MWnw2v+nzPHmzKnz2KwAYeGI3jA3SSO1G4ZOB8azuEd/KloZGMI7AoJTa63VcGcx1ImIEngXGAqcAOSJySoB6c3DujRwRKvf/ElJ5ILxF52bNmuU3LtCU6JzBYPARnRs5ciTZ2dke0bmmCCQ6B5CU5MxumDRpEl999ZWn3L0fgdvOUaNGkZ2dzebNmz2ic3BErC4hIYERI0YgIlx44YVs3rw5pM9Ho+mMFBQUkJ6ejsFgID09nYKCAh/ZmsyzEnj2nlP4/Sk9GNcnlgFmo8/1sUZhfjcHBSURe8QdNcE4gvdEZIWIXCci1wHvAMFEPs4FtiiltiqlrMBiwN9OJ7cCrwNNPwmPgqTEPiGVB6I9is7V1NR4HuirVq3ihBNOCNhOc6JzmZmZHkfy5ZdfctxxxzX7mWg0nZmCggKmTJlCSUmJcy+TkhKmTJkCpRYWTZ3DZcOOY+oVqaT0Mnn2JchINPk4A4tdUW+AvC+fbLuONEOTwWJxPsGexhkovgAQYJFSKpgdXfoBO7yOy4AhDdrvB0wELsR3BXNDO6YAUwBSU1ODuLUvOePuYOGr9/hMD5miY8kZd0dI7bz++uu89daRzNmmROdKSkp8pmka4hadGzx4sI/o3Pz5832mh9yic+6ppPPPP59Zs2Yxe/ZsJk+eTHV1NTfccAPdunUjMTHRJwNo7NixGI3OP8jFixfTu3dvz7kZM2ZwzTXXcO+993pE50477TT69OlDdnY2cXFxFBQUhPT5aDSdjZkzZ2KxWHzKLBYLM2fOZPv27SScsAyL3XfT+iiDMLhnNDssdh8hul3WKkq+W94ug8bNis65hIrODrlhkUnAaKXUTa7ja4BzvVcqi8hrwGNKqc9F5AXgv0qpJjUaWio6F66soabQonMaTefCYDD4Ha2LCA6Hg9fKLgEan1dK8eL2GjZW2zx7GifbHLxQk8hvbno30mb75ahE54DPReQcpdS6EO9bBgzwOu4PNNwJJgNY7Jo6SQbGiYhNKfVmiPdqlqyzJ4T9wa/RaDo3qamplJSU+C0H554FDUcEABWHHSzffWR3M5NDkVNdj6U2tLhkaxFMjGAE8JmI/Cwi34jIRhH5Jojr1gEnishAETEBVwJve1dQSg1USqUrpdKBJcD0SDiB1kKLzmk0nYv8/HzMZrNPmdlsJj8/H/C/Z4FRYqjeYuOUGGFc7xgu7xfLyL6xrOwby4cxhhalrUeaYEYEY1vSsFLKJiK34MwGMgLPK6W+FZFprvMLWtKuRqPRtBa5ubmAM1ZQWlpKamoq+fn5nvK0+GzAub+xxV6B2ZjMoB7XIr03cGrNO+BKJ42PEk5KiuF9EX4ufoQP29nsRDAxAn/bUh5UStVHxqSmaWmMQBN+9Gev0fji3gDr1EtNxPeIbnS+xuaguNTCgdy1rW5bUzGCYKaG/geUAz/ilJcoB7aJyP9EJOQgskaj0XRGCoqX8vzav3HXtJ4B1xSYjcKhaEO70x4Kah0BME4playUSsI5VfQqMB0InB/ZiWlN0TmAYcOGkZ2dzdChQ9m0aZPPudLSUrKzsxk+fDhjx46lqqoKaJnoXFFREQMGDCA7O5uLLrroqGzWaLoaS75+kut+27vZNQVJdsWmT59pQ0sbE4wjyFBKeZbEKaXex6lA+jkQE/iy9kXJd8t5559jee2JM3nnn2Nb7JG9Redai5UrV1JUVMSsWbN44oknfM716NGDN954g08++YSJEyfyj3/8w3POvbK4qKiokficW3Ru1apVzJ8/n9raWgAmT55MUVFRq/ZPo+kMXDwslliT7yPVvaYAnNLU31XVO7OHDrav7KFgHME+EckTkTTX6y6gyiUN0SF2XSj5bjkbPnzQ9eErLAd/abE0bGuLzoFTbA7gwIEDDB482OdcQkICvXr18tTzJ0rnD3+ic+BcNJeVlcVTTz0V7Eei0WiA5MTGMQFwTgfV2Bz8UHmY8Ttryaq1Y7GpdpU9FIwjuArnGoA3Xa8BQA7OTKArImVYONn06TPYbb6ic25p2FBpC9G58vJyMjMzmT59OsOGDfNrV3V1NQsXLuS6667zlIUqOpeRkcEPP/zAypUree+999iwYUPIn49G02Wx+Zd8x2JnxLYaBveM5pfTevJCRiIPn9iNB4ofaV37miCYr4/d/Oxb7F5gtiUyZoWXQBKwoUrDeovOORwOamtrycvL86nTlOgc4CM6d99991FfX+8RnXPXaUhKSgqffvopX3zxBX/5y1947733fM7X19dz1VVX8fe//53ExERPecP9CEaNGoXVamXevHke0Tmj0egRnfOue8kll/D1119z9tk6H0CjCYYhx0xjbeWTiOHIfgXKYeTb7/fx3XHdwCgIzlTSU1Ni+J/BSkHJCnLTRred0S6CGRG84dIEAkBEhgHPR86k8GPu3juk8kC0heiczWbD4XDOwPXs2dOjS+TN9OnTueKKK7jggguatL850bkDBw546hYXFzcpYKfRaHxJi89mSNIfMRtTAMFsTGFI0h/5oXsMGH2fAVEG4dTEaGZuah/LqYIZEUwF3hSRCcBZOLerbH+qSU0wKPNWNnz4oM/0kDEqlkGZtzZxVWPaQnRuz549XHXVVRgMBgwGg2d3Mrfo3O7du3nllVf46aef+Ne//sXEiRO57bbbgNBF5/7973+zaNEioqKiyMzMDDgNpdFo/JMWn+1ZZObGEfeQ37pmo1Bq2dMKVjVPswvKAETkfGAhUAf8RinVWFyjlWjpgrKS75az6dNnsBzcjbl7bwZl3hp2FUAtOqfRaAoKipk5s5DS0kpSU5M44aZKel1U0ahejc3BFzsPU37lmlaxq0WicyKyDF9ZPTNQDTwnIiilLgmvmZEl7eRx7VL+VaPRdB4KCoqZMmUhFosVgJKSCn55GKb06MbZl9jYWF3vkaf+rqqeK6vqKN6wrM0FMZuaGvp7q1nRSdCicxpN12bmzEKPE3BjrYXFj0Qz7LcOMhJNHLYf5uMyC+N31XHWQRuFyx9vv45AKfUJgIgMBH5RStW5juOAY1vHPI1Go+k4lJZW+i2v3OUMFkcZhCHdovhPjZ1nepno3j2KU7b7v6Y1CSZr6DV8F47ZXWUajUaj8SI1NclveVLfI7PsMXFGstPMjOsTS0JPE/87oVub72ccjCOIcu05DIDrvSlyJmk0Gk3HJD8/B7PZ9/FoilPk5Nk8xxa78tIiiqZ3vLHN9zMOxhGUi4gnMCwilwKNQ+BdiNYWnQOnuFxMTEwj0TmAJ554gszMTMaPH+9ZxNYS0Tk3s2bNCovNGk1XIzc3i0WLppKWlowIJPdTTJ1TT9ZE5yIz5x7GRxT8nVpEUeyyVreVyUBwjmAa8BcRKRWRHUAezrUFHYqCkhWkvzMRw2uZpL8zscVDsbYQnQOYM2cOmZmZjcrLy8tZtmwZq1evJicnx7POAFomOnfw4EG/zkaj0QRHbm4W27fPw+F4lfU/3Mzoy3sBTr2h9fut7LDYfeqbjUKSvW1l25p1BEqpn5VS5wGnAKcopYYqpTqEtISbgpIVTNkwmxLLHhSKEssepmyY3SJn0Baic9u2bUNEPPukerNu3Tqys7MREcaMGcOaNcHlJAcSnXvqqae4+eabg/9ANBpNQNLis/lNn+exbrueJT8cauQEAGrtit/ut7apCF0wIwJE5Dc49x+4XUTuFZF7I2tWeJm5aQEW+2GfMov9cIuWd7eF6NycOXO48847/dpTVVVFjx49gCPicW5CFZ2rrq5m48aNDB06NMRPRaPRNMXMwjkYf6llXO9YLu8f59m0xu5QHFtmoduuOgqXP95m9jUrMSEiC3AuJhsB/BO4HPgiwnaFlVLL3pDKA9EWonPuUUd6erpfmxITE9myxTlAc4vHuQlVdO7JJ5/klltuCekz0Wg0zTMg1cLlwwYQG+388hUfJWQkmth5oJ7njQbMJ3VncIDU09YgmBHBUKXUtcB+pdQDwPk4pag7DKnmY0IqD0RbiM59/fXXfPvtt4wZM4YPPviAadOmUV9/JNiUkZFBUVERACtWrPAbR3DTnOjcli1byM/PZ8yYMfz000+eKSuNRnN0XDOhv99Na0b3N3N5/ziy083sOa1nm6WRBuMIal0/LSLSF6gHBkbOpPCTP2gaZqPvZmpmYwz5g6aF1M7rr7/O8OHDPcdNic5NmDCBhx7yLzYFR0Tnrr76ah/RuYYxgt/+9rcUFxfz3nvvcfHFF7NgwQKio6OZPXs227ZtIyUlhQkTJpCZmUlhYSHTp0/3XOueGsrOzmb3bl/J7RkzZjB79myGDRvmEZ17+eWXee+993jvvfc48cQTmTFjRkifj0aj8U9CD6Pf8vgo8aSSntkrmke/e6yVLXPSrOiciPwVeAa4CHgWp/7QP5RSbRInaKnoXEHJCmZuWkCpZS+p5mPIHzQt7DrgWnROo9H4451fbsBib6zVWWNzsPyXOp/jd7I+jogNLRKdc6OUcn+tfV1E/gvEKqXaNum1BeSmjW4XG0BoNJqux6Ae17Khai52dSRppeGaAnCmkrYFwQSLY3FmDF2AczSwWkTmu7WHNEfQonMajcYf7j0KNh14CYu9gpp6OxsP1DdKJzXWN78tQCQIZmOal4CDOKeHwLlf8cvApEgZpdFoNJ0N701rps07i32nJ4DBawTgUCR8Ww3D/V4eUYJxBCcppU73Ov5YRL6OlEEajUbT2TFU9qTX11VYTu5BXYyBWrvi6+p69ifEktUG+xgH4wi+FJHzlFKfA4jIEODTyJql0Wg0nZdLfzuB3fIBcd2NVBx28EqphR21DoiG/1v3MECrOoOmdijbiDMmEA1cKyKlruM0YHPrmKfRaDSdi5KaImoS1mBWzsdvSqyRm0/oxrm9DvPDQRsbq23kfflkqzqCptYRjAcmAGNwrhsYDmS73v8m4pa1Y1pbffTEE0/0rAf44IMPGp0Pl/roBx98wAUXXMAFF1zANddcg93eWBdFo9EcHZsOvOSTPQTOxWWnJZg80tTGqEMBro4MTe1QVtKahkSa4vIPKSx9jkprOUmmFHJSbyQrZWTI7Xirj959990RsLQxPXv29Kweboi3+ugrr7zCs88+y1/+8hegscSEN271UbfDmDRpEsOHD2f16tUAXH/99axZs4asrKyI9Emj6apY7P5V/N2po1EG4bSewczah4+gROdaioiMEZEfRGSLiDRapioiuSLyjeu1RkRO99fO0VJc/iELtz5OhXUvCkWFdS8Ltz5OcfmHIbfVFuqjhw4dYvjw4Vx11VU+onIQXvVRk8m5oYZSCqUUAwd2qAXkGk2HwGxM9ltusR9JHY1r5fUEEXMEImLEuRJ5LE4J6xwROaVBtW3AcKXUacBDwKJI2FJY+hxWh+9QzOo4TGHpcyG31Rbqo59++imffPIJY8aM4f777/c5F071UYCXX36ZU089lfLyclJSUkL+fDQaTdMM6nEtRvGVvGm4uMxY27rTspEcEZwLbFFKbXVtb7kYuNS7glJqjVJqv+vwc6B/JAyptDZe2t1UeSC81UdnzZrlNy7QlPqowWDwUR8dOXIk2dnZHvXRQCQlOfdBnTRpEl999ZXPucTERA4cOAD4Vx8tKiry2Dlq1Ciys7PZvHmzR3204XXXXHMNmzdvJj09naVLl4b0+Wg0muZJi8/m7IRbWPtWAtPPi+GK1FimnhfD6qVOPSK7QxG710rJd8tbzaZIOoJ+wA6v4zJXWSBuBN71d0JEpojIehFZX14e2sMbIMnk/5ttoPJAtIX6qNVq5fBh52hm1apVnHDCCT7nw6k+6r4PQI8ePTxieBqNJrysftPI/LsUFTsNoISDvxj56pFuJKyNx6bgFQM8sfrBVnMGkYxI+Jvk8vu0E5EROB3BBf7OK6UW4Zo2ysjICHkNdk7qjSzc+rjP9JDJEENO6o0htfP666/z1ltveY6bUh8tKSlh3rx5Adtyq48OHjzYR310/vz5PtND+/fvZ9y4ccTHxxMTE8Pzzz8POB3J5MmTGThwoEd9NDExkYKCAs+1Y8eOxWh0fstYvHgxvXv39pybMWMG11xzDffee69HffQf//gHBQUFKKX49a9/zW9+06WTwzSaiDFzZiEWi9WnzForLP27iafXmBlgNvJBmYWLP32GtJPHRdyeZtVHW9ywyPnA/Uqp0a7juwGUUrMa1DsNWAqMVUr92Fy7LVUfDVfWUFNo9VGNRhMMBsNkv7MAIor/lNZRY3Pw9s5ahv58iDuvDc8+YEelPnoUrANOFJGBwE7gSuCqBoalAm8A1wTjBI6GrJSRYX/wazQaTUtITU2ipKRxGmlSX6dzMBuFKIOwcYC5VeyJWIxAKWUDbgFWAN8BryqlvhWRaSLi3hHmXiAJmCciX4nI+gDNdQi0+qhGowmG/PwczGaTT5kpTpGTZwOOpJLWxkQ0w99DRFctKKWWA8sblC3wen8TcFMkbdBoNJr2Rm6uc6Fm3t3/YlfZQZL6Op1A1kS7TyqpoZXE/lt3+ZpGo9FoAKczyM3NoqSmiOLdT2Iy2aixOZ3ADosdu0MRXdU6U0PaEWg0Gk0bkhafzfDHZpB2ho3uJ3cnzihY7IqN1Tb21Fdy7mePcNv5d0XUhtaZgOpktLboXFlZGZdccgnZ2dmNVh5XVFSQmZnJ8OHDGTFiBLt27QJaJjq3fPlyhg4dygUXXMAtt9xyVDZrNJrgKa3cRezAeCb0i2PSADOTBpi5pG8sx8ZHkV/6VvMNHCVdZkRQUlPk2SbObExmUI9rPbsFhUJbiM79+c9/Zv78+fTr13g9XmJiIqtWrcJoNPLiiy/y3HPPeaQtQhWdGzRoEKtWrSIqKoqrrrqKdevWcc4550S0bxqNBi7NGsjlJ3XH5NqxLD5KyEyOIVrgjZ21Eb9/lxgRlNQUsaFqLhZ7OaCw2MvZUDWXkpqikNtqbdG5+vp6tm/fzp/+9CcuvPDCRqJyRqPRs2jswIEDDBo0KKh++BOdS01NJSrK+d0gOjra816j0USWnN/08TgBN1EG4fREE6f1jI74/bvEf7o//W+7OsymAy+FPCpYuXIlt9xyC2azmSVLlpCXl+dzvqysjJUrV7J7925uuOEGPvzwQ4/o3IABAzjzzDO5++67PaJzSinOP/98brvtNr+icxUVFXzzzTe89tprREVFcckll/DFF74LTDZu3MhNN91EVVUVK1as8JS7VxZ369at0dRVINE5gA0bNlBRUcGZZ54Z0mej0WhahkRb/JabjUJsKyiRdglHEEj/O1B5ILxF5xwOB7W1tY0cQVOic4CP6Nx9991HfX29R3TOXcebhIQEfvWrX9G/v1OPLyoqCpvN5vNtffDgwaxdu5ZXX32V2bNns2CBM0O34dTQqFGjsFqtzJs3zyM6ZzQafUTnysrKuO2227TgnEbTipiNya4ZC18sdgXWyKg/eNMlpoYC6X8HKg9EW4jOxcXFkZCQQHV1NTU1NVitVh8nYLUe0Svp2bNnk0JxzYnOHTp0iKuuuooFCxZoCWqNphUZ1ONalMP3cWxzKL7eb2XDwXqe+uyRiN6/SzgCf/rfRolhUI9rQ2rn9ddfZ/jw4Z7jpkTnJkyYwEMPPRSwLbfo3NVXX+0jOudvY5r8/HzGjx/PRRdd5Glz9uzZbNu2jY0bNzJs2DBGjBjB008/zZ///GfPde79CLKzs9m9e7dPmzNmzGD27NkMGzbMIzr3zDPP8PPPP3PLLbeQnZ3NJ598EtLno9FoWkZafDZDkm6n6rAdpRQ1Ngfr9h2mrNbOyQnRLCpfFtH7R0x0LlK0VHQuXFlDTaFF5zQazdFgePV8JvSNY2L/OMye9QT1bDtkY1z0WG4698/NNxKAthKda1ekxWeH/cGv0Wg04WRMUixXppqJ8kojzUh0ahJ9WPkuN9FyR9AUXWJqqLXQonMajeZouOb4JI8TcBNlEAb3jMYRG7n7akeg0Wg07YSoKKvfcrNRiDocuWl87Qg0Go2mneDOZCxeamT6eTFMTo1l+nkxrHzdgHlvXcS2rtSOQKPRaNoJg3pcy8dvGFmYF03FTgNKCRU7DTx/dwzvfhHP+o/nROS+2hG0gNYUnbNarZ4U0CFDhvhd7Xv77bczbNgwJk6cyIEDB4CWic79/PPPnHnmmcTGxjaqr9FoIk9afDbP5xux1vrGCWx1wsHCnmyLj4zuUJdxBAUFxaSnT8dgmEx6+nQKCopb1I636FxrYDKZKCoqoqioiFtvvZXLLrvM5/y6deuoqKhg1apV5OTkMH/+fM+5d99913NtQ/E5t+jcqlWrmD9/PrW1tfTp04eioiLOO++81uiaRqPxw+Fy/4/lQ7sNVJzSIyL37BKOoKCgmClTFlJSUoFSipKSCqZMWdgiZ9DaonPevPbaa0yaNMmnbOvWrZxxxhkAnHXWWRQXB9cnf6JzZrPZsxpao9G0DUl9/SsGJ/VV/Dolxu+5o6VLOIKZMwuxWHyj8RaLlZkzC0Nua+XKlYwaNYqcnBy/qaJlZWUUFhby1ltveeSg3aJzn332GYsXLwbwiM6tXbuWN998k9raWr+ic24OHjzIjh07OOWUU3zKTz75ZIqKilBKeQTu3LhXFo8fP75Re02Jzmk0mrbjqTk3YIrzzRBy72dsjpAAXZdYUFZaWhlSeSDaQnTOzdtvv80ll1zSqPy0004jMzOTESNGMGTIEHr37u051xLROY1G07bk5mbx8d5HeesxE5W7xGc/4wNWB8UblpF19oSw3rNLjAhSU5NCKg9EW4jOufE3LeRmxowZFBUVcfLJJzeKIXjTnOicRqNpH/xw+gGeXFPHf0rrmPf5Yc+m9puq6/nXhsfDfr8u4Qjy83Mwm00+ZWazifz8nJDaaSvRuYMHD1JaWsqpp57qKXOLzoEzQ2jkyJFs3LiRq666ylMnVNG5/fv3M3LkSL7++msmTJjA+++/H8Kno9FowsW2A3F8VnGYw3aFUs6XTSkMBuHQcY6w36/LiM4VFBQzc2YhpaWVpKYmkZ+fQ25uVlht06JzGo0mHBSUrGDD/r9zTq8YH8kJm0Oxbt9hHj/jg5Db1KJzOOfdwv3g12g0mkiQmzYaq+PpALpDpgBXtZwuMTXUWmjROY1GEy7io/xnCAUqPxq0I9BoNJp2SI3N/7T9YYcKu+aQdgQajUbTDtlYbcWuVCMBurVvRfHS1kfDei/tCDQajaYdUl0bzydvGBoJ0P1jhomSH7uH9V7aEbSA1hSdA7j++utJSUlh7ty5fs8/8cQTZGZmMn78eM8ituZE5xqyefNmsrKyOP/88/nwww8BWLNmDYMGDfJZpKbRaFqH6064hSWPmhoJ0FlrhbceC2/AuMs4guKla5h+3h1MTv0908+7g+Kla1rUTmuLzgE8/PDDPPqo/6FgeXk5y5YtY/Xq1eTk5PDss896zgUSnSsqKuKFF17waecvf/kLzz//PCtWrODee+8F4NRTT+WLL76gf//+4e+URqNpkqyUkVTs8h8YDlTeUrqEIyheuoaFef+iYmclSkHFzkoW5v2rRc6gLUTn+vTpE9CedevWkZ2djYgwZswY1qxpmYP75ZdfOPHEE+nRowdJSUlUVFTQs2dPzGZzi9rTaDRHT1Jf/wHj7gmwZPNdYbtPRB2BiIwRkR9EZIuIzPBzXkTkadf5b0TkrEjYUThnCdZaX9E5a62Vwjmhp3q2lehcIKqqqujRwylN21A8rinRuYZ4LyzUInQaTfsg5656oqIVv+sbw+X9Yj2vUXGxrPzg+7DdJ2ILykTECDwLXAyUAetE5G2l1GavamOBE12vIcB818+wUrnLv7hcoPJAtKXoXCASExPZsmULQCPxuIaic8899xwvv/wyVVVV1NXV8cILL3DxxRczc+ZMjxKpv3Y0Gk3bcNYEG5fO6YGINNIsK3+kJ9wWnvtEckRwLrBFKbVVKWUFFgOXNqhzKfCScvI5kCAigedBWkhSX//icoHKA9GWonOByMjIoKioCIAVK1aQmZkZsO6NN95IUVERTz75pEeobubMmQD07t2bn376iQMHDrBv3z6Sk5NbZI9Gowkfy3dY/DoBf2VHQyQdQT9gh9dxmass1DqIyBQRWS8i68vLy0M2JCfvckxxvlF2U5yJnLzLQ2qnrUTn7r77bh599FHmzp3Ln/70J+CI6FxKSgoTJkwgMzOTwsJCpk+f7rmuKdG5hjz88MPccMMNjB492jM99d133zFy5Eh+/PFHjxidRqNpPXr+PLBV7hMx0TkRmQSMVkrd5Dq+BjhXKXWrV513gFlKqdWu45XAXUqpDYHabanoXPHSNRTOWULlrkqS+iaRk3c5WROHtrR7ftGicxqNJtxM6n+t32//SileK3sp6HbaSnSuDBjgddwf2NWCOmEha+LQsD/4NRqNJtK4v6x7OwO3NHW4iOTU0DrgRBEZKCIm4Erg7QZ13gaudWUPnQdUK6V+iaBNEUWLzmk0mnCzZOfLnge/92vJzpfDdo+IjQiUUjYRuQVYARiB55VS34rINNf5BcByYBywBbAA17fwXmENnGiap6PtY6HRdGTC+dD3R0T3I1BKLcf5sPcuW+D1XgE3H809YmNjqaysJCkpSTuDVqSuro7o6Oi2NkOj0YSBDr8xTf/+/SkrK6Ml2USao6OpFc8ajabj0OEdQXR0NAMHtk6KlUaj0XRGuoTWkEaj0WgCox2BRqPRdHEitqAsUohIOVDSwsuTgYowmtMR0H3uGug+dw2Ops9pSqkUfyc6nCM4GkRkfaCVdZ0V3eeuge5z1yBSfdZTQxqNRtPF0Y5Ao9FoujhdzREsamsD2gDd566B7nPXICJ97lIxAo1Go9E0pquNCDQajUbTAO0INBqNpovTKR2BiIwRkR9EZIuIzPBzXkTkadf5b0TkrLawM5wE0edcV1+/EZE1InJ6W9gZTprrs1e9c0TELiKhbUnXDgmmzyKSLSJfici3IvJJa9sYboL42+4pIstE5GtXn1ukYtxeEJHnRWSviGwKcD78zy9/Otcd+YVT8vpn4DjABHwNnNKgzjjgXUCA84C1bW13K/R5KJDoej+2K/TZq95HOFVwL29ru1vh95wAbAZSXcfHtLXdrdDnvwBzXO9TgH2Aqa1tP4o+DwPOAjYFOB/251dnHBGcC2xRSm1VSlmBxcClDepcCryknHwOJIhIR5bSbLbPSqk1Sqn9rsPPce4G15EJ5vcMcCvwOrC3NY2LEMH0+SrgDaVUKYBSqqP3O5g+K6C7OHXou+F0BLbWNTN8KKVW4exDIML+/OqMjqAfsMPruMxVFmqdjkSo/bkR5zeKjkyzfRaRfsBEYAGdg2B+z78CEkWkSEQ2iMi1rWZdZAimz3OBk3Fuc7sRuE0p5Wgd89qEsD+/OrwMtR/87U7TMEc2mDodiaD7IyIjcDqCCyJqUeQJps9PAnlKKXsn2bQomD5HAWcDFwFxwGci8rlS6sdIGxchgunzaOAr4ELgeOADESlWSh2IsG1tRdifX53REZQBA7yO++P8phBqnY5EUP0RkdOAfwJjlVKVrWRbpAimzxnAYpcTSAbGiYhNKfVmq1gYfoL9265QStUANSKyCjgd6KiOIJg+Xw/MVs4J9C0isg34NfBF65jY6oT9+dUZp4bWASeKyEARMQFXAm83qPM2cK0r+n4eUK2U+qW1DQ0jzfZZRFKBN4BrOvC3Q2+a7bNSaqBSKl0plQ4sAaZ3YCcAwf1tvwVkiUiUiJiBIcB3rWxnOAmmz6U4R0CIyLHAScDWVrWydQn786vTjQiUUjYRuQVYgTPj4Hml1LciMs11fgHODJJxwBbAgvMbRYclyD7fCyQB81zfkG2qAys3BtnnTkUwfVZKfSci7wHfAA7gn0opv2mIHYEgf88PAS+IyEac0yZ5SqkOK08tIoVANpAsImXAfUA0RO75pSUmNBqNpovTGaeGNBqNRhMC2hFoNBpNF0c7Ao1Go+niaEeg0Wg0XRztCDQajaaLox2BpsMjIv8UkVMi0O6hEOtPEpHvRORj13GhSx3ydhF5UERGNnFthog8fbQ2azQtQaePajQBEJFDSqluIdR/D6cK5sci0hunKmRa5CzUaMKDHhFoOgwiEi8i77h05zeJyGRXeZGIZLje3ygiP7rK/iEic13lL7g03NeIyFb33gQi0k1EVorI/0Rko4j4UzBtaMfVIvKFS/N/oYgYReRenPpNC0TkUeB94BhXnSzX/d33PMdlx9eudrqLcw+B/3r183kRWSciX7ptEpHrROQNEXlPRH4SkUe8bBrj6sPXrv4YXHVSXOcN4tSvTw7fb0TTWeh0K4s1nZoxwC6l1G/AuSGJ90kR6Qv8FaeW+0Gc+xB87VWlD86H9a9xLtNfAtQBE5VSB1wPyc9F5G0VYKgsIicDk4FMpVS9iMwDcpVSD4rIhcCdSqn1IvIs8F+l1Bmu6250/TQB/wEmK6XWiUgPoLbBbWYCHymlbhCRBOALEfnQde4M4EzgMPCDiDzj6sM/gGFKqW0i0ksp5RCRfwO5OMX3RgJfd+QVt5rIoUcEmo7ERmCkiMwRkSylVHWD8+cCnyil9iml6oHXGpx/UynlUEptBo51lQnwsIh8A3yIU873WAJzEU51z3Ui8pXr+LgQ+nAS8ItSah2AUuqAUqqhdv4oYIar/SIgFkh1nVuplKpWStXh3IAmDefmJKuUUttcbbq17J8H3DLUNwD/CsFOTRdCjwg0HQal1I8icjZOnZVZIvK+UupBryrNaU0f9lM3F+euVme7vuFvx/ngDYQALyql7g7Nep/rmwvMCfA7pdQPPoUiQ/Dtgx3n/7DfNpVSO0Rkj2ukMgRnXzWaRugRgabD4Jr6sSil/g38HecUkDdfAMNFJFFEooDfBdFsT2CvywmMwPkNuylWApeLyDEum3qJSCgB4e+BviJyjuv67i5bvVkB3CriVAcUkTObafMznP0e6LbJ69w/gX8Dryql7CHYqelC6BGBpiMxGHhURBxAPfAH75NKqZ0i8jCwFqc++2ag4fRRQwqAZSKyHufmJt83VVkptVlE7gHeFxGDy46bgZJgOqCUsrqC3M+ISBzO+EDDtNKHcM7rf+NyBtuB8U20WS4iU4A3XDbtBS52nX4b55SQnhbSBESnj2o6FSLSTSl1yPUteylO2eKlbW1XW+HKpnpCKZXV1rZo2i96akjT2bjfFWTdBGwD3mxTa9oQEZkBvA60NJ6h6SLoEYFGo9F0cfSIQKPRaLo42hFoNBpNF0c7Ao1Go+niaEeg0Wg0XRztCDQajaaL8/8BglOH2eXTRGwAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "alphas = np.logspace(-10,1,11)\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "it=0\n",
    "for alpha in alphas:\n",
    "    c1 = 1.*( float(it) % 3.)/3.0\n",
    "    c2 = 1.*( float(it) % 9.)/9.0\n",
    "    c3 = 1.*( float(it) % 27.)/27.0\n",
    "    probs,accept,rej = runSciKitRegressionL2(18,alpha)\n",
    "    ax.scatter(accept,rej,c=[[c1,c2,c3]],label='Alpha: %.1E' %alpha)\n",
    "    it+=1\n",
    "\n",
    "ax.set_xlabel('signal efficiency')\n",
    "ax.set_ylabel('background rejection')\n",
    "plt.legend(loc='lower left', fontsize = 'small');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With L2 regularization we get all the way up to 79% accuracy and have a stable local maximum of it in $\\alpha$ space. This is completing the picture that L2 regularization is better suited to the task at hand, which makes sense considering all the input variables are in fact important."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b> Exercises:</b>\n",
    "* Try running sci-kit learn after scaling the data - does it help the performance?\n",
    "<br><span style=\"color:blue\">\n",
    "There is no significant increase in accuracy: $0.790$ (with $\\alpha=3.16 \\times 10^{-5}$) compared to $0.789$ (with $\\alpha = 3.98 \\times 10^{-4}$). It seems that there is nothing new to learn in the data, making the model more expensive and slower to build than it should be if one keeps increasing the size of the training dataset.\n",
    "</span>\n",
    "* Try coming up with some 'rectangular' requirements (i.e. a set of optimized requirements on the input variables) and see how the ROC curve for those requirements compares to using Logistic Regression.\n",
    "\n",
    "![NB5_2.png](https://github.com/DBustamante98/ML/blob/main/NB5_2.png?raw=true)  \n",
    "\n",
    "<br><span style=\"color:blue\">\n",
    "There is a clear performance benefit from using logistic regression. In the cut-based approach, we have set a requirement to the missing energy magnitude. While putting more requirements would increase background rejection, it would also decrease signal efficiency.\n",
    "</span>\n",
    "* Is there a way we could select a region training data that could potentially improve performance? Hint: Think about where the gains of ML are most valuable.\n",
    "<br><span style=\"color:blue\">\n",
    "Missing energy is carried by particles that do not interact with the electromagnetic or strong forces and thus are not easily detectable. In general, missing energy is used to infer the presence of non-detectable particles and is expected to be a signature of many theories of physics beyond the Standard Model. Therefore, if we look at a subset of the data where the missing energy is relatively large, we might expect the model to learn more from events outside the Standard Model. \n",
    "</span><br>\n",
    "\n",
    "![NB5_3.png](https://github.com/DBustamante98/ML/blob/main/NB5_3.png?raw=true)    \n",
    "\n",
    "<br><span style=\"color:blue\">\n",
    "We  see an increase in performance when looking at the data with <code>'missing energy magnitude' > 2</code>.    \n",
    "</span>\n",
    "* Try adding a layer of neurons in the TensorFlow code to see if you can improve performance (see also discussion in Notebook 13: __Section IX: Pytorch DNN (SUSY)__).\n",
    "\n",
    "![NB5_4.png](https://github.com/DBustamante98/ML/blob/main/NB5_4.png?raw=true)    \n",
    "\n",
    "<br><span style=\"color:blue\">\n",
    "Neural network gives a slight increase in performance.\n",
    "</span>"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}