{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# How to rediscover the Higgs boson yourself - with a BDT!\n", "This notebook uses ATLAS Open Data http://opendata.atlas.cern to show you the steps to apply Machine Learning in search for the Higgs boson!\n", "\n", "ATLAS Open Data provides open access to proton-proton collision data at the LHC for educational purposes. ATLAS Open Data resources are ideal for high-school, undergraduate and postgraduate students.\n", "\n", "Notebooks are web applications that allow you to create and share documents that can contain for example:\n", "1. live code\n", "2. visualisations\n", "3. narrative text\n", "\n", "This notebook builds on [HZZAnalysis.ipynb](https://github.com/atlas-outreach-data-tools/notebooks-collection-opendata/blob/master/13-TeV-examples/uproot_python/HZZAnalysis.ipynb) in the same folder as this notebook. \n", "\n", "HZZAnalysis.ipynb loosely follows the [discovery of the Higgs boson by ATLAS](https://www.sciencedirect.com/science/article/pii/S037026931200857X) (mostly Section 4 and 4.1)\n", "\n", "Notebooks are a perfect platform to develop Machine Learning for your work, since you'll need exactly those 3 things: code, visualisations and narrative text!\n", "\n", "We're interested in Machine Learning because we can design an algorithm to figure out for itself how to do various analyses, potentially saving us countless human-hours of design and analysis work.\n", "\n", "Machine Learning use within ATLAS includes: \n", "* particle tracking\n", "* particle identification\n", "* signal/background classification\n", "* and more!\n", "\n", "This notebook will focus on signal/background classification.\n", "\n", "By the end of this notebook you will be able to:\n", "1. run a Boosted Decision Tree to classify signal and background\n", "2. know some things you can change to improve your Boosted Decision Tree\n", "\n", "Feynman diagram pictures are borrowed from our friends at https://www.particlezoo.net" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Contents: \n", "\n", "[Running a Jupyter notebook](#running)
\n", "[First time setup on your computer (no need on mybinder)](#setup_computer)
\n", "[To setup everytime](#setup_everytime)
\n", "[Lumi, fraction, file path](#fraction)
\n", "[Samples](#samples)
\n", "[Changing a cut](#changing_cut)
\n", "[Applying a cut](#applying_cut)
\n", "[Optimisation](#optimisation)
\n", "[Boosted Decision Tree (BDT)](#BDT)
\n", "  [Training and Testing split](#train_test)
\n", "  [Training Decision Trees](#training)
\n", "  [Assessing a Classifier's Performance](#performance)
\n", "  [Receiver Operating Characteristic (ROC) curve](#ROC)
\n", "  [Overtraining check](#overtraining)
\n", "  [Optimisation](#BDT_optimisation)
\n", "[Going further](#going_further)
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Running a Jupyter notebook\n", "\n", "To run the whole Jupyter notebook, in the top menu click Cell -> Run All.\n", "\n", "To propagate a change you've made to a piece of code, click Cell -> Run All Below.\n", "\n", "You can also run a single code cell, by clicking Cell -> Run Cells, or using the keyboard shortcut Shift+Enter." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## First time setup on your computer (no need on mybinder)\n", "This first cell only needs to be run the first time you open this notebook on your computer. \n", "\n", "If you close Jupyter and re-open on the same computer, you won't need to run this first cell again.\n", "\n", "If you open on mybinder, you don't need to run this cell." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import yaml\n", "import subprocess\n", "import sys\n", "\n", "# Path to your binder/environment.yml file\n", "environment_file = \"../../binder/environment.yml\"\n", "\n", "# Packages you want to install\n", "required_packages = ['scikit-learn', 'pandas', 'uproot3', 'numpy', 'matplotlib']\n", "\n", "# Load the environment.yml file\n", "with open(environment_file, 'r') as file:\n", " environment_data = yaml.safe_load(file)\n", "\n", "# Extract dependencies\n", "dependencies = environment_data.get('dependencies', [])\n", "\n", "# Create a list to hold the packages with versions\n", "install_packages = []\n", "\n", "# Find the versions for the required packages\n", "for dep in dependencies:\n", " # Check if the dependency is a string (package name)\n", " if isinstance(dep, str):\n", " for package in required_packages:\n", " if dep.startswith(package):\n", " install_packages.append(dep)\n", "\n", "# Install packages using pip\n", "if install_packages:\n", " print(f\"Installing packages: {install_packages}\")\n", " subprocess.run([sys.executable, \"-m\", \"pip\", \"install\", \"--upgrade\", \"--user\"] + install_packages)\n", "else:\n", " print(\"No matching packages found in environment.yml.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## To setup everytime\n", "Cell -> Run All Below\n", "\n", "to be done every time you re-open this notebook.\n", "\n", "We're going to be using a number of tools to help us:\n", "* uproot: lets us read .root files typically used in particle physics into data formats used in Machine Learning\n", "* pandas: lets us store data as dataframes, a format widely used in Machine Learning\n", "* numpy: provides numerical calculations such as histogramming\n", "* matplotlib: common tool for making plots, figures, images, visualisations" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import uproot3 # for reading .root files\n", "import pandas as pd # to store data as dataframe\n", "import time # to measure time to analyse\n", "import math # for mathematical functions such as square root\n", "import numpy as np # # for numerical calculations such as histogramming\n", "import matplotlib.pyplot as plt # for plotting\n", "from matplotlib.ticker import AutoMinorLocator # for minor ticks\n", "\n", "import infofile # local file containing info on cross-sections, sums of weights, dataset IDs" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Lumi, fraction, file path\n", "\n", "General definitions of fraction of data used, where to access the input files" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "lumi = 10 # fb-1 # data_A+B+C+D\n", "\n", "fraction = 0.03 # reduce this is you want the code to run quicker\n", " \n", "#tuple_path = \"Input/4lep/\" # local \n", "tuple_path = \"https://atlas-opendata.web.cern.ch/atlas-opendata/samples/2020/4lep/\" # web address" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Samples\n", "\n", "In this notebook we only process the signal H->ZZ and the main background ZZ, for illustration purposes. You can add data and the Z and ttbar backgrounds after if you wish." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "samples = {\n", "\n", " 'ZZ' : {\n", " 'list' : ['llll']\n", " },\n", "\n", " r'$H \\rightarrow ZZ \\rightarrow \\ell\\ell\\ell\\ell$' : { # H -> ZZ -> llll\n", " 'list' : ['ggH125_ZZ4lep'] # gluon-gluon fusion\n", " }\n", "\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Define function to get data from files.\n", "\n", "The datasets used in this notebook have already been filtered to include at least 4 leptons per event, so that processing is quicker." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "def get_data_from_files():\n", "\n", " data = {} # define empty dictionary to hold dataframes\n", " for s in samples: # loop over samples\n", " print('Processing '+s+' samples') # print which sample\n", " frames = [] # define empty list to hold data\n", " for val in samples[s]['list']: # loop over each file\n", " if s == 'data': prefix = \"Data/\" # Data prefix\n", " else: # MC prefix\n", " prefix = \"MC/mc_\"+str(infofile.infos[val][\"DSID\"])+\".\"\n", " fileString = tuple_path+prefix+val+\".4lep.root\" # file name to open\n", " temp = read_file(fileString,val) # call the function read_file defined below\n", " frames.append(temp) # append dataframe returned from read_file to list of dataframes\n", " data[s] = pd.concat(frames) # dictionary entry is concatenated dataframes\n", " \n", " return data # return dictionary of dataframes" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "define function to get cross-section weight" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "def get_xsec_weight(sample):\n", " info = infofile.infos[sample] # open infofile\n", " xsec_weight = (lumi*1000*info[\"xsec\"])/(info[\"sumw\"]*info[\"red_eff\"]) #*1000 to go from fb-1 to pb-1\n", " return xsec_weight # return cross-section weight" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "define function to calculate weight of MC event" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "def calc_weight(xsec_weight, mcWeight, scaleFactor_PILEUP,\n", " scaleFactor_ELE, scaleFactor_MUON, \n", " scaleFactor_LepTRIGGER ):\n", " return xsec_weight*mcWeight*scaleFactor_PILEUP*scaleFactor_ELE*scaleFactor_MUON*scaleFactor_LepTRIGGER" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We add functions to return the individual lepton transverse momenta, in GeV" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def calc_lep_pt_i(lep_pt,i):\n", " return lep_pt[i]/1000 # /1000 to go from MeV to GeV" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Changing a cut\n", "\n", "We apply 'cuts' to throw away collisions that have properties different to the signal we're looking for.\n", "\n", "If you change a cut: Cell -> Run All Below\n", "\n", "If you change a cut here, you also need to make sure the cut is applied in the \"[Applying a cut](#applying_cut)\" cell." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "# cut on lepton charge\n", "# paper: \"selecting two pairs of isolated leptons, each of which is comprised of two leptons with the same flavour and opposite charge\"\n", "def cut_lep_charge(lep_charge):\n", "# throw away when sum of lepton charges is not equal to 0\n", "# first lepton is [0], 2nd lepton is [1] etc\n", " return lep_charge[0] + lep_charge[1] + lep_charge[2] + lep_charge[3] != 0\n", "\n", "# cut on lepton type\n", "# paper: \"selecting two pairs of isolated leptons, each of which is comprised of two leptons with the same flavour and opposite charge\"\n", "def cut_lep_type(lep_type):\n", "# for an electron lep_type is 11\n", "# for a muon lep_type is 13\n", "# throw away when none of eeee, mumumumu, eemumu\n", " sum_lep_type = lep_type[0] + lep_type[1] + lep_type[2] + lep_type[3]\n", " return (sum_lep_type != 44) and (sum_lep_type != 48) and (sum_lep_type != 52)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Applying a cut\n", "If you add a cut: Cell -> Run All Below" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "def read_file(path,sample):\n", " start = time.time() # start the clock\n", " print(\"\\tProcessing: \"+sample) # print which sample is being processed\n", " data_all = pd.DataFrame() # define empty pandas DataFrame to hold all data for this sample\n", " tree = uproot3.open(path)[\"mini\"] # open the tree called mini\n", " numevents = uproot3.numentries(path, \"mini\") # number of events\n", " if 'data' not in sample: xsec_weight = get_xsec_weight(sample) # get cross-section weight\n", " for data in tree.iterate(['lep_charge','lep_type','lep_pt',\n", " # uncomment these variables if you want to calculate masses \n", " #,'lep_eta','lep_phi','lep_E', \n", " # add more variables here if you make cuts on them \n", " 'mcWeight','scaleFactor_PILEUP',\n", " 'scaleFactor_ELE','scaleFactor_MUON',\n", " 'scaleFactor_LepTRIGGER'\n", " ], # variables to calculate Monte Carlo weight\n", " outputtype=pd.DataFrame, # choose output type as pandas DataFrame\n", " entrystop=numevents*fraction): # process up to numevents*fraction\n", "\n", " nIn = len(data.index) # number of events in this batch\n", "\n", " if 'data' not in sample: # only do this for Monte Carlo simulation files\n", " # multiply all Monte Carlo weights and scale factors together to give total weight\n", " data['totalWeight'] = np.vectorize(calc_weight)(xsec_weight,\n", " data.mcWeight,\n", " data.scaleFactor_PILEUP,\n", " data.scaleFactor_ELE,\n", " data.scaleFactor_MUON,\n", " data.scaleFactor_LepTRIGGER)\n", "\n", " # cut on lepton charge using the function cut_lep_charge defined above\n", " fail = data[ np.vectorize(cut_lep_charge)(data.lep_charge) ].index\n", " data.drop(fail, inplace=True)\n", "\n", " # cut on lepton type using the function cut_lep_type defined above\n", " fail = data[ np.vectorize(cut_lep_type)(data.lep_type) ].index\n", " data.drop(fail, inplace=True)\n", "\n", " # return the individual lepton transverse momenta in GeV\n", " data['lep_pt_1'] = np.vectorize(calc_lep_pt_i)(data.lep_pt,1)\n", " data['lep_pt_2'] = np.vectorize(calc_lep_pt_i)(data.lep_pt,2)\n", " \n", " # dataframe contents can be printed at any stage like this\n", " #print(data)\n", "\n", " # dataframe column can be printed at any stage like this\n", " #print(data['lep_pt'])\n", "\n", " # multiple dataframe columns can be printed at any stage like this\n", " #print(data[['lep_pt','lep_eta']])\n", "\n", " nOut = len(data.index) # number of events passing cuts in this batch\n", " data_all = pd.concat([data_all, data], ignore_index=True) # append dataframe from this batch to the dataframe for the whole sample\n", " elapsed = time.time() - start # time taken to process\n", " print(\"\\t\\t nIn: \"+str(nIn)+\",\\t nOut: \\t\"+str(nOut)+\"\\t in \"+str(round(elapsed,1))+\"s\") # events before and after\n", " \n", " return data_all # return dataframe containing events passing all cuts\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is where the processing happens (this will take some minutes)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "start = time.time() # time at start of whole processing\n", "data = get_data_from_files() # process all files\n", "elapsed = time.time() - start # time after whole processing\n", "print(\"Time taken: \"+str(round(elapsed,1))+\"s\") # print total time taken to process every file" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Optimisation\n", "\n", "Here we define histograms for the variables that we'll look to optimise" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "lep_pt_2 = { # dictionary containing plotting parameters for the lep_pt_2 histogram\n", " # change plotting parameters\n", " 'bin_width':1, # width of each histogram bin\n", " 'num_bins':13, # number of histogram bins\n", " 'xrange_min':7, # minimum on x-axis\n", " 'xlabel':r'$lep\\_pt$[2] [GeV]', # x-axis label\n", "}\n", "\n", "lep_pt_1 = { # dictionary containing plotting parameters for the lep_pt_1 histogram\n", " # change plotting parameters\n", " 'bin_width':1, # width of each histogram bin\n", " 'num_bins':28, # number of histogram bins\n", " 'xrange_min':7, # minimum on x-axis\n", " 'xlabel':r'$lep\\_pt$[1] [GeV]', # x-axis label\n", "}\n", "\n", "SoverB_hist_dict = {'lep_pt_2':lep_pt_2,'lep_pt_1':lep_pt_1} \n", "# add a histogram here if you want it plotted" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here we define a function to illustrate the optimum cut value on individual variables, based on signal to background ratio." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "def plot_SoverB(data):\n", " \n", " signal = r'$H \\rightarrow ZZ \\rightarrow \\ell\\ell\\ell\\ell$' # which sample is the signal\n", "\n", " # *******************\n", " # general definitions (shouldn't need to change)\n", "\n", " for x_variable,hist in SoverB_hist_dict.items(): # access the dictionary of histograms defined in the cell above\n", "\n", " h_bin_width = hist['bin_width'] # get the bin width defined in the cell above\n", " h_num_bins = hist['num_bins'] # get the number of bins defined in the cell above\n", " h_xrange_min = hist['xrange_min'] # get the x-range minimum defined in the cell above\n", " h_xlabel = hist['xlabel'] # get the x-axis label defined in the cell above\n", " \n", " bin_edges = [ h_xrange_min + x*h_bin_width for x in range(h_num_bins+1) ] # bin limits\n", " bin_centres = [ h_xrange_min+h_bin_width/2 + x*h_bin_width for x in range(h_num_bins) ] # bin centres\n", " \n", " signal_x = data[signal][x_variable] # histogram the signal\n", " \n", " mc_x = [] # define list to hold the Monte Carlo histogram entries\n", "\n", " for s in samples: # loop over samples\n", " if s not in ['data', signal]: # if not data nor signal\n", " mc_x = [*mc_x, *data[s][x_variable] ] # append to the list of Monte Carlo histogram entries\n", "\n", " \n", " \n", " # *************\n", " # Signal and background distributions\n", " # *************\n", " distributions_axes = plt.gca() # get current axes\n", " \n", " mc_heights = distributions_axes.hist(mc_x, bins=bin_edges, color='red', \n", " label='Total background',\n", " histtype='step', # lineplot that's unfilled\n", " density=True ) # normalize to form probability density\n", " signal_heights = distributions_axes.hist(signal_x, bins=bin_edges, color='blue',\n", " label=signal, \n", " histtype='step', # lineplot that's unfilled\n", " density=True, # normalize to form probability density\n", " linestyle='--' ) # dashed line\n", " \n", " distributions_axes.set_xlim( left=bin_edges[0], right=bin_edges[-1] ) # x-limits of the distributions axes\n", " distributions_axes.set_ylabel('Arbitrary units' ) # y-axis label for distributions axes\n", " distributions_axes.set_ylim( top=max(signal_heights[0])*1.3 ) # set y-axis limits\n", " plt.title('Signal and background '+x_variable+' distributions') # add title\n", " distributions_axes.legend() # draw the legend\n", " distributions_axes.set_xlabel( h_xlabel ) # x-axis label\n", " \n", " # Add text 'ATLAS Open Data' on plot\n", " plt.text(0.05, # x\n", " 0.93, # y\n", " 'ATLAS Open Data', # text\n", " transform=distributions_axes.transAxes, # coordinate system used is that of distributions_axes\n", " fontsize=13 ) \n", " # Add text 'for education' on plot\n", " plt.text(0.05, # x\n", " 0.88, # y\n", " 'for education', # text\n", " transform=distributions_axes.transAxes, # coordinate system used is that of distributions_axes\n", " style='italic',\n", " fontsize=8 ) \n", " \n", " plt.show() # show the Signal and background distributions\n", " \n", " \n", " # *************\n", " # Signal to background ratio\n", " # *************\n", " plt.figure() # start new figure\n", " SoverB = [] # list to hold S/B values\n", " for cut_value in bin_edges: # loop over bins\n", " signal_weights_passing_cut = sum(data[signal][data[signal][x_variable]>cut_value].totalWeight)\n", " background_weights_passing_cut = 0 # start counter for background weights passing cut\n", " for s in samples: # loop over samples\n", " if s not in ['data', signal]: # if not data nor signal\n", " background_weights_passing_cut += sum(data[s][data[s][x_variable]>cut_value].totalWeight)\n", " if background_weights_passing_cut!=0: # some background passes cut\n", " SoverB_value = signal_weights_passing_cut/background_weights_passing_cut\n", " SoverB_percent = 100*SoverB_value # multiply by 100 for percentage\n", " SoverB.append(SoverB_percent) # append to list of S/B values\n", " \n", " SoverB_axes = plt.gca() # get current axes\n", " SoverB_axes.plot( bin_edges[:len(SoverB)], SoverB ) # plot the data points\n", " SoverB_axes.set_xlim( left=bin_edges[0], right=bin_edges[-1] ) # set the x-limit of the main axes\n", " SoverB_axes.set_ylabel( 'S/B (%)' ) # write y-axis label for main axes\n", " plt.title('Signal to background ratio for different '+x_variable+' cut values', family='sans-serif')\n", " SoverB_axes.set_xlabel( h_xlabel ) # x-axis label \n", " \n", " plt.show() # show S/B plot\n", " \n", " return" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here we call our function to illustrate the optimum cut value on individual variables, based on signal to background ratio.\n", "\n", "We're not doing any Machine Learning yet! We're looking at the variables we'll later use for Machine Learning.\n", "\n", "Let's talk through the lep_pt_2 plots.\n", "1. Imagine placing a cut at 7 GeV in the distributions of signal and background (1st plot). This means keeping all events above 7 GeV in the signal and background histograms. \n", "2. We then take the ratio of the number of signal events that pass this cut, to the number of background events that pass this cut. This gives us a starting value for S/B (2nd plot). \n", "3. We then increase this cut value to 8 GeV, 9 GeV, 10 GeV, 11 GeV, 12 GeV. Cuts at these values are throwing away more background than signal, so S/B increases. \n", "4. There comes a point around 13 GeV where we start throwing away too much signal, thus S/B starts to decrease. \n", "5. Our goal is to find the maximum in S/B, and place the cut there.\n", "\n", "The same logic applies to lep_pt_1." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkkAAAHICAYAAABahH7UAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAACF00lEQVR4nO3deVhU1RsH8O+AMOzIJossAiqCiAoa4YamYmruqblbalqWW4uamkslZaVmiqahZe7lrqTimiZuCGiKOwgqiJACLuzn98f8mLzOgAyODuD38zzzDJxz7rnvHYbh5dxzz5UJIQSIiIiISEJP1wEQERERVURMkoiIiIjUYJJEREREpAaTJCIiIiI1mCQRERERqcEkiYiIiEgNJklEREREajBJIiIiIlKDSRIRERGRGkySSOL48ePo0aMHXF1dIZfLYW9vj6CgIHz00UeSdq1bt0br1q11E6QaFS2exMREyGQy/PLLL6W2++WXXyCTyXDq1KkXE5iO91tRzJgxAzKZ7Knthg4dilq1aj3/gLTk4cOHmDFjBg4ePKjxtikpKZg6dSqCgoJga2sLCwsLBAQEYOnSpSgsLCx3TAcPHoRMJpPEVJ7X9datW5gxYwZiY2M12k7dvmQyGT744AON+nmasLAwtb/vZf0soIqJSRIp7dy5E82aNUNWVhbmzJmDPXv24IcffkDz5s2xfv16SduwsDCEhYXpKFIiUufhw4eYOXNmuZKk6OhorFy5Em3btsXKlSuxceNGBAcH47333sOIESO0Gue0adOwefNmjba5desWZs6cqXGSVJ59lUdJSZKjoyOioqLQuXPn5x4DaV81XQdAFcecOXPg7u6O3bt3o1q1/94ab731FubMmSNp6+Pj86LDo0qmsLAQBQUFkMvlug6FyqB58+a4evUqDAwMlGXt27dHXl4eFi1ahJkzZ8LFxUUr+/L09NRKP6V5+PAhTExMXsi+SiOXy/Hqq6/qNAYqP44kkVJGRgZsbW0lCVIxPT3pW0Xd6a0bN27gzTffhLm5OapXr44BAwbg5MmTKkPNQ4cOhZmZGa5cuYJOnTrBzMwMLi4u+Oijj5Cbmyvpc+bMmQgMDIS1tTUsLCzg7++P8PBwlPe+zOvXr0dISAgcHR1hbGwMb29vTJo0CQ8ePJC00yTGW7duoU+fPjA3N4elpSX69u2L1NRUjeK6e/cu3n77bVhbW8PU1BRdunTBtWvXJG0iIyPRrVs3ODs7w8jICLVr18bIkSORnp6u0t+FCxfQr18/2NvbQy6Xw9XVFYMHD1aJ/XEpKSkICAhAnTp1cPnyZWX5smXLULduXcjlcvj4+GDNmjUqpzCKTynMmTMHX375Jdzd3SGXy3HgwAEAwLZt2xAUFAQTExOYm5ujffv2iIqKkuy/pFMw6k6NFZ8u+e233+Dt7Q0TExM0bNgQO3bsUNl+586daNSoEeRyOdzd3fHdd9+V+BqUhRACYWFhaNSoEYyNjWFlZYU333xT5efVunVr+Pr64vDhw3j11VdhbGyMmjVrYtq0aRqfvipLX4mJibCzswOg+L2RyWSQyWQYOnRomfZhZWUlSZCKvfLKKwAUv99Pc+HCBbz++uswMTGBra0tRo0ahezsbJV26n7Wv//+OwIDA2FpaQkTExN4eHjgnXfeAaA4Zde0aVMAwNtvv608thkzZij7MzMzw9mzZxESEgJzc3O0bdu2xH0V++mnnyTv7XXr1knqSzotW3y6OjExEQBQq1YtnDt3DocOHVLGVrzPkk63HTlyBG3btoW5uTlMTEzQrFkz7Ny5U+1+Dhw4gPfeew+2trawsbFBz549cevWLUnb/fv3o3Xr1rCxsYGxsTFcXV3Rq1cvPHz4UO2xU9kwSSKloKAgHD9+HGPGjMHx48eRn59f5m0fPHiANm3a4MCBA/jmm2+wYcMG2Nvbo2/fvmrb5+fno2vXrmjbti22bt2Kd955B/PmzcM333wjaZeYmIiRI0diw4YN2LRpE3r27IkPP/wQX3zxRbmO8fLly+jUqRPCw8Oxa9cujBs3Dhs2bECXLl3KFeOjR4/Qrl077NmzB6Ghofj999/h4OBQ4nGXZNiwYdDT08OaNWswf/58nDhxAq1bt8a9e/eUba5evYqgoCAsXrwYe/bsweeff47jx4+jRYsWkp9VXFwcmjZtimPHjmHWrFn4888/ERoaitzcXOTl5and/z///IPAwEDI5XJERUWhTp06AIClS5fi3XffhZ+fHzZt2oSpU6eWejpnwYIF2L9/P7777jv8+eefqFevHtasWYNu3brBwsICa9euRXh4OO7evYvWrVvjyJEjGr1Oj9u5cycWLlyIWbNmYePGjbC2tkaPHj0kycq+ffvQrVs3mJubY926dfj222+xYcMGrFixotz7HTlyJMaNG4d27dphy5YtCAsLw7lz59CsWTPcvn1b0jY1NRVvvfUWBgwYgK1bt+LNN9/El19+ibFjx2q836f15ejoiF27dgFQvJ+ioqIQFRWFadOmlftYAcUf32rVqqFu3bqltrt9+zaCg4Pxzz//ICwsDL/99hvu379fprk/UVFR6Nu3Lzw8PLBu3Trs3LkTn3/+OQoKCgAA/v7+yp/Z1KlTlcc2fPhwZR95eXno2rUrXnvtNWzduhUzZ84sdZ/btm3DggULMGvWLPzxxx9wc3NDv3798Mcffzw13idt3rwZHh4eaNy4sTK20k7xHTp0CK+99hoyMzMRHh6OtWvXwtzcHF26dFGZ2gAAw4cPh4GBAdasWYM5c+bg4MGDGDhwoLI+MTERnTt3hqGhIZYvX45du3bh66+/hqmpaYm/81RGguj/0tPTRYsWLQQAAUAYGBiIZs2aidDQUJGdnS1pGxwcLIKDg5XfL1q0SAAQf/75p6TdyJEjBQCxYsUKZdmQIUMEALFhwwZJ206dOgkvL68S4yssLBT5+fli1qxZwsbGRhQVFZUYT1kUFRWJ/Px8cejQIQFAxMXFaRzj4sWLBQCxdetWSbsRI0aoHLc6K1asEABEjx49JOV///23ACC+/PLLUmO/fv26yv5fe+01Ub16dZGWlvbU/Z48eVJERkYKCwsL8eabb4pHjx4p2xQWFgoHBwcRGBgo2fb69evCwMBAuLm5KcsSEhIEAOHp6Sny8vIkfTg5OYkGDRqIwsJCZXl2draoUaOGaNasmbJsyJAhkj6LTZ8+XTz5UQVA2Nvbi6ysLGVZamqq0NPTE6GhocqywMBA4eTkJDmurKwsYW1trdKnOk/GFBUVJQCI77//XtIuOTlZGBsbi08//VRZFhwcXOJ7Q09PT1y/fv2p+9e0rzt37ggAYvr06WXuuzS7d+8Wenp6Yvz48U9tO3HiRCGTyURsbKykvH379gKAOHDggLLsydf1u+++EwDEvXv3Suz/5MmTJf5OFf++Ll++XG3dk+8rAMLY2FikpqYqywoKCkS9evVE7dq1lWXq3ntC/Pf7k5CQoCyrX7++2s+g4t+Nx+N+9dVXRY0aNSSfqwUFBcLX11c4OzsrP9uK9/P+++9L+pwzZ44AIFJSUoQQQvzxxx8CgMprT8+OI0mkZGNjg8OHD+PkyZP4+uuv0a1bN1y6dAmTJ09GgwYN1J7WKXbo0CGYm5vj9ddfl5T369dPbXuZTKYyeuPn54fr169Lyvbv34927drB0tIS+vr6MDAwwOeff46MjAykpaVpfIzXrl1D//794eDgoOwvODgYABAfH69xjAcOHIC5uTm6du0qade/f3+N4howYIDk+2bNmsHNzU15ugoA0tLSMGrUKLi4uKBatWowMDCAm5ubJPaHDx/i0KFD6NOnj/LUS2l+/fVXdOrUCcOHD8eGDRtgZGSkrLt48SJSU1PRp08fyTaurq5o3ry52v66du0qOWVz8eJF3Lp1C4MGDZKcsjUzM0OvXr1w7Nixcp8OaNOmDczNzZXf29vbo0aNGsqfz4MHD3Dy5En07NlTclzF/7GXx44dOyCTyTBw4EAUFBQoHw4ODmjYsKHKCFtJ742ioiL89ddfGu1bm32VxenTp9GnTx+8+uqrCA0NfWr7AwcOoH79+mjYsKFKjE9TfCqtT58+2LBhA27evFmumHv16lXmtm3btoW9vb3ye319ffTt2xdXrlwp06nF8nrw4AGOHz+ON998E2ZmZpL9Dxo0CDdu3MDFixcl2zz5c/fz8wMA5Xu9UaNGMDQ0xLvvvotff/1V5dQvlR+TJFLRpEkTTJw4Eb///jtu3bqF8ePHIzExUWXy9uMyMjIkHzjF1JUBgImJieQPF6CY4JiTk6P8/sSJEwgJCQGgmBfz999/4+TJk5gyZQoAxakuTdy/fx8tW7bE8ePH8eWXX+LgwYM4efIkNm3apLa/ssRY0nE7ODhoFJu69g4ODsjIyAAAFBUVISQkBJs2bcKnn36Kffv24cSJEzh27Jgk9rt376KwsBDOzs5l2u+6detgbGyM4cOHq8y9KN63Jj9XR0dHtX08WQ4ATk5OKCoqwt27d8sU65NsbGxUyuRyueS1KCoqKvG1LY/bt29DCAF7e3sYGBhIHseOHVP5R6K090bxa1NW2uzraWJiYtC+fXvUqVMHERERZZp8n5GRUe7XulWrVtiyZQsKCgowePBgODs7w9fXF2vXri1zzCYmJrCwsChz+9Ji1fbr+bi7d+9CCFHi74S6/T/5Xi/+eRS/1z09PbF3717UqFEDo0ePhqenJzw9PfHDDz88j0N4qfDqNiqVgYEBpk+fjnnz5uGff/4psZ2NjQ1OnDihUq7pBObHrVu3DgYGBtixY4ckWdmyZUu5+tu/fz9u3bqFgwcPKkePAEjm/WhKW8etrn1qaipq164NQDFnKC4uDr/88guGDBmibHPlyhXJNtbW1tDX1y/zf8KrV6/GtGnTEBwcjD179qBRo0bKuuIP5ifn2ZQULwCVRKu4j5SUFJW2t27dgp6eHqysrAAARkZGaieWlzaCWRorKyvIZLISX9vysLW1hUwmw+HDh9UmDk+WlfbaqUvySqPNvkoTExODdu3awc3NDXv27IGlpWWZtrOxsXmm17pbt27o1q0bcnNzcezYMYSGhqJ///6oVasWgoKCnrp9Wda9elpcT76exZ87ubm5kp9ted+TgOJ9qaenV+LvBKB4n2mqZcuWaNmyJQoLC3Hq1Cn8+OOPGDduHOzt7fHWW2+VO96XHUeSSEndLy3w36mc4v9y1AkODkZ2djb+/PNPSfmTV4toQiaToVq1atDX11eWPXr0CL/99lu5+wNU/5D99NNP5Y6xTZs2yM7OxrZt2yTla9as0aif1atXS74/evQorl+/rryCsKyxGxsbIzg4GL///nuZPsitra2xd+9eeHt7o02bNsqRKQDw8vKCg4MDNmzYINkmKSkJR48eLdNxeXl5oWbNmlizZo3kisQHDx5g48aNyiveAMUVQmlpaZJkIC8vD7t37y7Tvp5kamqKV155BZs2bZKM/mVnZ2P79u3l6vONN96AEAI3b95EkyZNVB4NGjSQtC/pvaGnp4dWrVpptO+y9PXkCIOmYmNj0a5dOzg7OyMyMlKZwJZFmzZtcO7cOcTFxanEqAm5XI7g4GDlBRIxMTHKcqD8x/akffv2Sd5rhYWFWL9+PTw9PZUjscVXqJ05c0ayrbr3z+OjmKUxNTVFYGAgNm3aJGlfVFSEVatWwdnZ+amT5Eujr6+PwMBALFq0CIDitCmVH0eSSKlDhw5wdnZGly5dUK9ePRQVFSE2Nhbff/89zMzMSr0iZ8iQIZg3bx4GDhyIL7/8ErVr18aff/6p/AP35BICZdG5c2fMnTsX/fv3x7vvvouMjAx899135V53p1mzZrCyssKoUaMwffp0GBgYYPXq1Sof6poYPHgw5s2bh8GDB+Orr75Snp7Q9A/7qVOnMHz4cPTu3RvJycmYMmUKatasiffffx8AUK9ePXh6emLSpEkQQsDa2hrbt29HZGSkSl9z585FixYtEBgYiEmTJqF27dq4ffs2tm3bhp9++kkyjwdQzHXZtWsXevbsifbt22Pbtm1o06YN9PT0MHPmTIwcORJvvvkm3nnnHdy7dw8zZ86Eo6NjmX6menp6mDNnDgYMGIA33ngDI0eORG5uLr799lvcu3cPX3/9tbJt37598fnnn+Ott97CJ598gpycHCxYsOCZVnv+4osv8Prrr6N9+/b46KOPUFhYiG+++Qampqb4999/Ne6vefPmePfdd/H222/j1KlTaNWqFUxNTZGSkoIjR46gQYMGeO+995TtbWxs8N577yEpKQl169ZFREQEli1bhvfeew+urq4a7bssfZmbm8PNzQ1bt25F27ZtYW1tDVtb2zKtbn3x4kW0a9cOAPDVV1/h8uXLkqUgPD09S53nNm7cOCxfvhydO3fGl19+CXt7e6xevRoXLlx46r4///xz3LhxA23btoWzszPu3buHH374QTJn0NPTE8bGxli9ejW8vb1hZmYGJyenUv95K42trS1ee+01TJs2DaampggLC8OFCxck/9h16tQJ1tbWGDZsGGbNmoVq1arhl19+QXJyskp/DRo0wLp167B+/Xp4eHjAyMhIJWkuFhoaivbt26NNmzb4+OOPYWhoiLCwMPzzzz9Yu3atxqNiS5Yswf79+9G5c2e4uroiJycHy5cvBwDlz5TKSafTxqlCWb9+vejfv7+oU6eOMDMzEwYGBsLV1VUMGjRInD9/XtJW3dVkSUlJomfPnsLMzEyYm5uLXr16iYiICJWrcoYMGSJMTU1V9q/uSpLly5cLLy8vIZfLhYeHhwgNDRXh4eEqV5aU9eq2o0ePiqCgIGFiYiLs7OzE8OHDxenTp9VegVfWGG/cuCF69eolOe6jR49qdHXbnj17xKBBg0T16tWFsbGx6NSpk7h8+bKk7fnz50X79u2Fubm5sLKyEr179xZJSUlqr2Y6f/686N27t7CxsRGGhobC1dVVDB06VOTk5Ej2e/LkSeU2ubm5olevXsLIyEjs3LlTWb506VJRu3ZtYWhoKOrWrSuWL18uunXrJho3bqxsU3wFz7fffqv2OLds2SICAwOFkZGRMDU1FW3bthV///23SruIiAjRqFEjYWxsLDw8PMTChQtLvLpt9OjRKtu7ubmJIUOGSMq2bdsm/Pz8lK/D119/XeJVS08q6Yq75cuXi8DAQGFqaiqMjY2Fp6enGDx4sDh16pSyTXBwsKhfv744ePCgaNKkiZDL5cLR0VF89tlnIj8//6n7fpwmfe3du1c0btxYyOVyAUDl9ShJ8XuipMfT3stC/PceNTIyEtbW1mLYsGFi69atT726bceOHaJjx46iZs2awtDQUNSoUUN06tRJHD58WNL/2rVrRb169YSBgYHkfV/S76u6fQnx3/snLCxMeHp6CgMDA1GvXj2xevVqle1PnDghmjVrJkxNTUXNmjXF9OnTxc8//6zyGZSYmChCQkKEubm5AKDcp7qr24QQ4vDhw+K1115TvodeffVVsX37dkkbdb+nQghx4MAByWsaFRUlevToIdzc3IRcLhc2NjYiODhYbNu2Te1rQmUnE6Kcq/IRlcHs2bMxdepUJCUllXkyMVVs9+7dQ926ddG9e3csXbpU1+FUWK1bt0Z6enqpc/l00RcRlR1Pt5HWLFy4EIDi1FB+fj7279+PBQsWYODAgUyQKqnU1FR89dVXaNOmDWxsbHD9+nXMmzcP2dnZ5VoQkYioMmGSRFpjYmKCefPmITExEbm5uXB1dcXEiRMxdepUXYdG5SSXy5GYmIj3338f//77L0xMTPDqq69iyZIlqF+/vq7Dq/QKCwtLvcWOTCaTXLhQXsUrV5dET0+vXPMGiao6nm4jItKR1q1b49ChQyXWu7m5Ke8PVl6JiYlwd3cvtc306dOV90Ejov8wSSIi0pGLFy+qvQFsMblcXuIVUmWVl5encgn7k57lKjGiqoxJEhEREZEaOj8JHRYWBnd3dxgZGSEgIACHDx8usW1KSgr69+8PLy8v6OnpYdy4cWrb3bt3D6NHj4ajoyOMjIzg7e2NiIiI53QEREREVBXpdOL2+vXrMW7cOISFhaF58+b46aef0LFjR5w/f17tQmu5ubmws7PDlClTMG/ePLV95uXloX379qhRowb++OMPODs7Izk5WWUBvdIUFRXh1q1bMDc313hRLyIiItINIQSys7Ph5OSknYsRdLVAkxBCvPLKK2LUqFGSsnr16olJkyY9ddvg4GAxduxYlfLFixcLDw8PkZeXV+64kpOTS11UjQ8++OCDDz74qLiP5OTkcucAj9PZSFJeXh6io6MxadIkSXlISEiZ7wulzrZt2xAUFITRo0dj69atsLOzQ//+/TFx4sQSL6XNzc2V3FhT/H+aVnJyskZ3lSYiIiLdycrKgouLi0Znj0qjsyQpPT0dhYWFsLe3l5Tb29s/053jr127hv3792PAgAGIiIjA5cuXMXr0aBQUFODzzz9Xu01oaChmzpypUm5hYcEkiYiIqJLR1lQZnU/cfvJAhBDPdHBFRUWoUaMGli5dioCAALz11luYMmUKFi9eXOI2kydPRmZmpvKh7uaFRERE9HLR2UiSra0t9PX1VUaN0tLSVEaXNOHo6AgDAwPJqTVvb2+kpqYiLy8PhoaGKtvI5fJy31meiIiIqiadjSQZGhoiICAAkZGRkvLIyEg0a9as3P02b94cV65cQVFRkbLs0qVLcHR0VJsgEREREamj0yUAJkyYgEGDBqFJkyYICgrC0qVLkZSUhFGjRgFQnAa7efMmVq5cqdwmNjYWAHD//n3cuXMHsbGxMDQ0hI+PDwDgvffew48//oixY8fiww8/xOXLlzF79myMGTPmhR8fEVFlVVRUhLy8PF2HQaTC0NDwhd1rUKdJUt++fZGRkYFZs2YhJSUFvr6+iIiIgJubGwDF4pFJSUmSbRo3bqz8Ojo6GmvWrJHc38jFxQV79uzB+PHj4efnh5o1a2Ls2LGYOHHiCzsuIqLKLC8vDwkJCZIReaKKQk9PD+7u7i/k7BBvS6JGVlYWLC0tkZmZyavbiOilIoRAUlIS8vPztbcgH5GWFC/2bGBgAFdXV5ULvbT991unI0lERFSxFBQU4OHDh3BycoKJiYmuwyFSYWdnh1u3bqGgoAAGBgbPdV/8F4GIiJQKCwsBgBe6UIVV/N4sfq8+T0ySiIhIBe9bSRXVi3xvMkkiIiIiUoNJUgWSmZkJExMTyGQy/PLLL5I6mUxW5kdiYiISExMhk8mUyymU1WeffQaZTAZ3d3eUNqc/MTERo0aNQr169WBiYgIrKyv4+PhgyJAhOHDgQJn3l5ubiwULFqBZs2aoXr06jIyMULt2bbz33nu4du2aRrFXBAcPHpT8LPT19VG9enV4e3ujf//+2LRp0zMPEd+7dw8zZszAwYMHtRM0UVkkJQGnT7+4xxNXNldEtWrVwvz580usHzp0KLp37/5cY5gxYwYaNWr0XPehCzKZDFu2bNF1GJy4XZGsWbMGOTk58PT0RHh4OIYOHaqs++233yRt4+PjMXv2bPTo0QM9e/aU1NnZ2eHOnTsa77+wsBC//vor6tSpg8uXL2P//v1o27atSrvTp08jODgYBgYGGDx4MLy9vfHo0SNcunQJ27dvh7m5Odq0afPU/d2+fRsdO3ZETEwM2rdvjxkzZsDMzAxxcXH45Zdf8Ouvv2Lt2rXo1q2bxseia3379sUbb7wBIQTu37+Py5cvY8eOHVi7di2aNm2KTZs2wdnZuVx937t3T3mvwdatW2sxaqISJCUB3t7Aw4cvbp8mJkB8PODq+tSmTzv9MmTIEJV/PJ/cfvPmzc89oaHKh0lSBRIeHo5WrVqhb9++eP/993Hx4kV4eXkBAAYOHChpe/DgQcyePRt+fn4qdQDKlST9+eefuHXrFvbu3YvBgwcjPDxcbZI0Y8YM3L9/H3FxcfDz85PULVy4sEw3KBZCoHfv3oiJicFPP/2Ed999V1I/fvx4BAcHo1+/fjh58iTq16+v8fHoUqNGjVR+Lt9//z3mzJmDSZMmoXPnzoiOjka1avwVpEogPV2RIK1apUiWnrf4eGDgQMV+y5AkpaSkKL9ev349Pv/8c1y8eFFZZmxs/FzCrKry8/Of+1VjlQVPt1UQZ86cQXR0NIYOHYp+/fpBLpdj+fLlLzSG8PBw1KpVC6+99hoGDhyIzZs34+7duyrtLl26BBsbG5UECVAs8uXk5PTUfe3YsQOHDx9Gnz59VBIkAPDw8MBPP/2ER48eYfr06cry4tOIM2bMwNq1a+Hn5wcjIyO4uLjg888/R35+vkpfKSkpeO+99+Dq6gpDQ0M4OTnh3XffRVpamqTdjBkzIJPJcOHCBXz66aeoWbMm5HI5GjZsiIiIiKce09PIZDJMnDgRb731Fs6cOYP169cr67KzszF16lQEBgbC1tYWcrkctWvXxqRJk/Dwsf/ef/nlF7i7uwMAZs6cqTytVzyiVFRUhK+++gqtWrWCg4MDDA0N4erqivfeew8ZGRnPfAz0kvP2Bvz9n/9Dw0TMwcFB+bC0tIRMJpOUrVmzBp6enjA0NISXl5dkZL5WrVoAgB49ekAmkym/v3r1Krp16wZ7e3uYmZmhadOm2Lt3b7letpkzZ6JGjRqwsLDAyJEjJSuZ79q1Cy1atED16tVhY2ODN954A1evXpVsf+PGDbz11luwtraGqakpmjRpguPHj6vdV0JCgnLKQvFioMuWLYOLiwtMTEzQo0cPzJ07F9WrV1duU3zKbvny5fDw8IBcLleul9WtWzeYmZnBwsICffr0we3bt5XbqTudOG7cOMkId+vWrTFmzBh8+umnsLa2hoODA2bMmCHZ5vLly2jVqhWMjIzg4+OjcrsyXWKSVEH8/PPPMDU1xZtvvonq1auja9euWLlyJQoKCl7I/m/fvo0dO3Zg8ODBkMlkGDJkCHJycrB69WqVth4eHsjIyMCmTZvKvb8//vgDADBixIgS23Ts2BHOzs7YuXMncnNzJXXbt2/He++9hy5duuDbb79FvXr18MUXX2DYsGGSdklJSWjSpAn++OMP9O/fH4sWLcLgwYOxbt06NG/eHJmZmSr7HTJkCI4dO4ZPPvkEX3zxBe7cuYPu3bsrV3V/VsVJ4Y4dO5RlN2/eRHh4OAIDA/H5559j7ty58Pf3x5w5c9CjRw9lu1atWmHevHkAFB/qv/32G3777TdMmTIFgGKl5O+++w716tXDxIkT8eOPP6J9+/YIDw9H69ateZsJeuls3rwZY8eOxUcffYR//vkHI0eOxNtvv62cO3ny5EkAwIoVK5CSkqL8/v79++jUqRP27t2LmJgYdOjQAV26dFG5C8TT7Nu3D/Hx8Thw4ADWrl2LzZs3K0+XA8CDBw8wYcIEnDx5Evv27YOenh569OihTHDu37+P4OBg3Lp1C9u2bUNcXBw+/fRTtauh//PPP2jevDl69+6NxYsXQ09PD3///TdGjRqFsWPHIjY2Fu3bt8dXX32lsu2VK1ewYcMGbNy4UXn7r+7du+Pff//FoUOHEBkZiatXr6Jv374aHT8A/PrrrzA1NcXx48cxZ84czJo1S5kIFRUVoWfPntDX18exY8ewZMmSinWHDEEqMjMzBQCRmZn5QvaXk5MjrK2txeDBg5VlO3fuFADE1q1b1W5z4MABAUBMnz5dbX1CQoIAIEaOHFmmGObMmSNkMpm4evWqsqxp06aicePGKm2PHj0qDAwMBABRp04d8fbbb4uwsDBx/vz5Mu1LCCH8/f0FAJGRkVFquzfeeEMAEGfPnpUcl56enoiOjla2KyoqEt27dxcAxJEjR5TlXbp0Eba2tiI5OVnS78mTJ4W+vr7k9Zs+fboAIDp37iyKioqU5SdOnBAAxKRJk556XMU/l9DQ0BLbZGRkCADC399fWZabmyvy8/NV2k6dOlUAEMePH1eWFb8G6n72RUVF4uHDhyrlP//8swAg1q9f/9RjoJfbo0ePxPnz58WjR4/+K4yOFgJQPL8Iz7C/FStWCEtLS+X3zZo1EyNGjJC06d27t+jUqZPyewBi8+bNT+3bx8dH/Pjjj8rv3dzcxLx580psP2TIEGFtbS0ePHigLFu8eLEwMzMThYWFardJS0uTfOb99NNPwtzcvMTPyunTp4uGDRuKo0ePCmtra/Htt99K6vv27Ss6d+4sKRswYIDkNZo+fbowMDAQaWlpyrI9e/YIfX19kZSUpCw7d+6cACBOnDihPL5u3bpJ+h47dqwIDg5Wfh8cHCxatGghadO0aVMxceJEIYQQu3fvFvr6+pLP6D///LPUn4na9+j/afvvN0eSKoDNmzfj33//lUzU7tChAxwdHREeHv5CYli+fDlatmwJDw8PZdnQoUMRExODmJgYSdugoCBER0dj0KBBuHv3LlasWIH3338fPj4+aNWqVZmuSsvKygIAWFpaltquuP7JEZ/27dvD399f+b1MJsOnn34KQPF6AooJzjt37sQbb7wBIyMjpKenKx+1atVC7dq1sWfPHpV9jh07VjIRtGnTpjA3N8fly5efelxlUbxUfvFrACgWRyuen1RQUIC7d+8iPT0d7dq1A4ASh9afJJPJlPMvCgsLce/ePaSnp+O1117TqB+iqiI+Ph7NmzeXlDVv3hzx8fGlbvfgwQN8+umn8PHxQfXq1WFmZoYLFy5oPJLUsGFDycrlQUFBuH//PpKTkwEoTuv1798fHh4esLCwUJ5OL95PbGwsGjduDGtr6xL3kZSUhHbt2mHq1Kn4+OOPJXUXL17EK6+8Iil78nsAcHNzg52dnfL7+Ph4uLi4wMXFRVlW/Fo87bV70pNTMxwdHZXTHeLj4+Hq6iq5kCUoKEij/p8nJkkVQHh4OOzs7ODs7IwrV67gypUrSEhIQPv27REREVGmidDP4u+//8aFCxfQtm1b5f6vXLmCpk2bQk9PT22i1qBBA6xcuRJ37txBYmIiVq1ahZYtW+Lw4cPo1q3bU0/rFCcK6k53Pa64/slkylvNnAUfHx8AUJ7Pv3TpEoqKivDLL7/Azs5O5XHx4kXJ+fVijyeKxaytrbU2p6c4OXryvkJhYWHw8/ODXC6HtbU17OzslOf21c0NK8mGDRsQGBgIY2NjWFlZwc7OTnlMmvRDVFU8efWbEOKpV8R98skn2LhxI7766iscPnwYsbGxaNCggdZOWRfvv0uXLsjIyMCyZctw/Phx5T8yxfspy6RzOzs7vPLKK1i3bp3kny9A/bEKNcu7mJqaPnW7J8v19PRU+lI3L/TJSeAymUx5ulBdLBVpIVNeWqNjiYmJ2LdvH4QQqFu3rto2v/7663M9R1ucBE2fPl0ySbrY6tWr8d1338HIyEjt9m5ubnBzc0P//v3RsmVL/P333zhx4gRatGhR4j59fX1x+vRpnD59Wjla8iQhBGJiYiCXy1GnTh1JXWm/RMV1xb98/fr1wzvvvKO2rboPIH19/RLj0Ybi8/316tVTln3//ff4+OOPERISgjFjxsDJyQmGhoa4efMmhg4dWua7sW/cuBF9+/bFK6+8gh9++AEuLi4wMjJCYWEhXn/9dd7VnV463t7eOHLkCAYPHqwsO3r0qOQfLQMDA5X1yw4fPoyhQ4cq5wTev3+/XPMS4+Li8OjRI+VnzbFjx2BmZgZnZ2dkZGQgPj4eP/30E1q2bAkAOHLkiGR7Pz8//Pzzz/j3339LHE0yNjbGjh070KlTJ3To0AF79uyBubk5AMXnzIkTJyTtT5069dS4fXx8kJSUhOTkZOVo0vnz55GZmal87ezs7PDPP/9ItouNjdXoyrji/dy6dUt50U9UVFSZt3/emCTp2IoVKyCEwE8//aT2F2DWrFlYvnz5c0uSsrOzsWHDBrRt21btwpMXLlzAtGnTsHnzZvTr16/UvmQyGQIDA/H333/j5s2bpbbt2bMnVq5ciaVLl5aYJEVERODmzZvo2bMn5HK5pO78+fMq7YvLikdNateuDZlMhtzc3BL3oQtLly4FALzxxhvKslWrVqFWrVr4888/JXdd37Vrl8r2pSWIq1atgpGREQ4cOCAZ4r9w4YI2QqeXnYanWSrCfj755BP06dMH/v7+aNu2LbZv345NmzZJrlSrVasW9u3bh+bNm0Mul8PKygq1a9fGpk2b0KVLF8hkMkybNq1c/2Tk5eVh2LBhmDp1Kq5fv47p06fjgw8+gJ6eHqysrGBjY4OlS5fC0dERSUlJmDRpkmT7fv36Yfbs2ejevTtCQ0Ph6OiImJgYODk5SU5LmZqaYufOnejYsSM6duyIXbt2wczMDB9++CFatWqFuXPnokuXLti/fz/+/PPPp47WtGvXDn5+fhgwYADmz5+PgoICvP/++wgODkaTJk0AAK+99hq+/fZbrFy5EkFBQVi1ahX++ecfNG7cuMyvT7t27eDl5YXBgwfj+++/R1ZWlvJClApBKzObqpgXNXG7sLBQuLq6Ch8fnxLbfP311wKAOHz4sKRcWxO3ly1bJgCIDRs2qK3Pzc0VlpaWom3btsqyPXv2qJ1k/PDhQ+Hr6ysAiDNnzpS636KiItG8eXMBQCxdulSl/urVq8LFxUUYGRkpJzA+flxlnbjduXNnoa+vLyl7fJvHJyoWT9xOSEhQaevm5iaZjFiS0iZuFxUViW+++UYAEI0aNRIFBQXKuoCAAOHu7i4py8/PF8HBwSo/5/T0dAFAjBkzRmUfvXr1EsbGxiI7O1uy3wEDBggAYsiQIU89Bnq5qZ0Ue/26ECYmisnUL+phYqLYr4aenLgthBBhYWHCw8NDGBgYiLp164qVK1dK6rdt2yZq164tqlWrJtzc3IQQis+aNm3aCGNjY+Hi4iIWLlwogoODxdixY5XblWXidrdu3cTnn38ubGxshJmZmRg+fLjIyclRtomMjBTe3t5CLpcLPz8/cfDgQZVJy4mJiaJXr17CwsJCmJiYiCZNmigv5iieuF0sOztbNGvWTLRs2VLcv39fCCHE0qVLRc2aNYWxsbHo3r27+PLLL4WDg4Nymyf7KHb9+nXRtWtXYWpqKszNzUXv3r1FamqqpM3nn38u7O3thaWlpRg/frz44IMPVCZuP/6aCSFEt27dJJ9FFy9eFC1atBCGhoaibt26YteuXRVm4rZMCC2dQ6hCsrKyYGlpiczMTJV5I9q0e/duvP766/j8888ll4Q+7sqVK6hTpw6GDh2KFStWKMsPHjyINm3aYPr06SprTgCK03ju7u5o2rQpunbtqrbvqVOnIigoCHFxcbhz547KOeliAwcOxJo1a3D16lW4u7vD19cX6enp6Nq1K/z8/GBiYoLk5GSsWbMGly5dwuDBg/Hrr78+9fhTUlLQsWNHxMXFISQkBJ07d4apqSni4uKwYsUKFBYWYs2aNZJ1OIqPq3Hjxrh27RpGjx4NR0dHbN26FXv37sWgQYOwcuVKZfvk5GS0aNECKSkpGDRoEPz9/VFUVIRr165h69atGDx4sPL1mzFjBmbOnImEhATlWinFatWqhVq1aj31ViDFP5fiFbcBxTD9lStXsH37dly6dAmvvPIKNm3ahJo1ayq3+/rrrzF58mS0b98ePXv2RFZWFtasWQMDAwOcOnVK5edcu3Zt5dpKdnZ2qFGjBl577TWsW7cO/fr1Q9OmTTF48GDk5+djy5YtePjwIU6dOvXUlYeJcnJykJCQAHd3d+kp9qQkxeKOL4qtbZkWkiTNjRgxAhcuXMDhw4d1HUq5lPgexXP4+62VVKuKeVEjSb179y7TqIufn58wNTUVWVlZyrKyjiSV9ii+nLNnz56l7n/Tpk0CgJg2bZoQQnHJ5vvvvy/8/PyEjY2N0NfXF9bW1qJ169YiPDy8xEtb1Xn06JGYN2+eCAwMFBYWFkIulwt3d3cxcuRIceXKlRKPa/r06WLNmjWiQYMGwtDQUDg7O4tp06aJvLw8lW3u3LkjPv74Y1GnTh0hl8uFpaWl8PX1FWPGjBHnzp1TttPmSFLxQ09PT1hYWAgvLy/Rr18/sXHjRsloUbGCggIxe/Zs4enpKQwNDYWrq6v45JNPxPnz59X+nI8ePSoCAwOFkZGRACCJbenSpcr/TB0cHMSIESOUyw5wJImeprT/0qly+vbbb0VsbKy4fPmyWLBggTAwMBDLli3TdVjlxpEkHXtRI0mkueKRpJJG0Ijo2ZT2XzpVTn369MHBgweRnZ0NDw8PfPjhhxrf/LwieZEjSZy4TUREVIVt2LBB1yFUWlwniYiIiEgNJklEREREavB0G1UqtWrV0tqijkRERKXhSBIRERGRGkySiIiIiNRgkkRERESkBuckERFRmdy8Cdy+LS2zsQHc3IBHj1RvuSaTAcW38YqPV7R5nLs7YGWl6PPJ2z1ywW2qCDiSREREZbJwIRAQIH188YWi7to11bpXX/1v2wEDVOuL7zG7erVq3QcfAJmZmsfYqlUrDBs2TKU8LCwMJiYmKCwsLMeRq4qIiIBMJivx0adPH43aacORI0fg5eWFTp06lbu8pLYvK44kERFRqbKzgehoYOhQoHdvaZ2NjeLZw0PR5nGP32h+9Wr1I0mAIoFq3Vpa5+ICWFpqFqcQArGxsXjrrbdU6qKjo9GwYUPo6+tr1mkJ2rRpg5SUFElZYWEh3n77bcTExGDatGkatdOGMWPGYMyYMVi0aFG5y0tq+7JiklQBrF69Gl9//TUMDAywfPlyNGrU6LnvMzw8HIcPH34uNzvdt28f5HI5WrRoAQD4559/8M033+C3337T+r6I6Pm7fBlo00aRBPn7q29jbFxyHQB4e5dcZ2+veBTLzwfu3VM8GxhoEudlZGdnIyAgQKUuOjpa+ZlUVpcuXULdunXV1hkbG8PY2Fj5fWFhIQYOHIiYmBjs378fDRo00Kjds8Zz8eJF3L59Gw4ODpI+NSkvqe3LjKfbdKyoqAgfffQR/vzzT5w+fbrMCdKzDhmfOHECTZs2faY+SvLjjz8iIyND+b2vry8TJCIqs7NngRo1FM+aiI6Ohr6+Pvz8/CTlubm5OHfunNrkqSR///03/P39sW/fvqe2LU58IiMjsW/fvhITjLK2K088u3btQvv27bFr1y7JqTJNyktq+zJjkqRD//77L+rVq4fs7Gy88cYbWLx4MRITE/HGG2/Ay8sLPj4+WLdunbK9k5MTvvzySwQFBeG9995T6e/ChQvo1q0bAgMD4e3tjV9//VVZ99dff+GVV16Bn58fJk+ejJMnT6Jp06Z49OgRLCwsJEmXjY0N/v33XwDAmTNn0LFjR/j7+6Nu3brKkafw8HAEBgaicePG8PHxwe7duwEohmq3b9+OadOmoVGjRkhJSUH//v2xZs0aAEB6ejoGDBiAunXrol69epg/f75yv6+88gq+/PJLtGnTBjVq1MD48eO19loTUdV3+vRpFBYWwsTERDLvx8jICAUFBRolSc2bN8f333+Pbt26lZooFRYWYtCgQcrE58kETdN25Y3n8OHD8Pf3x5EjR9D7sXOimpSX1PalJkhFZmamACAyMzOf+77Wrl0r+vbtK4QQ4tGjR6Ju3bpi8+bNQgghkpOThYWFhcjKyhIpKSkCgFi0aJHaftLS0sSrr74qrly5IoQQIiMjQ9jY2IicnBxx7tw54enpKS5fviyEEOKbb74RhoaGIicnRxw9elQEBgYq+7l27ZqoVauWEEKIixcvCicnJxEVFSWEEKKgoEDcvn1bub9ihw4dEs2aNRNCCHHnzh1ha2sric3Ly0tcuHBBCCFEs2bNxMKFC4UQQmRlZQlHR0dx8eJFkZ+fL4yMjERoaKgQQoi7d+8KAwMDkZ+fX56XlYjK6dGjR+L8+fPi0aNHyrLoaCEAxfOLUN79tWnTRvTo0UPExMRIHp999pkwMjJS+Tw5e/asAPDUh4mJidr9FRQUiH79+gkbGxsRGxtbYlxlbfcs8Xh5eYkRI0aIGTNmlLu8pLYVjbr3aDFt//3mnCQdO3XqlPK/m9WrV8Pf3x/du3cHADg7O8PExAT37t3DmTNn0LRpU7z//vtq+/nxxx+RnJyMXr16KcuMjIxQWFiIb775BmPHjkXt2rUBAH5+fmjQoAHkcjmio6Ph/9hEgsfj+eqrrzB27Fi8+v9LVPT19VGjRg3k5eUhLCwMO3fuRG5uLu7fv49atWqpbA8A2dnZSE1NRZ06dbBv3z4UFRVh9OjRAABzc3O4ubnh9u3byMnJgY2NDSZOnAhAMQHTwsIC1arxLUqkawYGQM2ams0P0oWYmBjMnDlTZdrCTz/9BD8/P5XPk7p16yL+yXULHrNnzx5MmDABP/zwg0pd8cjQ7t27sW/fPjRs2FBtH2Vt96zx3LhxAydPnsT3339f7vKS2r7M+BdIx6Kjo5VXN5w9e1aSsNy6dQuFhYVwdnbGihUr0L59+xL7iYmJwdKlS9WeRz59+rQkuYqKilLOR4qOjkbz5s2VdcXnvYu3GzVqlEp/n332GR48eID9+/fDzMwMEydOVJ6uO3nyJJo0aSKJy8/PD3p6eirH9+jRI1y7dg3169fHtm3b0LJlS8j+fznMk8kbEelOgwbAjRu6jqJ0165dw71799R+bpw+fVrtqTZDQ0PUq1dPbX8nT57E5MmT8dNPP6ksKVBYWIjBgwdj9+7d2Lt3b4lzScva7lnjART/WE6cOBHm5ublLi+p7cuMSZIOCSEQExOj/KV2cXFBXFwcAEUCMWrUKHz66aeQyWQ4ffo0hgwZUmJfzs7O2Lp1Kzp27AiZTIbU1FQUFRXByckJtra2OH36NAIDAxEXF4cFCxYo/1O4c+cOrK2tAQBXrlzBypUrsXbtWgCKOVAxMTEICgoCAKSmpsLBwUGZPJmZmeHEiRMICwvDsmXLAABXr15Fs2bNlHE9/uHk4uKCLVu2oKioCEIIjB8/Hr1794a1tTVOnz4tmUgeHR2t0fwBInq+UlIUj8dZWSku48/JAc6fV92mOF+5eBF48EBaV6sWYG0N3LkDJCdL60xNFWskmZqWPb7o6Gjo6empJCIFBQU4c+YM3n333bJ3BqBhw4bYvHkzQkJCJOVFRUUYPHgwtmzZgj/++AOOjo5ITU2VtLGzs4NMJitTu7IuSVBSPACwbds2PHz4ELVq1UJcXBwyMjLw2muvaVR+//59tW1felo5afcMFi1aJGrVqiXkcrnw9/cXf/31V4ltb926Jfr16yfq1q0rZDKZGDt2bKl9r127VgAQ3bp10yimFzUn6eLFi8LDw0P5/f3790XPnj1F/fr1Rb169cTXX3+trHN2dhZJSUkl9nXr1i3RsWNHUbduXeHn5yfatGkjrl+/LoQQ4vDhw8LDw0P4+/uLHj16CBcXFxEXFyeEEGLr1q2idu3aYsCAAWLGjBnCxsZGOd/o7NmzIjAwUPj6+go/Pz+xdOlSIYQQERERwsnJSbRo0UJMnTpVuLm5iUuXLin7c3d3F35+fuL69eti4MCBYuXKlUIIIQoLC8W7774rvL29hZeXl/jkk09EXl6eEEKIFi1aiEOHDimPp3fv3mLDhg3P/BoTkWbUzfe4c0eImjUV84QefwwYoKi/fFm17vG/Lq++qlr322+KuoULVetCQjSPe9KkScLLy0ulPDY2VgAQp0+f1rxTNY4dO/bUOUN3794tc7tnlZOTI3r06CHCw8OFt7e36NChg0hJSdGoPDExUW3biupFzkmSCSHEi03L/rN+/XoMGjQIYWFhaN68OX766Sf8/PPPOH/+PFzVrEefmJiIefPmISAgAPPmzUNwcLDk6qjHXb9+Hc2bN4eHhwesra2xZcuWMseVlZUFS0tLZGZmwsLCopxHR0RU+eTk5CAhIQHu7u4wMjJSlr/IkSRzc6BOnWc/FqqaSnqPAtr/+63TJCkwMBD+/v5YvHixsszb2xvdu3dHaGhoqdu2bt0ajRo1UpskFRYWIjg4GG+//TYOHz6Me/fuMUkiIiqD0v4AEVUELzJJ0tk6SXl5eYiOjlY5vxoSEoKjR48+U9+zZs2CnZ2d2slt6uTm5iIrK0vyICIiopebzpKk9PR0FBYWwv7xtegB2Nvbq0xu08Tff/+N8PBw5UTisggNDYWlpaXy4eLiUu79ExERUdWg8xW3ZY/fARGKK76eLCur7OxsDBw4EMuWLYOtrW2Zt5s8eTIyMzOVj+QnT5ATERHRS0dnSwDY2tpCX19fZdQoLS1NZXSprK5evYrExER06dJFWVZUVAQAqFatGi5evAhPT0+V7eRyOeRyebn2SURUFelwuipRqV7ke1NnI0mGhoYICAhAZGSkpDwyMlKyzo4m6tWrh7NnzyI2Nlb56Nq1K9q0aYPY2FieRiMieoridXvy8vJ0HAmResXvzbKuMfUsdLqY5IQJEzBo0CA0adIEQUFBWLp0KZKSkpSrPE+ePBk3b97EypUrldvExsYCAO7fv487d+4gNjYWhoaG8PHxgZGREXx9fSX7qF69OgColBMRkapq1arBxMQEd+7cgYGBAfT0dD4rg0ipqKgId+7cgYmJyQu5bZVOk6S+ffsiIyMDs2bNQkpKCnx9fREREQE3NzcAQEpKCpKSkiTbNG7cWPl1dHQ01qxZAzc3NyQmJr7I0ImIqiSZTAZHR0ckJCTg+vXrug6HSIWenh5cXV3LPX9ZEzpdJ6mi4jpJRPSyKyoq4ik3qpAMDQ1LHOHU9t9v3ruNiIhU6OnpcTFJeunxZDMRERGRGkySiIiIiNRgkkRERESkBpMkIiIiIjWYJBERERGpwSSJiIiISA0mSURERERqMEkiIiIiUoNJEhEREZEaTJKIiIiI1GCSRERERKQGkyQiIiIiNZgkEREREanBJImIiIhIDSZJRERERGowSSIiIiJSg0kSERERkRpMkoiIiIjUYJJEREREpAaTJCIiIiI1mCQRERERqcEkiYiIiEgNJklEREREajBJIiIiIlKDSRIRERGRGkySiIiIiNRgkkRERESkBpMkIiIiIjWq6ToAIiKiiuLMGaCgQFpWty5gZgbcuAGkpUnrbG0BV1fg4UPgwgVpnZ4e0KiR4uvz54GcHGm9hwdQvTqQmgrcuiWtq15dUZ+Xp6h3dX3GA6NyYZJERFRFJSUB6enSMnt7oGZNIDsbuHxZWmdgADRooPj67FkgP19aX6cOYG4O3LwJ3L4trbOxAdzcgEePgPh4aZ1MBjRurPg6Ph4wNa24f/TbtlV9zY4eBYKCgLlzgXnzpHXvvw8sWqRIkAICpHXm5kBWluLr3r0VidLjtm4FunYFVqwAPvtMWvfmm8DvvwPnzgH+/sD16xX3NavKmCQREVVBDx4As2YB4eHS8kmTgNBQIDoaaNNGWlezpmK0BAA6dlQkQ487cABo3RpYuBD4+mtp3bBhwM8/A9euqSYLhoZAbq7i6wEDgIsXFclSRfyjv2+f+pEkAJgwARg4UFpna6t4rldP8Zo+Tu+xCS2//65+JAkA3n4b6NBBWle9uuK5+HVLT6+Yr1dVJxNCCF0HUdFkZWXB0tISmZmZsLCw0HU4RETlcucOkJwsLdP1SNLmzUDPnoqEwt//2Y5Pm86dA7p1U4zu1K+v62j+c/q0IumsaK9XRaXtv98cSSIiqoIePVLMn/H2BoyNVevNzUv/o1ucLKlTs6bioY6xcen9urmVXKdLubnA1av/jdwQAby6jYioSoqPB3x9VUd1iKjsdJ4khYWFwd3dHUZGRggICMDhw4dLbJuSkoL+/fvDy8sLenp6GDdunEqbZcuWoWXLlrCysoKVlRXatWuHEydOPMcjICKisnJ3BzZsUDzT0zVqpJjLVHyVHL1YOk2S1q9fj3HjxmHKlCmIiYlBy5Yt0bFjRyQlJaltn5ubCzs7O0yZMgUNGzZU2+bgwYPo168fDhw4gKioKLi6uiIkJAQ3n5yBSEREL5yVleJKLysrXUdSOejpAXK5dBI4vTg6nbgdGBgIf39/LF68WFnm7e2N7t27IzQ0tNRtW7dujUaNGmH+/PmltissLISVlRUWLlyIwYMHlykuTtwmosquok74vX0bWL1acZWbvb2uo/lPVhYQFaW41L8ifexfugS8+y6wdOl/V9lRybT991tnuWleXh6io6MREhIiKQ8JCcHRo0e1tp+HDx8iPz8f1tbWJbbJzc1FVlaW5EFEVJnJZIpL72UyXUcidfMm8NFHqssL6JqFheIy/IqUIAHA/fvAoUOKZ3rxdHZ1W3p6OgoLC2H/xL8S9vb2SE1N1dp+Jk2ahJo1a6Jdu3YltgkNDcXMmTO1tk8iIl1r3LhiX6kVHw9YWgKenoqlBs6eVW3TsCGgr69YqiA7W1rn4gLY2QH//gskJkrrTE0BLy/F16dPq/br4wMYGQEJCcDdu4qye/eAv/4CRo4EHB2f9eioqtD5EgCyJ/7NEUKolJXXnDlzsHbtWhw8eBBGRkYltps8eTImTJig/D4rKwsuLi5aiYGIiP5jawuYmCgWZezSBdi2TZGgPLkAJQBkZipGdj74ANizR1q3cCEwejQQEQEMGiSte/VVxakzQH2/ly8DtWsD06YpTv0VMzEB3nnnmQ6PqhidJUm2trbQ19dXGTVKS0tTGV0qj++++w6zZ8/G3r174efnV2pbuVwOuVz+zPskIqoo4uMV835Wr1aslVRRuLoqYktPV4wkAYrVpZ9crRpQjAgBioRI3UgSAHTqpLpt8XaA+n6dnRXPX3yhWEW7WPF92IiK6SxJMjQ0REBAACIjI9GjRw9leWRkJLp16/ZMfX/77bf48ssvsXv3bjRp0uRZQyUiqnQePQJiYhTPFY2rqzQZMTAofXJ5nTol11lbKx4lKa1fd/eKvxSBqyuwbBmTN13R6em2CRMmYNCgQWjSpAmCgoKwdOlSJCUlYdSoUQAUp8Fu3ryJlStXKreJjY0FANy/fx937txBbGwsDA0N4ePjA0Bxim3atGlYs2YNatWqpRypMjMzg5mZ2Ys9QCIiomdgawsMH67rKF5eOk2S+vbti4yMDMyaNQspKSnw9fVFREQE3P6/bn1KSorKmkmNi28ABCA6Ohpr1qyBm5sbEv8/cy8sLAx5eXl48803JdtNnz4dM2bMeK7HQ0REpE3p6YqRpICA/26ma2amWA6gqAj4/7iBhK+v4srGa9cU870e5+QEODgoyq9dk9YZGSkmtQOKfouKpPX16inmbSUlKeJ6GU5P8ga3anCdJCKq7CrqOkmkmaQk1fvdBQcDBw8qrl5Ud01ScrJi3lXv3sAff0jrZs8GJk9WTJh/cmaLj4/iRr+AYsL8k/PAit9Lo0cDYWGKhCk+vmIlStr++80kSQ0mSURU2d29C+zdC7Rrx9WtK7vikZtiFWEk6fBhxRWKFS0JZ5L0AjBJIiIiKllFHamsMituExHR83P7NjB3ruKZSNtq1ADGj1c8V2VMkoiIqqCKevsPqhqcnRVJePGaU1UVkyQiIiLSyP37ilXNq/o95ZgkERERkUYuXQKaNVM8V2VMkoiIiIjUYJJERFQFWVoqbiBbfH80ItKcTlfcJiKi58PTU7FgIBGVH0eSiIiqoPx84M4dxTORtlWrprgtSbUqPtTCJImIqAo6e1axhs3Zs7qOhKoiPz9FEu7np+tIni8mSURERERqMEkiIiIijZw7B9Su/d8NcasqJklERESkkdxc4OpVxXNVxiSJiIiISI0qPi+diOjl1LAhkJkJmJrqOhKiyotJEhFRFaSvD1hY6DoKosqNp9uIiKqgy5eBDh0Uz0TaVrs2sGuX4rkq40gSEVEVlJ0N7NmjeCbSNgsLRRJe1XEkiYiIiDSSkgLMmKF4rsqYJBEREZFGUlKAmTOZJBERERG9lJgkERFVQS4uwMKFimciKh9O3CYiqoLs7IDRo3UdBVHlxiSJiOgZJCUB6emKr2vUAJydgfv3gUuXpO2qVfvvjunnzqnezqF2bcUVQykpqvM8rKwAd3cgJwc4f141Bn9/xfPFi8CDB4qv//0XOHsWGDIEsLZ+tmMkepKVFTBggOK5KpMJIYSug6hosrKyYGlpiczMTFhwNTYiKkFSEuDtDTx8qPh+/Hhg7lwgKgpo1kza1tYWuHNH8XXt2or7Xj1u1y7FJdUzZigmxD5uwABg1SrgyhWgTh3VOIo/xYOCgGPHpHXXrwOuruU6PKJKR9t/vzmSRERUTunpigRp1SpFslSjhqK8QQMgOlrattpjn7Zbt6ofSQKAkSOBrl2ldcX/rTs7q/b7uF9++W8kCVAkZkyQ6HnIyQFu3FC8J42MdB3N88MkiYionGxtgfffB1q2lCYjZmb/nQJTp379kuscHRUPdYyMSu/Xy6v0eIm05fx5ICBAkbSX9p6s7JgkERGVk6srsGiRrqMgoueFSwAQEZXTw4fA6dP/zUkioqqFSRIRUTlduKA45XDhgq4jIaLngafbiIiIqNweX3qiWK1aiqUn7twBkpOldebmiqs0CwuBuDjV/ho0AAwMFFeAZmZK62rWBOztgbt3gYQEaZ2xsaJem5gkERERkUb8/UtfeuK334CBA4ENG4APPpDWhYQAu3crEquAANW+09IUi6GOHw9s3y6t+/57YMIEYO9eoE8faV3jxsDBg890WCqYJBEREVG5Pbn0BKAYSQIUiUxQkLTO3FzxbGqqfkmL6tUVz/PmKdYNe1zxSFG7dqrbGhurH5l6FkySiIjKSU9P8YGvx9md9BIrbekJOzvFQx19/dKXD/D0LLnOykr9at9//VXyNuWh8a92cnIybty4ofz+xIkTGDduHJYuXVquAMLCwuDu7g4jIyMEBATg8OHDJbZNSUlB//794eXlBT09PYwbN05tu40bN8LHxwdyuRw+Pj7YvHlzuWIjIipNo0ZAVpbimYiqHo2TpP79++PAgQMAgNTUVLRv3x4nTpzAZ599hlmzZmnU1/r16zFu3DhMmTIFMTExaNmyJTp27IikpCS17XNzc2FnZ4cpU6agYcOGattERUWhb9++GDRoEOLi4jBo0CD06dMHx48f1+xAiYiI6KWm8b3brKyscOzYMXh5eWHBggVYv349/v77b+zZswejRo3CtWvXytxXYGAg/P39sXjxYmWZt7c3unfvjtDQ0FK3bd26NRo1aoT58+dLyvv27YusrCz8+eefyrLXX38dVlZWWLt2bZni4r3biKgszp8HevcGfv8d8PHRdTRE9NdfWQgO1uG92/Lz8yGXywEAe/fuRdf/32SoXr16SHny1tWlyMvLQ3R0NCZNmiQpDwkJwdGjRzUNSykqKgrjx4+XlHXo0EElmXpcbm4uch+7kVJWVla5909U6T1+W/uKpALeiCwnR5Eo5eToOhIiArR/ax6Nk6T69etjyZIl6Ny5MyIjI/HFF18AAG7dugUbG5sy95Oeno7CwkLY29tLyu3t7ZGamqppWEqpqaka9xkaGoqZT952m+hl9ORt7SsSExMgPr7CJUpEVHEYG2u3P42TpG+++QY9evTAt99+iyFDhijnBm3btg2vvPKKxgHIZDLJ90IIlbLn3efkyZMxYcIE5fdZWVlwcXF5phiIKqUnb2tfUcTHKxZdSU9nkkREJSphSnO5aZwktW7dGunp6cjKyoLVY9ffvfvuuzA1NS1zP7a2ttDX11cZ4UlLS1MZCdKEg4ODxn3K5XLlKUQigiJBqsq39iaiKunff7Xbn8ZXt7322mvIzs6WJEgAYG1tjb59+5a5H0NDQwQEBCAyMlJSHhkZiWbNmmkallJQUJBKn3v27HmmPomI1PHwALZuVTwTUdWj8UjSwYMHkZeXp1Kek5NT6hpH6kyYMAGDBg1CkyZNEBQUhKVLlyIpKQmjRo0CoDgNdvPmTaxcuVK5TWxsLADg/v37uHPnDmJjY2FoaAif/19aMnbsWLRq1QrffPMNunXrhq1bt2Lv3r04cuSIpodKRBVIElxQcMMQHv5AXh7wzz+qbRo1UizseOkScP++tM7VVTH3Oz1ddUjezAyoWxcoKgL+/xEj4esLGBoC164B9+5J61555b8VgomoailzknTmzBnl1+fPn5ec0iosLMSuXbtQU8M7y/Xt2xcZGRmYNWsWUlJS4Ovri4iICLi5uQFQLB755JpJjRs3Vn4dHR2NNWvWwM3NDYmJiQCAZs2aYd26dZg6dSqmTZsGT09PrF+/HoGBgRrFRkQVR1KKAbwRj04L8vB7V8W9ndTd8yknB5DLgXffBQ4dktYtWwYMHw5s2QKMGCGtCw5W3PMpP199v8nJgLMzMHEi8Mcf0rrZs4HJk5/l6IiooirzOkl6enrKyc/qNjE2NsaPP/6Id955R7sR6gDXSaKX1unTiiwhOrpCzUk6vToeAQO9sfOHK+g0pnaFGklycgIcHJ7h4IhIay5cyIK3tw7WSUpISIAQAh4eHjhx4gTsHrsZi6GhIWrUqAF9ff1nDoiIqCQONvkAFAlLaTlc3bol19naKh7q6OmV3i/nHhFVbE5O2u2vzElS8SmwoqIi7UZAREREpAXZ2drtr0xJ0rZt29CxY0cYGBhg27ZtpbYtXoGbiEhbnOzyMRuT4WTXT9ehEFEFdvWqdvsrU5LUvXt3pKamokaNGujevXuJ7WQyGQoLC7UVGxERAMDBtgCT8TVwxxc4XaDrcKQq4O1SiEg7ypQkPX6KjafbiOhFu2dgh78M30SrgaNRHZm6DkeKt0shqrI0XieJiOhFu5bvgm55vyN6VTz8vR/pOpz/FN8u5fDhinUbl2Ic5SJ6JuVKkvbt24d9+/YhLS1NZWRp+fLlWgmMiEiFtzdQcVYmUCQhJiaKRKki4igXvWQMDLTbn8ZJ0syZMzFr1iw0adIEjo6Oz3wzWiKiSsvVVZGEpKfrOhJVvCkwvYTq19dufxonSUuWLMEvv/yCQYMGaTcSIqLKyNW1Yich8fG6jkAVTwNSJaFxkpSXl8ebxRLRC2VkBPj4KJ6pjCryqUCeBqTn5Nw57fancZI0fPhwrFmzBtOmTdNuJEREJfDx0f6HX5VXUU8F8jQgPUf5+drtT+MkKScnB0uXLsXevXvh5+cHgydmSc2dO1drwRER0TOo6KcCiSo4jZOkM2fOoFGjRgCAf564wyQncRNpICmpYv6XXwHFxgKtWgF//aW4iS0R0YugcZJ04MCB5xEH0cslKUlxOfvDh7qORJWJScl3gNWRoiLFPZm4li0RvUhcTJJIF9LTFQnSqlUVbxFCXnlERJWUp6d2+9M4SWrTpk2pp9X279//TAERvVS8vQH/irQ6IhFR5WVurt3+NE6SGj0xISA/Px+xsbH4559/MGTIEG3FRURERKSRW7e025/GSdK8efPUls+YMQP3799/5oCIiJ5Urx4QHa14JiIqSVqadvvT01ZHAwcO5H3biOi5MDFRnJU0MdF1JET0MtFakhQVFQUjLodLRM9BUhIwerTimYjoRdH4dFvPnj0l3wshkJKSglOnTnEVbiJ6LtLTgbAwYNgwXnhHRC+OxkmSpaWl5Hs9PT14eXlh1qxZCAkJ0VpgRERERJqwttZufxonSStWrNBuBERERERaoO2RZq3NSSIiIiLSpUePtNsfV9ymqo/3SKv0atQAxo9XPBMRleTiRe32xySJqjbeI61KcHYG5s7VdRRE9LJhkkRVG++RViXcvw+cPQs0aACYmek6GiJ6WWicJB08eBCtW7d+DqEQPUe8R1qldukS0KyZYtVt/hiJ6EXReOL266+/Dk9PT3z55ZdITk5+HjERERERaUwm025/GidJt27dwtixY7Fp0ya4u7ujQ4cO2LBhA/Ly8rQbGREREZEGGjbUbn8aJ0nW1tYYM2YMTp8+jVOnTsHLywujR4+Go6MjxowZg7i4OO1GSERERKQDz7ROUqNGjTBp0iSMHj0aDx48wPLlyxEQEICWLVvi3Llz2oqRiF5y1aop5rlX46UmRFQKbS8BUK4kKT8/H3/88Qc6deoENzc37N69GwsXLsTt27eRkJAAFxcX9O7dW7uREtFLy88PuHNH8UxEVBKdLyb54YcfYu3atQCAgQMHYs6cOfD19VXWm5qa4uuvv0atWrW0FiQRERHRi6ZxknT+/Hn8+OOP6NWrFwwNDdW2cXJywoEDB545OCIiADh3DujWDdi6FahfX9fRENHLQqPTbfn5+XB1dUVgYGCJCRIAVKtWDcHBwWXqMywsDO7u7jAyMkJAQAAOHz5cavtDhw4hICAARkZG8PDwwJIlS1TazJ8/H15eXjA2NoaLiwvGjx+PnJycMsVDRBVPbi5w9arimYjoRdEoSTIwMMDmzZu1tvP169dj3LhxmDJlCmJiYtCyZUt07NgRSUlJatsnJCSgU6dOaNmyJWJiYvDZZ59hzJgx2Lhxo7LN6tWrMWnSJEyfPh3x8fEIDw/H+vXrMXnyZK3FTURERBWPm5t2+9N44naPHj2wZcsWrex87ty5GDZsGIYPHw5vb2/Mnz8fLi4uWLx4sdr2S5YsgaurK+bPnw9vb28MHz4c77zzDr777jtlm6ioKDRv3hz9+/dHrVq1EBISgn79+uHUqVNaiZmIiIgqJisr7fan8Zyk2rVr44svvsDRo0cREBAAU1NTSf2YMWPK1E9eXh6io6MxadIkSXlISAiOHj2qdpuoqCiEhIRIyjp06IDw8HDk5+fDwMAALVq0wKpVq3DixAm88soruHbtGiIiIjBkyJASY8nNzUXuY+P4WVlZZToGIiIiqjjS0rTbn8ZJ0s8//4zq1asjOjoa0dHRkjqZTFbmJCk9PR2FhYWwt7eXlNvb2yM1NVXtNqmpqWrbFxQUID09HY6Ojnjrrbdw584dtGjRAkIIFBQU4L333lNJxh4XGhqKmTNnliluInrxatcGdu1SPBMRleTWLe32p3GSlJCQoNUAZE/caEUIoVL2tPaPlx88eBBfffUVwsLCEBgYiCtXrmDs2LFwdHTEtGnT1PY5efJkTJgwQfl9VlYWXFxcynU8RKR9FhZAhw66joKqvKQkID1d11GosrUFXF11HcVLSWfr19ra2kJfX19l1CgtLU1ltKiYg4OD2vbVqlWDjY0NAGDatGkYNGgQhg8fDgBo0KABHjx4gHfffRdTpkyBnp7qNCy5XA65XK6NwyKi5yAlBfjpJ2DkSMDRUdfRUJWUlAR4ewMPH+o6ElUmJkB8PBMlHShXknTjxg1s27YNSUlJKje2nTt3bpn6MDQ0REBAACIjI9GjRw9leWRkJLp166Z2m6CgIGzfvl1StmfPHjRp0gQGBgYAgIcPH6okQvr6+hBCKEediKhySUkBZs4EunZlkkTPSXq6IkFatUqRLFUU8fHAwIGK+JgkvXAaJ0n79u1D165d4e7ujosXL8LX1xeJiYkQQsDf31+jviZMmIBBgwahSZMmCAoKwtKlS5GUlIRRo0YBUJwGu3nzJlauXAkAGDVqFBYuXIgJEyZgxIgRiIqKQnh4uHIFcADo0qUL5s6di8aNGytPt02bNg1du3aFvr6+podL9NJ58oyDpSXg6Qnk5wNnz6q2b9gQ0NcHLl8GsrOldS4ugJ0d8O+/QGKitM7UFPDyUnx9+rRqvz4+gJERkJCg+DtB9EJ4ewMa/i2jisPCQrv9aZwkTZ48GR999BFmzZoFc3NzbNy4ETVq1MCAAQPw+uuva9RX3759kZGRgVmzZiElJQW+vr6IiIiA2/8XOkhJSZGsmeTu7o6IiAiMHz8eixYtgpOTExYsWIBevXop20ydOhUymQxTp07FzZs3YWdnhy5duuCrr77S9FCJXjpJSarrjHTpAmzbBty7BwQEqG6Tman4YPrgA2DPHmndwoXA6NFARAQwaJC07tVXgagoxdfq+r18WTFRe9o0YPVqxRkHW9tyHxpR5VYR/1OogHOlPDy0259MaHgOytzcHLGxsfD09ISVlRWOHDmC+vXrIy4uDt26dUPik/8uVkJZWVmwtLREZmYmLLSdltKLdfq04i9wdDT/OyyD27eB+fOBVq2A4qmBFWEk6e7dCvl5TOVR/DtZUU9rVbTPioo+V2rTJsUveQWRce8+bNsGa+3vt8YjSaampso1hZycnHD16lXU///NlNIr4lUBRFRm9vZAaKj6OgOD0v921KlTcp21teJRktL6dXdXPKiKsLVV/HEdOFDXkaiqiMOVrq6KBK6i/X29cwfo2RPQ8AzS83YOflrtT+Mk6dVXX8Xff/8NHx8fdO7cGR999BHOnj2LTZs24dVXX9VqcET0Yt29C+zdC7Rrp/2Va4kAVNw/+kDFHa50da2YcVXEn+Oma8BXvbXWncZJ0ty5c3H//n0AwIwZM3D//n2sX78etWvXxrx587QWGBG9eAkJQJ8+ijMOTJLouamof/RJMxXx5xhdqNXuNEqSCgsLkZycDD8/xXCWiYkJwsLCtBoQERERUUWg0Q1u9fX10aFDB9y7d+85hUNERERUMWiUJAGKFayvXbv2PGIhIiIiKrcGtR9ptT+Nk6SvvvoKH3/8MXbs2IGUlBRkZWVJHkRUeRkbA40bK56JiCobba8ZrfHE7eIFI7t27Sq52WzxjWkLC7U7aYqIXhxvb/VrFhERVQZXb2j3PqwaJ0kHDhzQagBERERE2pD9QOMTZKXSOElyd3eHi4uLZBQJUIwkJScnay0wInrxYmIUtws5dkxx2o2I6GWmccrl7u6OO3fuqJT/+++/cOeyuESVmhBAXp7imYjoZadxklQ89+hJ9+/fh5GRkVaCIiIiItK1Mp9umzBhAgBAJpNh2rRpMDExUdYVFhbi+PHjaNSokdYDJCIiIioLZ/t8rfZX5iQpJiYGgGIk6ezZszA0NFTWGRoaomHDhvj444+1GhwRERFRWdlWL9Bqf2VOkoqvanv77bfxww8/wMLCQquBEJHueXsD//wDeHjoOhIiIs39m6XdhZI0vrptxYoVWg2AiCoOY2Ogfn1dR0FEVD5JKYZPb6SBMiVJPXv2xC+//AILCwv07Nmz1LabNm3SSmBE9OJdvw588QUwbRrg5qbraIiIdKtMSZKlpaXyijZLS8vnGhAR6U5GBhAeDrz/PpMkIqIyJUmPn2Lj6TYiIiJ6GWg8J6lYWloaLl68CJlMhrp166JGjRrajIuIiIhII6bGRVrtT+PFJLOysjBo0CDUrFkTwcHBaNWqFWrWrImBAwciMzNTq8ERERERlVUd11yt9qdxkjR8+HAcP34cO3bswL1795CZmYkdO3bg1KlTGDFihFaDI6IXy94emDRJ8UxE9LLT+HTbzp07sXv3brRo0UJZ1qFDByxbtgyvv/66VoOjSiYpCUhP13UUUvHxuo6gUqlZEwgN1XUURETlE3vRWKv9aZwk2djYqL3CzdLSElZWVloJiiqhpCTFSoQPH+o6ElUmJoCtra6jqBSys4HoaCAgADA313U0RES6pXGSNHXqVEyYMAErV66Eo6MjACA1NRWffPIJpk2bpvUAqZJIT1ckSKtWKZKlisTWFnB11XUUlcLly0CbNopEyd9f19EQEelWmZKkxo0bK9dJAoDLly/Dzc0Nrv//w5OUlAS5XI47d+5g5MiRzydSqhy8vfnXlYiIqoQyJUndu3d/zmEQERERVSxlSpKmT58OACgsLMSRI0fg5+fH+UdERERUodRzz9FqfxotAaCvr48OHTrg3r17Wg2CiCoGAwPFFW4GBrqOhIhIc0aGQqv9abxOUoMGDXDt2jWtBkFEFUODBsCNG4pnIqLKJjHFUKv9aZwkffXVV/j444+xY8cOpKSkICsrS/IgIiIi0oV7Wfpa7U/jJQCKF4zs2rWr5Io3IQRkMhkKCwu1Fx0RvVBnzwIdOwJ//snRJCIijZOkAwcOPI84iKgCyM8Hbt5UPBMRvew0TpKCg4NLrIuNjX2WWIiIiIgqDI3nJD0pMzMTYWFh8Pf3R0BAgDZiIiIiItKYg412h8HLnSTt378fAwcOhKOjI3788Ud06tQJp06d0rifsLAwuLu7w8jICAEBATh8+HCp7Q8dOoSAgAAYGRnBw8MDS5YsUWlz7949jB49Go6OjjAyMoK3tzciIiI0jo2IiIgqDwfbAq32p9Hpths3buCXX37B8uXL8eDBA/Tp0wf5+fnYuHEjfHx8NN75+vXrMW7cOISFhaF58+b46aef0LFjR5w/f155y5PHJSQkoFOnThgxYgRWrVqFv//+G++//z7s7OzQq1cvAEBeXh7at2+PGjVq4I8//oCzszOSk5Nhzrt1Ej1VnTrAgQOKZyKiyibrwTOfIJOQCSHKtPJSp06dcOTIEbzxxhsYMGAAXn/9dejr68PAwABxcXHlSpICAwPh7++PxYsXK8u8vb3RvXt3hIaGqrSfOHEitm3bhvj4eGXZqFGjEBcXh6ioKADAkiVL8O233+LChQswKOeKeFlZWbC0tERmZiYsLCzK1cdL5/Rpxa3jeWdUIiLSkb+WnUTwu69o7e93mVOuPXv2YPjw4Zg5cyY6d+4Mff1nW4sgLy8P0dHRCAkJkZSHhITg6NGjareJiopSad+hQwecOnUK+f+/HGfbtm0ICgrC6NGjYW9vD19fX8yePbvUpQlyc3O53hMRFFe2TZ6seCYietmVOUk6fPgwsrOz0aRJEwQGBmLhwoW4c+dOuXecnp6OwsJC2NvbS8rt7e2RmpqqdpvU1FS17QsKCpCeng4AuHbtGv744w8UFhYiIiICU6dOxffff4+vvvqqxFhCQ0NhaWmpfLi4uJT7uIgqs9u3ga+/VjwTEb3sypwkBQUFYdmyZUhJScHIkSOxbt061KxZE0VFRYiMjER2dna5Anh8QUrgv0UpNWn/eHlRURFq1KiBpUuXIiAgAG+99RamTJkiOaX3pMmTJyMzM1P5SE5OLtexEBERUdWh8QwnExMTvPPOOzhy5AjOnj2Ljz76CF9//TVq1KiBrl27lrkfW1tb6Ovrq4wapaWlqYwWFXNwcFDbvlq1arCxsQEAODo6om7dupLTgd7e3khNTUVeXp7afuVyOSwsLCQPIiIiqlzkur7B7eO8vLwwZ84c3LhxA2vXrtVoW0NDQwQEBCAyMlJSHhkZiWbNmqndJigoSKX9nj170KRJE+Uk7ebNm+PKlSsoKipStrl06RIcHR1haKjdG98RERFRxeHtnqPV/rRyrZy+vj66d++Obdu2abTdhAkT8PPPP2P58uWIj4/H+PHjkZSUhFGjRgFQnAYbPHiwsv2oUaNw/fp1TJgwAfHx8Vi+fDnCw8Px8ccfK9u89957yMjIwNixY3Hp0iXs3LkTs2fPxujRo7VxqERVmo0NMGyY4pmI6GWn8W1JtKlv377IyMjArFmzkJKSAl9fX0RERMDNzQ0AkJKSgqSkJGV7d3d3REREYPz48Vi0aBGcnJywYMEC5RpJAODi4oI9e/Zg/Pjx8PPzQ82aNTF27FhMnDjxhR8fUWmSkgAzM8DaGrhzB3hyKpy5uWK9osJCIC5OdfsGDQADA+DqVSAzU1pXsyZgbw/cvQskJEjrjI0Bb2/F1zExwJOLgPz4o6INEVFl889V7X54lXmdpJcJ10kqB66TpJGkJMDNDZg7Fxg/Hli0CPjgA2mbkBBg924gKwuwtFTtIy0NsLMDunYFtm+X1n3/PTBhAvD770CfPtK6xo0VPy4AkMuBJ6fq/fMPUL/+sx0fEZEuaHudJJ2OJBG9rP6/YgUaNFA89+kDBAVJ2xQvEm9qqsg9n1S9uuJ53jxgxgxpXc2aiud27VS3fXyU6Ngx1ZEkD4+yHAERUdXHJIlIh6ytFc92doqHOvr6pQ/OeXqWXGdlpXiUpHHjp8dIRPSy0u5NToiIiIiqCCZJRDpgagq8+qrimYiItKO2a65W++PpNiId8PIC/n9PZiIi0hIz46KnN9IAR5KIiIioSrh5x0Cr/TFJItKB06cBmey/S/GJiOjZ3flXuyfImCQRERERqcEkiYiIiEgNJklEREREajBJIiIioirBpnqBVvvjEgBEOuDjA1y+DDg76zoSIqKqw8U+X6v9MUki0gEjI6B2bV1HQURUtTzMkWm1P55uI9KBhARg4EDFMxERacel60Za7Y9JEpEO3L0LrF6teCYiooqJSRIRERGRGkySiIiIiNRgkkRERERVgp6WsxomSUQ64OgITJ+ueCYiIu3wq/NIq/1xCQAiHXB0BGbM0HUURERUGo4kEelAVhawe7fimYiItONCIpcAIKr0rlwBXn9d8UxERNqRk8vFJImIiIieOyZJRERERGowSSIiIiJSg0kSkQ7I5YCnp+KZiIi0o1bNPK32xyUAKpukJCA9XddRqIqP13UElUr9+py0TUSkbdXNCrXaH5OkyiQpCfD2Bh4+1HUk6pmYALa2uo6CiIheUrcztJvWMEmqTNLTFQnSqlWKZKmisbUFXF11HUWlcOYM0LYtsG8f4Oen62iIiKqGlHQDrfbHJKky8vYG/P11HQU9g4ICRc5bUKDrSIiIqCScuE1ERESkBpMkIiIiIjWYJBEREVGVYGmu3avbmCQR6UDdusDRo4pnIiLSDncnrpNEVOmZmQFBQbqOgoioaskrqGI3uA0LC4O7uzuMjIwQEBCAw4cPl9r+0KFDCAgIgJGRETw8PLBkyZIS265btw4ymQzdu3fXctREz+bGDWDCBMUzERFpx/mrRlrtT6dJ0vr16zFu3DhMmTIFMTExaNmyJTp27IikpCS17RMSEtCpUye0bNkSMTEx+OyzzzBmzBhs3LhRpe3169fx8ccfo2XLls/7MIg0lpYGzJuneCYioopJp0nS3LlzMWzYMAwfPhze3t6YP38+XFxcsHjxYrXtlyxZAldXV8yfPx/e3t4YPnw43nnnHXz33XeSdoWFhRgwYABmzpwJDw+PF3EoREREVMXoLEnKy8tDdHQ0QkJCJOUhISE4evSo2m2ioqJU2nfo0AGnTp1Cfn6+smzWrFmws7PDsGHDyhRLbm4usrKyJA8iIiJ6ueksSUpPT0dhYSHs7e0l5fb29khNTVW7TWpqqtr2BQUFSP//TV///vtvhIeHY9myZWWOJTQ0FJaWlsqHi4uLhkdDREREVY3OJ27LZNKZ6EIIlbKntS8uz87OxsCBA7Fs2TLYanCj1cmTJyMzM1P5SE5O1uAIiDRnawu8/z7vB0xEpE1+dR5ptT+dLQFga2sLfX19lVGjtLQ0ldGiYg4ODmrbV6tWDTY2Njh37hwSExPRpUsXZX1RUREAoFq1arh48SI8PT1V+pXL5ZDL5c96SERl5uoKLFqk6yiIiKoWPS0P/ehsJMnQ0BABAQGIjIyUlEdGRqJZs2ZqtwkKClJpv2fPHjRp0gQGBgaoV68ezp49i9jYWOWja9euaNOmDWJjY3kajSqMhw+B06cVz0REpB1XkrU74KHTxSQnTJiAQYMGoUmTJggKCsLSpUuRlJSEUaNGAVCcBrt58yZWrlwJABg1ahQWLlyICRMmYMSIEYiKikJ4eDjWrl0LADAyMoKvr69kH9WrVwcAlXIiXbpwAQgIAKKjAX9/XUdDRFQ13H+o3bEfnSZJffv2RUZGBmbNmoWUlBT4+voiIiICbm5uAICUlBTJmknu7u6IiIjA+PHjsWjRIjg5OWHBggXo1auXrg6BiIiIqiiZKJ75TEpZWVmwtLREZmYmLCwsdB3Of06f5vBDFcEfJRGR9v217CSC331Fa3+/dX51GxEREVFFxCSJSAf09ABzc+1fiUFE9DJzsc/Tan86nZNE9LJq1Ajgwu5ERNplU71Qq/3x/1giIiKqEjLu6Wu1PyZJRDpw/jxQv77imYiItCP5tqFW+2OSRKQDOTmKBCknR9eREBFRSZgkEREREanBJImIiIhIDSZJREREVCWYmRRptT8mSUQ64OEBbN2qeCYiIu2o7ZKr1f64ThKRDlSvDnTtqusoiIiqliLtDiRxJIlIF1JTgdBQxTMREWnHmcvGWu2PI0lU5SUlAenpiq+rV1ec4srLA/75R7Vto0aKW4VcugTcvy+tc3UFbG0VfSUlSevMzIC6dRX/xcTGqvbr6wsYGgLXrgH37gHx8cBnnwEdOgAODs9+jEREpH1MkqhKS0oCvL2Bhw8V37/5JvD770BaGhAQoNo+JweQy4F33wUOHZLWLVsGDB8ObNkCjBghrQsOBg4eBPLz1febnAw4OwMTJwJ//KEoMzFRJF1ERFQxMUmiKi09XZEgrVqlSJaqV1eU16gBREertjcwUDwvXap+JAkAuncH/P2ldWZm/22vrt8aNRTP33wDTJ6s+NrW9r8+iYio4mGSRFWakxMwezbQtq30tJahoWqi87i6dUuus7UteQRIT6/0fnk1GxFR5cEkiao0B4f/Rm6IiKhq8/HU7r2eeHUbVWn37gHbtimeiYioajOsJrTaH5MkqtKuXQO6dVM8ExFR1ZZwy1Cr/TFJIiIioiohM1tfq/0xSSIiIiJSg0kSERERkRpMkqhKMzICfHwUz0RERJrgEgBUpfn4AOfO6ToKIiJ6ERxt87XaH5Mk0prie6QVj9wkJAB370rbODoqHllZwJUr0jq5HKhfX/H1mTNAQYG0vm5dxcrWN24obivyuOLVqx8+BC5ckNa5uAB2ds9+fEREVLHZ2xQ8vZEGmCSRVjx+j7TLl4HatYFp04DVq6Xtpk8HZswAoqKA11+X1nl6/pc4tW37301pix09CgQFAXPnAvPmSevefx9YtEiRID157zRzc+D8ecW904iIqOq6d1+7V7cxSSKtePweacXJyBdfABMmSNs5Oiqeg4JU73Eml//39b596keSAEWfAwdK64pvE1Kvnmq/trZMkIiIXgaJN7W7ThKTJNIqb+//Jkm7uyse6lhYlH6PMz+/kuucnUtOekxMSu+XiIiorHh1GxEREZEaHEkirfD3B4R2b5lDRESkUxxJIiIioirBSM4b3FIFdPGiYjL2xYu6joSIiF5W9WrlaLU/JkmkFQ8eAMeOKZ6JiIiqAiZJREREVCWcuWys1f50niSFhYXB3d0dRkZGCAgIwOHDh0ttf+jQIQQEBMDIyAgeHh5YsmSJpH7ZsmVo2bIlrKysYGVlhXbt2uHEiRPP8xCIiIioAigq0m5/Ok2S1q9fj3HjxmHKlCmIiYlBy5Yt0bFjRyQlJaltn5CQgE6dOqFly5aIiYnBZ599hjFjxmDjxo3KNgcPHkS/fv1w4MABREVFwdXVFSEhIbh58+aLOiwiIiKqAmRC6O7C7cDAQPj7+2Px4sXKMm9vb3Tv3h2hoaEq7SdOnIht27YhPj5eWTZq1CjExcUhKipK7T4KCwthZWWFhQsXYvDgwWWKKysrC5aWlsjMzISFhYWGR/UcnT6tuOdGdHSFWzHx33+BiAigUyfA2lrX0RAR0cvor2UnEfzuK1r7+62zkaS8vDxER0cjJCREUh4SEoKjR4+q3SYqKkqlfYcOHXDq1Cnk56u/8+/Dhw+Rn58P61L+cufm5iIrK0vyIM1YWytuFcIEiYiIqgqdJUnp6ekoLCyEvb29pNze3h6pqalqt0lNTVXbvqCgAOlP3g31/yZNmoSaNWuiXbt2JcYSGhoKS0tL5cPFxUXDo6E7dxQ3mL1zR9eREBHRy6qum3aXAND5itsymUzyvRBCpexp7dWVA8CcOXOwdu1aHDx4EEbFNxRTY/LkyZjw2J1Ys7KyFIlSbCxgZlaWw3gxHjvNWNEkJwMffKBYK8nOTtfREBHRy8jESLsziHSWJNna2kJfX19l1CgtLU1ltKiYg4OD2vbVqlWDjY2NpPy7777D7NmzsXfvXviVdrdUAHK5HPLHb0FfLDi4DEfygpmY/HfLeyIiIlJKvm2g1f50liQZGhoiICAAkZGR6NGjh7I8MjIS3bp1U7tNUFAQtm/fLinbs2cPmjRpAgOD/16Yb7/9Fl9++SV2796NJk2alD/IpUsVE6UrEltbwNVV11EQERFVOBn3tJvW6PR024QJEzBo0CA0adIEQUFBWLp0KZKSkjBq1CgAitNgN2/exMqVKwEormRbuHAhJkyYgBEjRiAqKgrh4eFYu3atss85c+Zg2rRpWLNmDWrVqqUceTIzM4OZpqfOvLwq3FVkRERE9GLoNEnq27cvMjIyMGvWLKSkpMDX1xcRERFwc3MDAKSkpEjWTHJ3d0dERATGjx+PRYsWwcnJCQsWLECvXr2UbcLCwpCXl4c333xTsq/p06djxowZL+S4Xkbm5kBIiOKZiIioKtDpOkkVlXKdpEOHYNGqla7DISIiojKoMuskUdVSWAhkZSmeiYiIdMHOukCr/TFJIq2IiwMsLRXPREREulDTTv3C0uXFJImIiIiqhPuPtJvWMEkiIiKiKuFKkpo1D58BkyQiIiIiNXR+WxLSTEoK4Oio+PrsWeDJ+/rWqaO4DP/mTeD2bWmdjQ3g5gY8eqR6hxOZDGjcWPF1fLyizePc3QErK0WfN29K6ywtn+2YiIiIKiImSZVIUhLQrBkQE6O4P1rHjqoJy4EDQOvWwMKFwNdfS+uGDQN+/hm4dk11IXFDQyA3V/H1gAGKfTxuwwagd29g9Wrgo4+kdV26ABs3AmlpQPXqz3qUREREFQOTpEokPV2RFCUnK5KkP/9UP5IEKG4227u3tK749nYeHkB0tLTu8fsDr16tfiQJUCRQrVtL6ywtAQMD3tiWiIh0q5qWsxomSZVYgwYl19WsqXioY2xc+t1WvL1LrrO3VzyIiIgqGl/PR09vpAFO3CYiIiJSg0kSERERVQnxCUZa7Y9JUiVSp45iYnbxvCMiIiL6T26e7OmNNMA5SZWIubnqpGkiIiJ6PjiSVIncvAlMnqx62T8RERFpH5OkSuT2bcXaR08uEklERETaxySJiIiIqgQP51yt9sckiYiIiKoEC9MirfbHJImIiIiqhNR07V6PxiSpErGxUdx/rfj2IkRERPSf1AwDrfbHJQAqETc3xQ1qiYiI6PnjSFIl8ugRcO6c6s1niYiISPuYJFUi8fGAr6/imYiIiJ4vJklERERUJVS3KNRqf0ySiIiIqEqo5Zin1f6YJBEREVGVkKPlG9wySapEZDLA0FDxTERERFIXEoy02h+XAKhEGjcGcrW74joRERGVgCNJRERERGowSapE4uMBf38uAUBERPQiMEmqRB49AmJiuJgkERHRi8AkiYiIiKqERl7aHUVgkkRERESkBq9uK0VOngxXTquW+/srni9eBB48kNbVqgVYWwN37gDJydI6c3OgTh2gsBCIi1Ptt0EDwMAAuHoVyMyU1tWsWe7DICIieilcTpJrtT8mSaW4eccQAe1Vy4VQPA8dChw7Jq377Tdg4EBgwwbggw+kdSEhwO7disQqIEC137Q0wM4OGD8e2L5dWvf998Dbbyv6dXcv9yERERFVWQ8eafcEGZOkUhQWANHRJdf/8ov6kSQA6NMHCAqS1pmbK55NTdX3W7264nnePGDGDGldzZqAlRXQu3fZYiciIqJno/MkKSwsDN9++y1SUlJQv359zJ8/Hy1btiyx/aFDhzBhwgScO3cOTk5O+PTTTzFq1ChJm40bN2LatGm4evUqPD098dVXX6FHjx4ax/YwRw+t/Euu9/Iquc7OTvFQR1//v1N26nh6li0+IiIien50OnF7/fr1GDduHKZMmYKYmBi0bNkSHTt2RFJSktr2CQkJ6NSpE1q2bImYmBh89tlnGDNmDDZu3KhsExUVhb59+2LQoEGIi4vDoEGD0KdPHxw/fvxFHRYRERFVATIhimfYvHiBgYHw9/fH4sWLlWXe3t7o3r07QkNDVdpPnDgR27ZtQ/xjqymOGjUKcXFxiIqKAgD07dsXWVlZ+PPPP5VtXn/9dVhZWWHt2rVliisrKwuWlpY4tPQEWo1oWt7DIyIiohcoccffcO/SApmZmbCwsHjm/nR2ui0vLw/R0dGYNGmSpDwkJARHjx5Vu01UVBRCQkIkZR06dEB4eDjy8/NhYGCAqKgojB8/XqXN/PnzS4wlNzcXuY/dFC3z/5eWPXh0H1lZWZocFhEREelINX3F32xtjf/oLElKT09HYWEh7O3tJeX29vZITU1Vu01qaqra9gUFBUhPT4ejo2OJbUrqEwBCQ0Mxc+ZMlfJOY18Dxpb1iIiIiKgiyMjIgKWl5TP3o/OJ2zKZTPK9EEKl7GntnyzXtM/JkydjwoQJyu+Liorw77//wsbGptTtXrSsrCy4uLggOTlZK8OILwO+Zprh66UZvl6a42umGb5emsnMzISrqyusra210p/OkiRbW1vo6+urjPCkpaWpjAQVc3BwUNu+WrVqsLGxKbVNSX0CgFwuh1wuXYCqevH1+BWQhYUFf1k0xNdMM3y9NMPXS3N8zTTD10szenrauS5NZ1e3GRoaIiAgAJGRkZLyyMhINGvWTO02QUFBKu337NmDJk2awMDAoNQ2JfVJREREpI5OT7dNmDABgwYNQpMmTRAUFISlS5ciKSlJue7R5MmTcfPmTaxcuRKA4kq2hQsXYsKECRgxYgSioqIQHh4uuWpt7NixaNWqFb755ht069YNW7duxd69e3HkyBGdHCMRERFVTjpNkvr27YuMjAzMmjULKSkp8PX1RUREBNzc3AAAKSkpkjWT3N3dERERgfHjx2PRokVwcnLCggUL0KtXL2WbZs2aYd26dZg6dSqmTZsGT09PrF+/HoGBgS/8+LRNLpdj+vTpKqcGqWR8zTTD10szfL00x9dMM3y9NKPt10un6yQRERERVVQ6XXGbiIiIqKJikkRERESkBpMkIiIiIjWYJBERERGpwSSJiIiISA0mSZVAQUEBpk6dCnd3dxgbG8PDwwOzZs1CUVGRrkOrEP766y906dIFTk5OkMlk2LJli6ReCIEZM2bAyckJxsbGaN26Nc6dO6ebYCuI0l6z/Px8TJw4EQ0aNICpqSmcnJwwePBg3Lp1S3cB69jT3mOPGzlyJGQyWak31a7qyvJ6xcfHo2vXrrC0tIS5uTleffVVyZIvL5unvWb379/HBx98AGdnZxgbG8Pb2xuLFy/WTbA6FhoaiqZNm8Lc3Bw1atRA9+7dcfHiRUkbbX3uM0mqBL755hssWbIECxcuRHx8PObMmYNvv/0WP/74o65DqxAePHiAhg0bYuHChWrr58yZg7lz52LhwoU4efIkHBwc0L59e2RnZ7/gSCuO0l6zhw8f4vTp05g2bRpOnz6NTZs24dKlS+jatasOIq0YnvYeK7ZlyxYcP34cTk5OLyiyiulpr9fVq1fRokUL1KtXDwcPHkRcXBymTZsGIyOjFxxpxfG012z8+PHYtWsXVq1ahfj4eIwfPx4ffvghtm7d+oIj1b1Dhw5h9OjROHbsGCIjI1FQUICQkBA8ePBA2UZrn/uCKrzOnTuLd955R1LWs2dPMXDgQB1FVHEBEJs3b1Z+X1RUJBwcHMTXX3+tLMvJyRGWlpZiyZIlOoiw4nnyNVPnxIkTAoC4fv36iwmqAivp9bpx44aoWbOm+Oeff4Sbm5uYN2/eC4+tIlL3evXt25efX6VQ95rVr19fzJo1S1Lm7+8vpk6d+gIjq5jS0tIEAHHo0CEhhHY/9zmSVAm0aNEC+/btw6VLlwAAcXFxOHLkCDp16qTjyCq+hIQEpKamIiQkRFkml8sRHByMo0eP6jCyyiUzMxMymaxC3/hZl4qKijBo0CB88sknqF+/vq7DqdCKioqwc+dO1K1bFx06dECNGjUQGBhY6ilMUvwd2LZtG27evAkhBA4cOIBLly6hQ4cOug5N5zIzMwEA1tbWALT7uc8kqRKYOHEi+vXrh3r16sHAwACNGzfGuHHj0K9fP12HVuGlpqYCAOzt7SXl9vb2yjoqXU5ODiZNmoT+/fvzLuQl+Oabb1CtWjWMGTNG16FUeGlpabh//z6+/vprvP7669izZw969OiBnj174tChQ7oOr8JasGABfHx84OzsDENDQ7z++usICwtDixYtdB2aTgkhMGHCBLRo0QK+vr4AtPu5r9N7t1HZrF+/HqtWrcKaNWtQv359xMbGYty4cXBycsKQIUN0HV6lIJPJJN8LIVTKSFV+fj7eeustFBUVISwsTNfhVEjR0dH44YcfcPr0ab6nyqD4gpNu3bph/PjxAIBGjRrh6NGjWLJkCYKDg3UZXoW1YMECHDt2DNu2bYObmxv++usvvP/++3B0dES7du10HZ7OfPDBBzhz5ozam9hr43OfSVIl8Mknn2DSpEl46623AAANGjTA9evXERoayiTpKRwcHAAo/rNwdHRUlqelpan8l0FS+fn56NOnDxISErB//36OIpXg8OHDSEtLg6urq7KssLAQH330EebPn4/ExETdBVcB2draolq1avDx8ZGUe3t7q/1DR8CjR4/w2WefYfPmzejcuTMAwM/PD7Gxsfjuu+9e2iTpww8/xLZt2/DXX3/B2dlZWa7Nz32ebqsEHj58CD096Y9KX1+fSwCUgbu7OxwcHBAZGaksy8vLw6FDh9CsWTMdRlaxFSdIly9fxt69e2FjY6PrkCqsQYMG4cyZM4iNjVU+nJyc8Mknn2D37t26Dq/CMTQ0RNOmTVUu2b506RLc3Nx0FFXFlp+fj/z8fP4d+D8hBD744ANs2rQJ+/fvh7u7u6Rem5/7HEmqBLp06YKvvvoKrq6uqF+/PmJiYjB37ly88847ug6tQrh//z6uXLmi/D4hIQGxsbGwtraGq6srxo0bh9mzZ6NOnTqoU6cOZs+eDRMTE/Tv31+HUetWaa+Zk5MT3nzzTZw+fRo7duxAYWGh8jy+tbU1DA0NdRW2zjztPfZkEmlgYAAHBwd4eXm96FArhKe9Xp988gn69u2LVq1aoU2bNti1axe2b9+OgwcP6i5oHXvaaxYcHIxPPvkExsbGcHNzw6FDh7By5UrMnTtXh1HrxujRo7FmzRps3boV5ubmys8nS0tLGBsbQyaTae9zX1uX4NHzk5WVJcaOHStcXV2FkZGR8PDwEFOmTBG5ubm6Dq1COHDggACg8hgyZIgQQnE56PTp04WDg4OQy+WiVatW4uzZs7oNWsdKe80SEhLU1gEQBw4c0HXoOvG099iTXvYlAMryeoWHh4vatWsLIyMj0bBhQ7FlyxbdBVwBPO01S0lJEUOHDhVOTk7CyMhIeHl5ie+//14UFRXpNnAdKOnzacWKFco22vrcl/1/h0RERET0GM5JIiIiIlKDSRIRERGRGkySiIiIiNRgkkRERESkBpMkIiIiIjWYJBERERGpwSSJiIiISA0mSURERERqMEkiojL76KOP0KVLF12HUarWrVtDJpNBJpMhNja2zNsNHTpUud2WLVu03r+2lTVeIio/JklEVGaxsbFo1KiRrsNQGjduHLp3765SPmLECKSkpMDX1xcAEBoaiqZNm8Lc3Bw1atRA9+7dVW6w+sMPPyAlJaVM+32yf0Bxx/GxY8eidu3aMDIygr29PVq0aIElS5bg4cOHZT6mLl26lHhX96ioKMhkMpw+fVqjeImofJgkEVGZxcXFVagk6eTJk3jllVdUyk1MTODg4IBq1RT38D506BBGjx6NY8eOITIyEgUFBQgJCcGDBw+U21haWsLBwaFM+32y/2vXrqFx48bYs2cPZs+ejZiYGOzduxfjx4/H9u3bsXfv3jIf07Bhw7B//35cv35dpW758uVo1KgR/P39NYqXiMqHSRIRlUlycjIyMjKUSVJycjIGDBgAKysrWFlZoX///rh7966y/e3btyGTyfDDDz+gcePGMDIyQv369XHkyJEy7a+07fPz82FoaIijR49iypQpkMlkCAwMLLGvXbt2YejQoahfvz4aNmyIFStWICkpCdHR0c/0mhR7//33Ua1aNZw6dQp9+vSBt7c3GjRogF69emHnzp2SU5RCCMyZMwceHh4wNjZGw4YN8ccffyjr33jjDdSoUQO//PKLZB8PHz7E+vXrMWzYMK3ETERPxySJiMokNjYW5ubm8PDwwJUrVxAQEABPT09ERUVh7969uHr1Kj755BNl+5iYGABAWFgY5s2bh7i4ONSqVQsDBgxAUVHRU/dX2vb6+vrKZCs2NhYpKSnYvXt3mY8lMzMTAGBtbV3mbUqSkZGBPXv2YPTo0TA1NVXbRiaTKb+eOnUqVqxYgcWLF+PcuXMYP348Bg4ciEOHDgEAqlWrhsGDB+OXX37B4/cf//3335GXl4cBAwY8c8xEVDbVdB0AEVUOsbGxaNiwIWQyGUaNGoX33nsPM2fOVNZ/+umnkiQpLi4OBgYG2LVrF9zd3QEAs2bNQpMmTXDz5k24uLiUur+nbX/r1i3Y2NigYcOGGh2HEAITJkxAixYtJHOKyuvKlSsQQsDLy0tSbmtri5ycHADA6NGj8c033+DBgweYO3cu9u/fj6CgIACAh4cHjhw5gp9++gnBwcEAgHfeeQfffvstDh48iDZt2gBQnGrr2bMnrKysnjlmIiobJklEVCbFk7avX7+Offv24ejRo/j++++V9YWFhZLEJzY2Fj179lQmOAAgl8s12l9p28fExGicIAHABx98gDNnzpT5tF9ZPT5aBAAnTpxAUVERBgwYgNzcXADA+fPnkZOTg/bt20va5uXloXHjxsrv69Wrh2bNmmH58uVo06YNrl69isOHD2PPnj1ajZmISsckiYjKJDY2Fp06dUJcXBysra1x/PhxlTbGxsaS9kOGDJHUnz59Gra2tqhZs2aZ9lfa9sUjW5r48MMPsW3bNvz1119wdnbWaNuS1K5dGzKZDBcuXJCUe3h4AJC+JsWnGXfu3KnyGjyZQA4bNgwffPABFi1ahBUrVsDNzQ1t27bVSsxEVDack0RET5WdnY2EhAQ0atQIBgYGyM7OhqOjI2rXri15FP/hf/ToES5fvozCwkJlH0VFRfjhhx8wZMgQ6OmV/tFTlu3Pnj0LPz+/MsUvhMAHH3yATZs2Yf/+/ZLRqWdlY2OD9u3bY+HChZKr5dTx8fGBXC5HUlKSymv35OnHPn36QF9fH2vWrMGvv/6Kt99+W2W0ioieLyZJRPRUsbGx0NfXh6+vLwIDA2FhYYFBgwYhNjYWV65cwa5duzB27Fhl+7Nnz0Imk2HVqlWIiopCfHw8+vbti3v37mHq1KlP3V9Zti8qKsKZM2dw69Yt5UTskowePRqrVq3CmjVrYG5ujtTUVKSmpuLRo0fP9sL8X1hYGAoKCtCkSROsX78e8fHxuHjxIlatWoULFy5AX18fAGBubo6PP/4Y48ePx6+//oqrV68iJiYGixYtwq+//irp08zMDH379sVnn32GW7duYejQoVqJlYjKjkkSET1VXFwc6tWrB7lcDmtra0RERODu3bsIDg6Gv78/PvvsM9SqVUvZPjY2FvXq1cPUqVPx5ptvokmTJtDT00NUVBSqV6/+1P2VZfsvv/wS69evR82aNTFr1qxS+1u8eDEyMzPRunVrODo6Kh/r169/hlflP56enoiJiUG7du0wefJkNGzYEE2aNMGPP/6Ijz/+GF988YWy7RdffIHPP/8coaGh8Pb2RocOHbB9+3a1o1vDhg3D3bt30a5dO7i6umolViIqO5l4/BpTIiItGD16NO7evYs1a9a88O1bt26NRo0aYf78+eXat0wmw+bNm9Wu5K2N/rXtafESUflxJImItC42NrbM84Wex/ZhYWEwMzPD2bNny7zNqFGjYGZm9tz61zZN4iWi8uFIEhFplRAClpaWWLduHTp16qS2TVJSEnx8fErc/tGjR9ixY0eJ25fm5s2byrlGrq6uMDQ0LNN2aWlpyMrKAgA4OjqWuDBkefvXtrLGS0TlxySJiF64goICJCYmllhfq1Yt5X3RiIh0hUkSERERkRqck0RERESkBpMkIiIiIjWYJBERERGpwSSJiIiISA0mSURERERqMEkiIiIiUoNJEhEREZEaTJKIiIiI1GCSRERERKQGkyQiIiIiNf4HC9kMlCc2+f0AAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_SoverB(data)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the [ATLAS Higgs discovery paper](https://www.sciencedirect.com/science/article/pii/S037026931200857X), there are a number of numerical cuts applied, not just on lep_pt_1 and lep_pt_2.\n", "\n", "Imagine having to separately optimise about 7 variables! Not to mention that applying a cut on one variable could change the distribution of another, which would mean you'd have to re-optimise... Nightmare.\n", "\n", "This is where a Machine Learning algorithm such as a Boosted Decision Tree (BDT) can come to the rescue. A BDT can optimise all variables at the same time.\n", "\n", "A BDT not only optimises cuts, but can find correlations in many dimensions that will give better signal/background classification than individual cuts ever could.\n", "\n", "That's the end of the introduction to why one might want to use a BDT. If you'd like to try using one, just keep reading below!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Boosted Decision Tree (BDT)\n", "\n", "Choose variables for use in the BDT" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "data_for_BDT = {} # define empty dictionary to hold dataframes that will be used to train the BDT\n", "BDT_inputs = ['lep_pt_1','lep_pt_2'] # list of features for BDT\n", "for key in data: # loop over the different keys in the dictionary of dataframes\n", " data_for_BDT[key] = data[key][BDT_inputs].copy()\n", "data_for_BDT" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Organise data ready for the BDT" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "# for sklearn data is usually organised \n", "# into one 2D array of shape (n_samples x n_features) \n", "# containing all the data and one array of categories \n", "# of length n_samples \n", "\n", "all_MC = [] # define empty list that will contain all features for the MC\n", "for key in data: # loop over the different keys in the dictionary of dataframes\n", " if key!='data': # only MC should pass this\n", " all_MC.append(data_for_BDT[key]) # append the MC dataframe to the list containing all MC features\n", "X = np.concatenate(all_MC) # concatenate the list of MC dataframes into a single 2D array of features, called X\n", "\n", "all_y = [] # define empty list that will contain labels whether an event in signal or background\n", "for key in data: # loop over the different keys in the dictionary of dataframes\n", " if key!=r'$H \\rightarrow ZZ \\rightarrow \\ell\\ell\\ell\\ell$' and key!='data': # only background MC should pass this\n", " all_y.append(np.zeros(data_for_BDT[key].shape[0])) # background events are labelled with 0\n", "all_y.append(np.ones(data_for_BDT[r'$H \\rightarrow ZZ \\rightarrow \\ell\\ell\\ell\\ell$'].shape[0])) # signal events are labelled with 1\n", "y = np.concatenate(all_y) # concatenate the list of lables into a single 1D array of labels, called y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### The Training and Testing split\n", "One of the first things to do is split your data into a training and testing set. This will split your data into train-test sets: 67%-33%. It will also shuffle entries so you will not get the first 67% of X for training and the last 33% for testing. This is particularly important in cases where you load all signal events first and then the background events.\n", "\n", "Here we split our data into two independent samples. The split is to create a training and testing set. The first will be used for training the classifier and the second to evaluate its performance.\n", "\n", "We don't want to test on events that we used to train on, this prevents overfitting to some subset of data so the network would be good for the test data but much worse at any *new* data it sees." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "from sklearn.model_selection import train_test_split\n", "\n", "# make train and test sets\n", "X_train,X_test, y_train,y_test = train_test_split(X, y, \n", " test_size=0.33, \n", " random_state=492 )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Training Decision Trees\n", "We'll use SciKit Learn (sklearn) in this tutorial. Other possible tools include keras and pytorch. \n", "\n", "Here we set several hyper-parameters to non default values.\n", "\n", "After instantiating our AdaBoostClassifier, call the fit() method with the training sample as an argument. This will train the tree, now we are ready to evaluate the performance on the held out testing set." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Time taken to fit BDT: 0.4s\n", "AdaBoostClassifier(algorithm='SAMME',\n", " estimator=DecisionTreeClassifier(max_depth=2),\n", " learning_rate=0.5, n_estimators=12)\n" ] } ], "source": [ "from sklearn.tree import DecisionTreeClassifier\n", "from sklearn.ensemble import AdaBoostClassifier\n", "\n", "dt = DecisionTreeClassifier(max_depth=2) # maximum depth of the tree\n", "bdt = AdaBoostClassifier(dt,\n", " algorithm='SAMME', # SAMME discrete boosting algorithm\n", " n_estimators=12, # max number of estimators at which boosting is terminated\n", " learning_rate=0.5) # shrinks the contribution of each classifier by learning_rate\n", "\n", "start = time.time() # time at start of BDT fit\n", "bdt.fit(X_train, y_train) # fit BDT to training set\n", "elapsed = time.time() - start # time after fitting BDT\n", "print(\"Time taken to fit BDT: \"+str(round(elapsed,1))+\"s\") # print total time taken to fit BDT\n", "print(bdt)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The fit() method returns the trained classifier. When printed out all the hyper-parameters are listed." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Assessing a Classifier's Performance\n", "Next let's create a quick report on how well our classifier is doing. It is important to make sure you use samples not seen by the classifier to get an unbiased estimate of its performance." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " precision recall f1-score support\n", "\n", " background 0.85 0.91 0.88 5194\n", " signal 0.63 0.48 0.55 1598\n", "\n", " accuracy 0.81 6792\n", " macro avg 0.74 0.70 0.71 6792\n", "weighted avg 0.80 0.81 0.80 6792\n", "\n", "Area under ROC curve for test data: 0.8495\n" ] } ], "source": [ "from sklearn.metrics import classification_report, roc_auc_score\n", "y_predicted = bdt.predict(X_test) # get predicted y for test set\n", "print (classification_report(y_test, y_predicted,\n", " target_names=[\"background\", \"signal\"]))\n", "print (\"Area under ROC curve for test data: %.4f\"%(roc_auc_score(y_test,\n", " bdt.decision_function(X_test))) )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To illustrate that point, here's the same performance metrics evaluated on the training set instead. The estimates of the performance are more optimistic than on an unseen set of events." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " precision recall f1-score support\n", "\n", " background 0.85 0.92 0.88 10546\n", " signal 0.64 0.49 0.56 3243\n", "\n", " accuracy 0.82 13789\n", " macro avg 0.75 0.70 0.72 13789\n", "weighted avg 0.80 0.82 0.81 13789\n", "\n", "Area under ROC curve for training data: 0.8563\n" ] } ], "source": [ "y_predicted = bdt.predict(X_train) # get predicted y for train set\n", "print (classification_report(y_train, y_predicted,\n", " target_names=[\"background\", \"signal\"]))\n", "print (\"Area under ROC curve for training data: %.4f\"%(roc_auc_score(y_train,\n", " bdt.decision_function(X_train))))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Receiver Operarting Characteristic (ROC) curve for BDT\n", "Another useful plot to judge the performance of a classifier is to look at the ROC curve directly." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# we first plot the Neural Network output\n", "signal_decisions = bdt.decision_function(X[y>0.5]).ravel() # get probabilities on signal\n", "background_decisions = bdt.decision_function(X[y<0.5]).ravel() # get decisions on background\n", "\n", "plt.hist(background_decisions, color='red', label='background', \n", " histtype='step', # lineplot that's unfilled\n", " density=True ) # normalize to form a probability density\n", "plt.hist(signal_decisions, color='blue', label='signal', \n", " histtype='step', # lineplot that's unfilled\n", " density=True, # normalize to form a probability density\n", " linestyle='--' ) # dashed line\n", "plt.xlabel('BDT output') # add x-axis label\n", "plt.ylabel('Arbitrary units') # add y-axis label\n", "plt.legend() # add legend\n", "\n", "\n", "# we then plot the ROC\n", "plt.figure() # make new figure \n", "\n", "from sklearn.metrics import roc_curve, auc\n", "\n", "decisions = bdt.decision_function(X_test).ravel() # get probabilities on test set\n", "\n", "# Compute ROC curve and area under the curve\n", "fpr, tpr, _ = roc_curve(y_test, # actual\n", " decisions ) # predicted\n", "\n", "# Compute area under the curve for training set\n", "roc_auc = auc(fpr, # false positive rate \n", " tpr) # true positive rate\n", "\n", "plt.plot(fpr, tpr, label='ROC (area = %0.2f)'%(roc_auc)) # plot test ROC curve\n", "plt.plot([0, 1], # x from 0 to 1\n", " [0, 1], # y from 0 to 1\n", " '--', # dashed line\n", " color='grey', label='Luck')\n", "\n", "plt.xlabel('False Positive Rate') # x-axis label\n", "plt.ylabel('True Positive Rate') # y-axis label\n", "plt.title('Receiver operating characteristic (ROC) curve') # title\n", "plt.legend() # add legend\n", "plt.grid() # add grid" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Sliding the cut threshold in Neural Network output (upper plot) from right to left builds up the ROC curve (lower plot) from bottom to top." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### BDT Overtraining Check\n", "Comparing the BDT's output distribution for the training and testing set is a popular way in HEP to check for overtraining. The compare_train_test() method will plot the shape of the BDT's decision function for each class, as well as overlaying it with the decision function in the training set.\n", "\n", "There are techniques to prevent overtraining." ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "def compare_train_test(clf, X_train, y_train, X_test, y_test):\n", " decisions = [] # list to hold decisions of classifier\n", " for X,y in ((X_train, y_train), (X_test, y_test)): # train and test\n", " d1 = clf.decision_function(X[y<0.5]).ravel() # background\n", " d2 = clf.decision_function(X[y>0.5]).ravel() # signal\n", " decisions += [d1, d2] # add to list of classifier decision\n", " \n", " highest_decision = max(np.max(d) for d in decisions) # get maximum score\n", " bin_edges = [] # list to hold bin edges\n", " bin_edge = -1.1 # start counter for bin_edges\n", " while bin_edge < highest_decision: # up to highest score\n", " bin_edge += 0.1 # increment\n", " bin_edges.append(bin_edge)\n", " \n", " plt.hist(decisions[0], # background in train set\n", " bins=bin_edges, # lower and upper range of the bins\n", " density=True, # area under the histogram will sum to 1\n", " histtype='stepfilled', # lineplot that's filled\n", " color='red', label='B (train)', # Background (train)\n", " alpha=0.5 ) # half transparency\n", " plt.hist(decisions[1], # background in train set\n", " bins=bin_edges, # lower and upper range of the bins\n", " density=True, # area under the histogram will sum to 1\n", " histtype='stepfilled', # lineplot that's filled\n", " color='blue', label='S (train)', # Signal (train)\n", " alpha=0.5 ) # half transparency\n", "\n", " hist_background, bin_edges = np.histogram(decisions[2], # background test\n", " bins=bin_edges, # number of bins in function definition\n", " density=True ) # area under the histogram will sum to 1\n", " \n", " scale = len(decisions[2]) / sum(hist_background) # between raw and normalised\n", " err_background = np.sqrt(hist_background * scale) / scale # error on test background\n", "\n", " width = 0.1 # histogram bin width\n", " center = (bin_edges[:-1] + bin_edges[1:]) / 2 # bin centres\n", " \n", " plt.errorbar(x=center, y=hist_background, yerr=err_background, fmt='o', # circles\n", " c='red', label='B (test)' ) # Background (test)\n", " \n", " hist_signal, bin_edges = np.histogram(decisions[3], # siganl test\n", " bins=bin_edges, # number of bins in function definition\n", " density=True ) # area under the histogram will sum to 1\n", " scale = len(decisions[3]) / sum(hist_signal) # between raw and normalised\n", " err_signal = np.sqrt(hist_signal * scale) / scale # error on test background\n", " \n", " plt.errorbar(x=center, y=hist_signal, yerr=err_signal, fmt='o', # circles\n", " c='blue', label='S (test)' ) # Signal (test)\n", " \n", " plt.xlabel(\"BDT output\") # write x-axis label\n", " plt.ylabel(\"Arbitrary units\") # write y-axis label\n", " plt.legend() # add legend\n", " \n", "compare_train_test(bdt, X_train, y_train, X_test, y_test) # call compare_train_test" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### BDT Optimisation\n", "\n", "Here we get the BDT's decision function for every event that was processed at the begininning (so could be data, signal, background...). The higher the decision function, the more the BDT thinks that event looks like signal." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([-1.90525443, 0.22947967, -2. , ..., -0.11803786,\n", " -1.12847715, 0.22947967])" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y_predicted = bdt.decision_function(X)\n", "y_predicted" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this cell we save the BDT output to our dataframes." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0 -1.905254\n", "1 0.229480\n", "2 -2.000000\n", "3 -0.118038\n", "4 -2.000000\n", " ... \n", "15735 0.229480\n", "15736 -1.329311\n", "15737 -1.475995\n", "15738 -1.799166\n", "15739 -0.118038\n", "Name: BDT_output, Length: 15740, dtype: float64\n", "0 0.229480\n", "1 0.229480\n", "2 -0.118038\n", "3 -0.118038\n", "4 -1.475995\n", " ... \n", "4836 -0.118038\n", "4837 -1.905254\n", "4838 -0.118038\n", "4839 -1.128477\n", "4840 0.229480\n", "Name: BDT_output, Length: 4841, dtype: float64\n" ] } ], "source": [ "cumulative_events = 0 # start counter for total number of events for which output is saved\n", "for key in data: # loop over samples\n", " data[key]['BDT_output'] = y_predicted[cumulative_events:cumulative_events+len(data[key])]\n", " cumulative_events += len(data[key]) # increment counter for total number of events\n", " print(data[key]['BDT_output']) # print the dataframe column BDT_output" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here we define parameters to plot the BDT output" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "BDT_output = { # dictionary containing plotting parameters for the mllll histogram\n", " # change plotting parameters\n", " 'bin_width':0.1, # width of each histogram bin\n", " 'num_bins':14, # number of histogram bins\n", " 'xrange_min':-1, # minimum on x-axis\n", " 'xlabel':'BDT output', # x-axis label\n", "}\n", "\n", "SoverB_hist_dict = {'BDT_output':BDT_output}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here we call the function defined above to to illustrate the optimum cut value on BDT output, based on signal to background ratio." ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_SoverB(data)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Putting everything into a BDT means we only have 1 variable to optimise. The signal and background distributions are separated much better when looking at BDT output, compared to individual variables. Cutting on BDT output also achieves much higher S/B values than on individual variables.\n", "\n", "BDTs can achieve better S/B ratios because they find correlations in many dimensions that will give better signal/background classification.\n", "\n", "Hopefully you've enjoyed this discussion on optimising for signal to background ratio, and in particular how a BDT can be used to facilitate this." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Going further\n", "\n", "If you want to go further, there are a number of things you could try: \n", "* Increase the fraction of events that are processed in '[Lumi, fraction, file path](#fraction)'.\n", "* Add in the other H->ZZ signal samples in '[Samples](#samples)'. You can copy them from [HZZAnalysis.ipynb](https://github.com/atlas-outreach-data-tools/notebooks-collection-opendata/blob/master/13-TeV-examples/uproot_python/HZZAnalysis.ipynb). Try adding them one at a time first, then see how things look with all added.\n", "* Add in the Z and ttbar backgrounds samples in '[Samples](#samples)'. You can copy them from [HZZAnalysis.ipynb](https://github.com/atlas-outreach-data-tools/notebooks-collection-opendata/blob/master/13-TeV-examples/uproot_python/HZZAnalysis.ipynb). Try adding them separately first, then see how things look with both added.\n", "* Add some more variables into the in '[Boosted Decision Tree (BDT)](#BDT)'. Add them in one at a time, rather than all at once, because adding a variable could decrease BDT performance, due to anti-correlation. For some ideas of variables, you can look at the paper for the [discovery of the Higgs boson by ATLAS](https://www.sciencedirect.com/science/article/pii/S037026931200857X) (mostly Section 4 and 4.1).\n", "* Add in real data in '[Samples](#samples)' and see whether the BDT output distributions in data and simulation match. You can copy data from [HZZAnalysis.ipynb](https://github.com/atlas-outreach-data-tools/notebooks-collection-opendata/blob/master/13-TeV-examples/uproot_python/HZZAnalysis.ipynb). \n", "* Modify some BDT hyper-parameters in '[Training Decision Trees](#training)'.\n", "\n", "With each change, keep an eye on the:\n", "* total area under the ROC curve, \n", "* separation between signal and background in the BDT output distribution\n", "* S/B scores that can be achieved\n", "\n", "Notice that we've trained and tested our BDT on simulated data. We would then *apply* it to real experimental data. Once you're happy with your BDT, you may want to put it back into a full analysis to run over all data." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Back to contents](#contents)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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": 4 }