From 678a694cf4f8373c471e2344c65e388b78a6f7b5 Mon Sep 17 00:00:00 2001 From: spiccinelli Date: Tue, 19 Jan 2021 16:07:36 +0100 Subject: [PATCH] Project Release --- Project_Group6.ipynb | 2676 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2676 insertions(+) create mode 100644 Project_Group6.ipynb diff --git a/Project_Group6.ipynb b/Project_Group6.ipynb new file mode 100644 index 0000000..e7ab180 --- /dev/null +++ b/Project_Group6.ipynb @@ -0,0 +1,2676 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Implementation and optimization of the mean-timer technique in drift tube detectors" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alessandro Marcomini (2024286), Andrea Scanu (2022460), Samuele Piccinelli (2027650), Cristina Venturini (2022461) - `GROUP 6`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Outline
\n", + "\n", + "The project is organized as following:\n", + "\n", + "1. INTRODUCTION\n", + "2. PREPARING THE DATA\n", + "3. FINDING EVENTS\n", + "4. VISUALISING THE EVENTS\n", + "5. CONCLUSION\n", + "6. APPENDIX: CODE OPTIMIZATION" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Importing useful libraries: " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import colors, patches\n", + "from matplotlib.lines import Line2D\n", + "from os import listdir\n", + "from os.path import isfile, join\n", + "from numba import vectorize, int64, int32\n", + "import time\n", + "from tqdm.notebook import tqdm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Introduction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The project consists in analyzing data coming from a series of 4 particle detectors, with the goal of reconstructing the trajectory of the particle passing through them.
\n", + "Each detector is composed of 4 layers of 16 cells, with a particular numeration, as shown in the figure. Each cell measures the time of the electronic signal released at the passage of a charged particle: the particle ionizes and the produced electrons drift at constant velocity towards the anodic wire at the center of the cell.
\n", + "The final goal is to precisely assess the exact position where a particle has traversed a given cell; combining the information of consecutive cells it is then possible to deduce the trajectory of the particle.\n", + "Under the assumption of constant drift velocity within the entire cell, the time taken by the ionization to reach the anodic wire (drift time) is proportional to the distance:\n", + "\n", + "$$\n", + "x = v_d (t_{abs} - t_0)\n", + "$$\n", + "\n", + "where $v_d$ is the constant drift velocity, $t$ is the *absolute* time recorded by the electronics (i.e. the data we have) and $t_0$ is a time pedestal - which we need to determine - corresponding to the time where the particle crosses the detector (the drift time is $t-t_0$).
\n", + "To determine $t_0$ we exploit the fact that the layers are staggered by exactly half a cell: as said in the [NOTE2007_034.pdf](https://core.ac.uk/download/pdf/44189221.pdf) this allows to use a set of equations (different cases based on which layer was the hit recorded on) to spot the passage of a particle. One of these equations is as follows:
\n", + "\n", + "$$\n", + "T_{Max} = \\frac{t'_1+t'_3}{2}+t'_2\n", + "$$ \n", + "\n", + "where $t'_1$, $t'_2$, $t'_3$ are the drift times of those three cells and $T_{Max}$ is the maximum drift time, a known constant quantity: $T_{Max} = \\frac{L}{2 v_d} = 390$ ns ($L=42$ mm is the lenght of the cell).
\n", + "From the equation above, knowing $t_1$, $t_2$, $t_3$, in the case of cells like in the picture, one can extract the value of the time pedestal ($t_0$), thus the drift times in each cell, and thus the position of the hit within the cell (although with the left-right ambiguity).
\n", + "In the case of different patterns of cells, there's a list of equations regarding each specific case always in `NOTE2007_034.pdf`.
\n", + "
\n", + "As for the data structure, it was a csv file with 6 columns: `HEAD` (useless for our analysis), `FPGA` (0 or 1), `TDC_CHANNEL` (1-128 and 137, 138, 139), `ORBIT_CNT`, `BX_COUNTER`, `TDC_MEAS` (these three containing the time information).
\n", + "`FPGA` and `TDC_CHANNEL` map the four detectors as:
\n", + "
\n", + "Detector 1 $\\rightarrow$ `FPGA` = 0, `TDC_CHANNEL` (1-64)
\n", + "Detector 2 $\\rightarrow$ `FPGA` = 0, `TDC_CHANNEL` (65-128)
\n", + "Detector 3 $\\rightarrow$ `FPGA` = 1, `TDC_CHANNEL` (1-64)
\n", + "Detector 4 $\\rightarrow$ `FPGA` = 1, `TDC_CHANNEL` (65-128)
\n", + "
\n", + "\n", + "Since it is stated that the physics run is mainly composed of background events and that events with detector noise are to be discarded, we decided to concentrate on the calibration runs, where most of the hits can be associated to the actual track of a particle." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Preparing the data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The data are encoded in a CSV file and the analysis was performed on a calibration run in which most of the hits can be associated to a particle's track.\n", + "\n", + "This is code to import the data, in particular to concatenate the multiple files present in the `Run000260` folder and create a Pandas dataframe. Due to the long compile time a restricted version of the dataset was considered.
\n", + "The first 10 hits in the raw data are presented below." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "'''\n", + "path = \"Group6\"\n", + "files = [join(path, f) for f in listdir(path) if isfile(join(path, f))]\n", + "# concatenate the files and load the data\n", + "data = pd.concat([pd.read_csv(file) for file in files], axis = 0)\n", + "data.reset_index(inplace=True, drop=True)\n", + "display(data.head(10))\n", + "'''" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "file_name = \"Run000260/data_000000.txt\"\n", + "data = pd.DataFrame(pd.read_csv(file_name), columns=[\"HEAD\",\"FPGA\",\"TDC_CHANNEL\",\"ORBIT_CNT\",\"BX_COUNTER\",\"TDC_MEAS\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We subsequently drop the `HEAD` column, since it's useless, and we also drop the rows containing the trigger information, since the technique later used to identify the events doesn't use it.
\n", + "\n", + "As for our understanding of the assignement, the trigger information was to be neglected, since the data were acquired using an acquisition system which read the detectors' sensors at $40$ MHz (every $25$ ns) without the need for an external trigger.
\n", + "Also, we dropped all the rows containing a `TDC_CHANNEL` above 128." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEAS
0111618974148841533.024.0
117118974148871650.021.0
21671897414914980.08.0
317018974149221287.08.0
405718974149222162.022.0
\n", + "
" + ], + "text/plain": [ + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS\n", + "0 1 116 1897414884 1533.0 24.0\n", + "1 1 71 1897414887 1650.0 21.0\n", + "2 1 67 1897414914 980.0 8.0\n", + "3 1 70 1897414922 1287.0 8.0\n", + "4 0 57 1897414922 2162.0 22.0" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data = data.drop(columns = ['HEAD'])\n", + "indexNames = data[(data['TDC_CHANNEL'] >= 137) & (data['TDC_CHANNEL'] <= 139)].index\n", + "data.drop(indexNames, inplace=True)\n", + "data.drop(data[(data['TDC_CHANNEL'] > 128)].index, inplace=True)\n", + "display(data.head())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.1 Adding new columns" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we compute the *absolute* time for each row of the dataframe, converting the information given in `TDC_MEAS` and `BX_COUNTER` in ns, and storing it in a new column, called `Absolute`. We also sort the values in the dataframe by the absolute time value.
\n", + "We don't consider the information given by the `ORBIT_CNT` since to identify events we are going to restrict ourselves to finding one event in one orbit, as will be explained later." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEASAbsolute
36441919219187341900.00.00.000000
77501711319197262640.00.00.000000
1184557011819206894890.00.00.000000
3416805318975593260.01.00.833333
11536751819205636210.01.00.833333
\n", + "
" + ], + "text/plain": [ + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS Absolute\n", + "364419 1 92 1918734190 0.0 0.0 0.000000\n", + "775017 1 13 1919726264 0.0 0.0 0.000000\n", + "1184557 0 118 1920689489 0.0 0.0 0.000000\n", + "34168 0 53 1897559326 0.0 1.0 0.833333\n", + "1153675 1 8 1920563621 0.0 1.0 0.833333" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "absolute_time = data[\"BX_COUNTER\"]*25 + data[\"TDC_MEAS\"]*25/30\n", + "data[\"Absolute\"] = pd.Series(absolute_time, index = data.index)\n", + "data = data.sort_values(by=\"Absolute\")\n", + "display(data.head())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We then define three functions, `chamber()`, `layer()`, `cell()`, that add a column each to the original dataframe with information regarding the chamber (detector), layer and cell the hit was recorded on.\n", + "\n", + "Those functions were initially built with a if statement which made the code cumbersome. We managed to enhance the performance thanks to a `@vectorize` decorator." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "@vectorize([int64(int64,int64)], nopython=True)\n", + "def chamber(fpga, tdc):\n", + " return (tdc // 64 + 1) + 2*fpga\n", + "\n", + "@vectorize([int64(int64)], nopython=True)\n", + "def layer(tdc):\n", + " index = {0:1, 2:2, 3:3, 1:4}\n", + " key = tdc % 64 % 4\n", + " return index[key]\n", + "\n", + "@vectorize([int64(int64)], nopython=True)\n", + "def cell(tdc):\n", + " return tdc % 64" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEASAbsoluteChamberLayerCell
36441919219187341900.00.00.0000004128
77501711319197262640.00.00.0000003413
1184557011819206894890.00.00.0000002254
3416805318975593260.01.00.8333331453
11536751819205636210.01.00.833333318
\n", + "
" + ], + "text/plain": [ + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS Absolute \\\n", + "364419 1 92 1918734190 0.0 0.0 0.000000 \n", + "775017 1 13 1919726264 0.0 0.0 0.000000 \n", + "1184557 0 118 1920689489 0.0 0.0 0.000000 \n", + "34168 0 53 1897559326 0.0 1.0 0.833333 \n", + "1153675 1 8 1920563621 0.0 1.0 0.833333 \n", + "\n", + " Chamber Layer Cell \n", + "364419 4 1 28 \n", + "775017 3 4 13 \n", + "1184557 2 2 54 \n", + "34168 1 4 53 \n", + "1153675 3 1 8 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data['Chamber'] = chamber(data['FPGA'].values, data['TDC_CHANNEL'].values)\n", + "data['Layer'] = layer(data['TDC_CHANNEL'].values)\n", + "data['Cell'] = cell(data['TDC_CHANNEL'].values)\n", + "display(data.head())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we drop some other rows of the dataframe that are not relevant for the analysis: if a specific `ORBIT_CNT` value presents itself less than 3 times it is impossible that that specific orbit contains an event, since we consider only orbits with 3 or 4 hits to call an event." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def filter_by_freq(df, column, min_freq):\n", + " freq = df[column].value_counts()\n", + " frequent_values = freq[freq >= min_freq].index\n", + " return df[df[column].isin(frequent_values)]\n", + "\n", + "\n", + "data = filter_by_freq(data,\"ORBIT_CNT\",3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We add an empty column `Event`; we divide the data in 4 different dataframes containing the hits of a single detector, which will be later needed for the analysis." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "data[\"Event\"] = 0\n", + "Tmax = 390. # some useful constants\n", + "L2 = 21.\n", + "\n", + "detector1 = data[(data['Chamber'] == 1)]\n", + "detector2 = data[(data['Chamber'] == 2)]\n", + "detector3 = data[(data['Chamber'] == 3)]\n", + "detector4 = data[(data['Chamber'] == 4)]\n", + "\n", + "detectors = [detector1, detector2, detector3, detector4]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We then plot two histograms, one for each `FPGA`, with the number of hits for each `TDC_CHANNEL`:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "detector12 = data[(data['FPGA'] == 0)]\n", + "detector34 = data[(data['FPGA'] == 1)]\n", + "\n", + "plt.clf()\n", + "fig, axes = plt.subplots(nrows=1, ncols=2, tight_layout=False, figsize=(15, 6), sharey=False)\n", + "fig.subplots_adjust(wspace=0.1)\n", + "ax0, ax1 = axes.flatten()\n", + "data0, bins, __ = ax0.hist(detector12[\"TDC_CHANNEL\"].values, bins=np.arange(1,129,1), range=(detector12[\"TDC_CHANNEL\"].min(), detector12[\"TDC_CHANNEL\"].max()), histtype='step', color=\"black\")\n", + "ax0.set_xlabel(r\"FPGA 0\", size=15)\n", + "ax0.set_ylabel(r\"Counts/bin\", size=15)\n", + "data1, bins, __ = ax1.hist(detector34[\"TDC_CHANNEL\"].values, bins=np.arange(1,129,1), range=(detector34[\"TDC_CHANNEL\"].min(), detector34[\"TDC_CHANNEL\"].max()), histtype='step', color=\"red\")\n", + "ax1.set_xlabel(r\"FPGA 1\", size=15)\n", + "fig.suptitle(r\"Histograms of hits per TDC CHANNEL\", size=15)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From the graphs above one can see that some channels have significantly less counts than others: this can be due to a difference in performance between the cells." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Finding events" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once we have prepared the data, we move on to actually solving the problem and finding the events. To do so, we make some assumptions as to what happens in a detector and about the data we have.
\n", + "First of all, since the rate of passage of particles through the detector is rather limited, i.e. the chance to get two particle within the same orbit is extremely small, we assume that we can find no more than one event for each orbit.
\n", + "\n", + "As for what we consider an event, we take into account only layers and orbits with 3 or 4 hits that are roughly aligned. By that we mean that the track of the particle crosses a semi-column of cells, i.e. the interested wires are at the same position for each couple of staggered cells. Given the small thickness of the layers and the muon velocity (which is much higher than the drift velocity of the electrons), the time pedestal $t_0$ of an event is assumed to be equal for all cells.
\n", + "In the figure we highlighted an example of the cells interested in the search of an event.
\n", + "\n", + "An event is identified by the number of the layer of the cells the hit was recorded on: we consider events of all types, e.g. 1234, 123, 124, 134, 234." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.1 Identifying events (L/R ambiguity unresolved)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this part we identify the events by iterating on each detector and each orbit: the goal of the algorithm is to assign a common tag to rows belonging to the same event. In this way it will be easier to access all information a specific event. \n", + "\n", + "For each orbit we look for a couple of staggered cells: the program first identifies a cell $n$ in the first layer in which a hit occurred and checks if in the $n-1$ cell, which belongs to the third layer, there's an event happening at a distance in time less than $T_{max}$, a necessary condition to register an event.
\n", + "If this condition is verified it looks for the third and fourth component of the event in the 4 cells which we have marked as compatible, according to the request of having an almost vertical track.
\n", + "To avoid the degenerate cases of 4 hits with only two staggered cells (the ones from first and third layer) and the remaining ones not correctly aligned, a condition based on the sum of the cells labels has been implemented.
\n", + "Analogously the process is executed starting from cells of the second layer: this allows us to also find events with a couple of staggered cells in layers 2 and 4 (e.g. an event of type 124, not found with the previous code)." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def find_events(detec, n_ev):\n", + " ORBs = detec['ORBIT_CNT'].sort_values().drop_duplicates()\n", + " df_events = pd.DataFrame(index = [], columns = data.columns) # create an empy dataframe to save the events\n", + "\n", + " for cnt in tqdm(ORBs):\n", + " df = detec[detec.ORBIT_CNT == cnt]\n", + " idx_l1 = df.index[df[\"Layer\"] == 1]\n", + " idx_l2 = df.index[df[\"Layer\"] == 2]\n", + "\n", + " for i in idx_l1: # iterate on first layer cells\n", + " cell1 = df.at[i,'Cell']\n", + " for j in df.index[df[\"Cell\"] == cell1 - 1]:\n", + " if np.abs(df.at[i,'Absolute'] - df.at[j,'Absolute']) < Tmax: # look for compatible signal in staggered cells\n", + " n_ev += 1\n", + " df.at[i, \"Event\"] = n_ev # assign event tag\n", + " df.at[j, \"Event\"] = n_ev\n", + " Tmean = (df.at[i,'Absolute'] + df.at[j,'Absolute'])/2\n", + " compatible_k = df.index[df[\"Cell\"] == cell1 - 2].append(df.index[df[\"Cell\"] == cell1 - 6]).append(df.index[df[\"Cell\"] == cell1 - 3]).append(df.index[df[\"Cell\"] == cell1 - 7])\n", + " for k in compatible_k:\n", + " if (np.abs(df.at[k,'Absolute'] - Tmean) < Tmax) : df.at[k, \"Event\"] = n_ev\n", + "\n", + " for i in idx_l2: # iterate on second layer cells\n", + " if df.at[i, 'Event'] == 0:\n", + " cell2 = df.at[i,'Cell']\n", + " for j in df.index[df[\"Cell\"] == cell2 - 1]:\n", + " if np.abs(df.at[i,'Absolute'] - df.at[j,'Absolute']) < Tmax and df.at[j,'Event'] == 0:\n", + " n_ev += 1\n", + " df.at[i, \"Event\"] = n_ev\n", + " df.at[j, \"Event\"] = n_ev\n", + " Tmean = (df.at[i,'Absolute'] + df.at[j,'Absolute'])/2\n", + " compatible_k = df.index[df[\"Cell\"] == cell2 + 1].append(df.index[df[\"Cell\"] == cell2 + 5]).append(df.index[df[\"Cell\"] == cell2 + 2]).append(df.index[df[\"Cell\"] == cell2 + 6])\n", + " for k in compatible_k:\n", + " if (np.abs(df.at[k,'Absolute'] - Tmean) < Tmax) : df.at[k, \"Event\"] = n_ev\n", + "\n", + " sizes = df.sort_values(by=\"Event\").groupby(\"Event\").size()\n", + " cellnum = df.sort_values(by=\"Event\").groupby(\"Event\")[\"Cell\"].sum()\n", + " # filter only events with 3 or 4 hits and aligned events\n", + " check = [((s == 3) or (s == 4 and c % 8 != 6)) for s, c in zip(sizes, cellnum)]\n", + " check[0] = False\n", + " events = df[\"Event\"].sort_values().drop_duplicates()[check] \n", + " for e in events: df_events = df_events.append(df[df[\"Event\"] == e].sort_values(by=\"Layer\"))\n", + " return df_events, n_ev" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "aebe204766f34b20b06ef59d4dcec8dd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=39192.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "46f4e06a4d9646a0bfc105a508dd2f78", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=34996.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0947ccb3e8e74e738088b7a697052517", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=62066.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "25087283b7d540469bccdd354c24c345", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=58516.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "n_ev = 0\n", + "DF_EVENTS = pd.DataFrame(index = [], columns = data.columns)\n", + "\n", + "for detec in detectors: # iterate on every detector\n", + " df_events, n_ev = find_events(detec, n_ev)\n", + " DF_EVENTS = DF_EVENTS.append(df_events)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total number of events: 33900\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEASAbsoluteChamberLayerCellEvent
76102018974185832539.017.063489.16666711202
75701918974185832528.016.063213.33333313192
75801718974185832537.09.063432.50000014172
13070481897421321195.06.04880.00000011489
13060471897421321190.07.04755.83333313479
13100451897421321202.00.05050.00000014459
197104818974251081167.06.029180.000000114813
196804618974251081166.019.029165.833333124613
197704518974251081166.018.029165.000000144513
20590201897425590120.019.03015.833333112014
20560181897425590108.013.02710.833333121814
20550171897425590111.018.02790.000000141714
214704218974260201100.019.027515.833333124216
215104318974260201111.011.027784.166667134316
215004118974260201111.01.027775.833333144116
242402818974274811468.022.036718.333333112820
242102618974274811467.015.036687.500000122620
242502518974274811474.016.036863.333333142520
252405818974280387.02.0176.666667125821
2525059189742803814.019.0365.833333135921
2528057189742803819.09.0482.500000145721
26330418974286163304.09.082607.50000011422
26300218974286163298.026.082471.66666712222
26290318974286163293.06.082330.00000013322
272702418974291752968.028.074223.333333112423
272602318974291752958.020.073966.666667132323
273002118974291752969.04.074228.333333142123
292304418974303821576.010.039408.333333114425
291904318974303821567.016.039188.333333134325
292204118974303821578.011.039459.166667144125
\n", + "
" + ], + "text/plain": [ + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS Absolute Chamber \\\n", + "761 0 20 1897418583 2539.0 17.0 63489.166667 1 \n", + "757 0 19 1897418583 2528.0 16.0 63213.333333 1 \n", + "758 0 17 1897418583 2537.0 9.0 63432.500000 1 \n", + "1307 0 48 1897421321 195.0 6.0 4880.000000 1 \n", + "1306 0 47 1897421321 190.0 7.0 4755.833333 1 \n", + "1310 0 45 1897421321 202.0 0.0 5050.000000 1 \n", + "1971 0 48 1897425108 1167.0 6.0 29180.000000 1 \n", + "1968 0 46 1897425108 1166.0 19.0 29165.833333 1 \n", + "1977 0 45 1897425108 1166.0 18.0 29165.000000 1 \n", + "2059 0 20 1897425590 120.0 19.0 3015.833333 1 \n", + "2056 0 18 1897425590 108.0 13.0 2710.833333 1 \n", + "2055 0 17 1897425590 111.0 18.0 2790.000000 1 \n", + "2147 0 42 1897426020 1100.0 19.0 27515.833333 1 \n", + "2151 0 43 1897426020 1111.0 11.0 27784.166667 1 \n", + "2150 0 41 1897426020 1111.0 1.0 27775.833333 1 \n", + "2424 0 28 1897427481 1468.0 22.0 36718.333333 1 \n", + "2421 0 26 1897427481 1467.0 15.0 36687.500000 1 \n", + "2425 0 25 1897427481 1474.0 16.0 36863.333333 1 \n", + "2524 0 58 1897428038 7.0 2.0 176.666667 1 \n", + "2525 0 59 1897428038 14.0 19.0 365.833333 1 \n", + "2528 0 57 1897428038 19.0 9.0 482.500000 1 \n", + "2633 0 4 1897428616 3304.0 9.0 82607.500000 1 \n", + "2630 0 2 1897428616 3298.0 26.0 82471.666667 1 \n", + "2629 0 3 1897428616 3293.0 6.0 82330.000000 1 \n", + "2727 0 24 1897429175 2968.0 28.0 74223.333333 1 \n", + "2726 0 23 1897429175 2958.0 20.0 73966.666667 1 \n", + "2730 0 21 1897429175 2969.0 4.0 74228.333333 1 \n", + "2923 0 44 1897430382 1576.0 10.0 39408.333333 1 \n", + "2919 0 43 1897430382 1567.0 16.0 39188.333333 1 \n", + "2922 0 41 1897430382 1578.0 11.0 39459.166667 1 \n", + "\n", + " Layer Cell Event \n", + "761 1 20 2 \n", + "757 3 19 2 \n", + "758 4 17 2 \n", + "1307 1 48 9 \n", + "1306 3 47 9 \n", + "1310 4 45 9 \n", + "1971 1 48 13 \n", + "1968 2 46 13 \n", + "1977 4 45 13 \n", + "2059 1 20 14 \n", + "2056 2 18 14 \n", + "2055 4 17 14 \n", + "2147 2 42 16 \n", + "2151 3 43 16 \n", + "2150 4 41 16 \n", + "2424 1 28 20 \n", + "2421 2 26 20 \n", + "2425 4 25 20 \n", + "2524 2 58 21 \n", + "2525 3 59 21 \n", + "2528 4 57 21 \n", + "2633 1 4 22 \n", + "2630 2 2 22 \n", + "2629 3 3 22 \n", + "2727 1 24 23 \n", + "2726 3 23 23 \n", + "2730 4 21 23 \n", + "2923 1 44 25 \n", + "2919 3 43 25 \n", + "2922 4 41 25 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"total number of events: \", DF_EVENTS[\"Event\"].nunique())\n", + "display(DF_EVENTS.head(30))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.2 Finding the time pedestal $t_0$ and resolving the L/R ambiguity" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After filtering the dataframe in order to recognize all suitable events, we proceed to determine the time pedestal $t_0$ of each event, given the absolute time of each signal. Following the mean-timer technique and adapting formulas to the case of different layers, we found the following relations for the events when 3 cells are hit (parentheses are referred to interested layers):\n", + "\n", + "$$\n", + "t_0 \\ (1,2,3) = \\frac{t_1 + t_3 + 2t_2}{4} - \\frac{T_{max}}{2}\n", + "$$\n", + "\n", + "$$\n", + "t_0 \\ (1,2,4) = \\frac{3t_2 - t_4 + 2t_1}{4} - \\frac{T_{max}}{2}\n", + "$$\n", + "\n", + "$$\n", + "t_0 \\ (1,3,4) = \\frac{3t_3 - t_1 + 2t_4}{4} - \\frac{T_{max}}{2}\n", + "$$\n", + "\n", + "The case of layers 2,3,4 is equal in form to the one of layers 1,2,3, with proper substitution.
\n", + "The case in which all the four layers are hit presents multiple possible relations which provide various $t_0$ estimations. We think that the assumption made *a priori* that ionization occurs at the same time in all the cells (i.e., the cells involved are hit altogether) better holds for consecutive cells, rather than for ones more distant in space. As a result, we calculate the time pedestal of each subset of consecutive cells (the one belonging to layers 1,2,3 and 2,3,4, respectively) and let $t_0$ be the mean of the returned values:\n", + "\n", + "$$\n", + "t_0 \\ (1,2,3,4) = \\frac{t_0 \\ (1,2,3) + t_0 \\ (2,3,4)}{2} = \n", + " \\frac{t_1 + 3t_2 + 3t_3 + t_4}{8} - \\frac{T_{max}}{2}\n", + "$$\n", + "\n", + "Given $t_0$, it is straightforward to find the drift time of electrons in each cell as $t_{drift} = t_{abs} - t_0$ and assuming a constant drift velocity the spatial coordinate of the pacticles' track can be found by proportion:\n", + "\n", + "$$\n", + "x(t_{drift}) = \\frac{t_{drift}}{T_{max}} \\cdot \\frac{L_{max}}{2} = t_{drift} \\cdot 0.054 \\ \\left( \\frac{mm}{ns} \\right)\n", + "$$\n", + "\n", + "To resolve the Right-Left ambiguity and determine the sign of the angle of incidence $\\alpha$ we take into account all possible cases and select the correct one given the interested cells and the relative position in them." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b525422ddf654ec38ccab79bf92e307e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=33900.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "def Pedestal_123(t1, t2, t3, c1, c2, c3, Tmax = Tmax): # sum = 6\n", + " t0 = (t1 + t3 + 2*t2)/4 - Tmax/2\n", + " if c2 == c1 - 2: a, l = np.sign(t3-t1), ['R','L','R']\n", + " else: a, l = np.sign(t1-t3), ['L','R','L']\n", + " return t0, a, l\n", + "\n", + "def Pedestal_124(t1, t2, t4, c1, c2, c4, Tmax = Tmax): # sum = 7\n", + " t0 = (3*t2 - t4 + 2*t1)/4 - Tmax/2\n", + " if c1 == c2 + 2: a, l = np.sign(t2-t4), ['R','L','L']\n", + " else: a, l = np.sign(t4-t2), ['L','R','R']\n", + " return t0, a, l\n", + "\n", + "def Pedestal_134(t1, t3, t4, c1, c3, c4, Tmax = Tmax): # sum = 8\n", + " t0 = (3*t3 - t1 + 2*t4)/4 - Tmax/2\n", + " if c3 == c4 + 2: a, l = np.sign(t3-t1), ['R','R','L']\n", + " else: a, l = np.sign(t1-t3), ['L','L','R']\n", + " return t0, a, l\n", + "\n", + "def Pedestal_234(t2, t3, t4, c2, c3, c4, Tmax = Tmax): # sum = 9\n", + " t0 = (t2 + t4 + 2*t3)/4 - Tmax/2\n", + " if c3 == c2 + 5: a, l = np.sign(t4-t2), ['R','L','R']\n", + " else: a, l = np.sign(t2-t4), ['L','R','L']\n", + " return t0, a, l\n", + "\n", + "def Pedestal_1234(t1, t2, t3, t4, c1, c2, c3, c4, Tmax = Tmax): \n", + " t01, a01, l01 = Pedestal_123(t1,t2,t3,c1,c2,c3)\n", + " t02, a02, l02 = Pedestal_234(t2,t3,t4,c2,c3,c4)\n", + " l = np.array([l01[0], l01[1], l01[2], l02[2]])\n", + " return np.mean([t01, t02]), np.mean([a01, a02]), l\n", + "\n", + "Ped = { 6: Pedestal_123, # assign proper function for each layer pattern\n", + " 7: Pedestal_124,\n", + " 8: Pedestal_134,\n", + " 9: Pedestal_234}\n", + "\n", + "def Find_pedestal(df):\n", + " if len(df.index) == 3:\n", + " Sum = df[\"Layer\"].sum()\n", + " tx, ty, tz = df[\"Absolute\"]\n", + " c1, c2, c3 = df[\"Cell\"]\n", + " if Sum in np.arange(6,10,1): t0, a, l = Ped[Sum](tx, ty, tz, c1, c2, c3)\n", + " else: t0, a, l = 1e5, 1, [\"e\" , \"e\", \"e\"]\n", + " return t0, a, l\n", + " elif len(df.index) == 4:\n", + " tx, ty, tz, tw = df[\"Absolute\"]\n", + " c1, c2, c3, c4 = df[\"Cell\"]\n", + " t0, a, l = Pedestal_1234(tx, ty, tz, tw, c1, c2, c3, c4)\n", + " if (df[\"Layer\"].sum() == 10): return t0, a, l\n", + " else: return 1e5, 1, [\"e\" for i in range(4)]\n", + " #else: return 1e5, 1, [\"e\" for i in range(len(df.index))]\n", + "\n", + "DF_off = pd.DataFrame(index = [], columns = DF_EVENTS.columns)\n", + "alphas = {1.: '+', -1.: '-', 0.: '?', 0.5: '?', -0.5:'?'} # labels to identify positive/negative incidence angle\n", + "EVs = DF_EVENTS[\"Event\"].sort_values().drop_duplicates() # (unknown sign for vertical events) \n", + "\n", + "for e in tqdm(EVs): # iterate over events\n", + " df = DF_EVENTS[DF_EVENTS[\"Event\"] == e].sort_values(by=\"Layer\")\n", + " t0, a, l = Find_pedestal(df)\n", + " df[\"T_drift\"] = df[\"Absolute\"] - t0 # adds column with drift time\n", + " df[\"X(mm)\"] = df[\"T_drift\"]/Tmax*21 # adds column with position\n", + " df[\"LR\"] = np.array(l) # adds column with L/R tag\n", + " df[\"Alpha\"] = alphas[a] # adds column with alpha angle\n", + " # save events with acceptable drift times\n", + " if ((df[\"T_drift\"] > 0.) & (df[\"T_drift\"] < Tmax)).all(): DF_off = DF_off.append(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total number of events: 28490\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FPGATDC_CHANNELORBIT_CNTBX_COUNTERTDC_MEASAbsoluteChamberLayerCellEventT_driftX(mm)LRAlpha
13070481897421321195.06.04880.00000011489203.12500010.937500R-
13060471897421321190.07.04755.8333331347978.9583334.251603R-
13100451897421321202.00.05050.00000014459373.12500020.091346L-
197104818974251081167.06.029180.000000114813201.87500010.870192R+
196804618974251081166.019.029165.833333124613187.70833310.107372L+
197704518974251081166.018.029165.000000144513186.87500010.062500L+
20590201897425590120.019.03015.833333112014367.29166719.777244R-
20560181897425590108.013.02710.83333312181462.2916673.354167L-
20550171897425590111.018.02790.000000141714141.4583337.616987L-
252405818974280387.02.0176.66666712582123.9583331.290064L-
2525059189742803814.019.0365.833333135921213.12500011.475962R-
2528057189742803819.09.0482.500000145721329.79166717.758013L-
26330418974286163304.09.082607.50000011422332.29166717.892628R-
26300218974286163298.026.082471.66666712222196.45833310.578526L-
26290318974286163293.06.082330.0000001332254.7916672.950321R-
272702418974291752968.028.074223.333333112423385.00000020.730769R-
272602318974291752958.020.073966.666667132323128.3333336.910256R-
273002118974291752969.04.074228.333333142123390.00000021.000000L-
292304418974303821576.010.039408.333333114425334.58333318.016026R-
291904318974303821567.016.039188.333333134325114.5833336.169872R-
292204118974303821578.011.039459.166667144125385.41666720.753205L-
330705818974322182254.011.056359.16666712582838.3333332.064103L-
331105918974322182264.010.056608.333333135928287.50000015.480769R-
331005718974322182259.015.056487.500000145728166.6666678.974359L-
340405618974326773277.027.081947.500000115629386.66666720.820513R-
340005418974326773265.025.081645.83333312542985.0000004.576923L-
340105318974326773272.011.081809.166667145329248.33333313.371795L-
406504818974356331296.020.032416.666667114833339.79166718.296474R-
406404718974356331293.023.032344.166667134733267.29166714.392628R-
406304518974356331289.013.032235.833333144533158.9583338.559295L-
\n", + "
" + ], + "text/plain": [ + " FPGA TDC_CHANNEL ORBIT_CNT BX_COUNTER TDC_MEAS Absolute Chamber \\\n", + "1307 0 48 1897421321 195.0 6.0 4880.000000 1 \n", + "1306 0 47 1897421321 190.0 7.0 4755.833333 1 \n", + "1310 0 45 1897421321 202.0 0.0 5050.000000 1 \n", + "1971 0 48 1897425108 1167.0 6.0 29180.000000 1 \n", + "1968 0 46 1897425108 1166.0 19.0 29165.833333 1 \n", + "1977 0 45 1897425108 1166.0 18.0 29165.000000 1 \n", + "2059 0 20 1897425590 120.0 19.0 3015.833333 1 \n", + "2056 0 18 1897425590 108.0 13.0 2710.833333 1 \n", + "2055 0 17 1897425590 111.0 18.0 2790.000000 1 \n", + "2524 0 58 1897428038 7.0 2.0 176.666667 1 \n", + "2525 0 59 1897428038 14.0 19.0 365.833333 1 \n", + "2528 0 57 1897428038 19.0 9.0 482.500000 1 \n", + "2633 0 4 1897428616 3304.0 9.0 82607.500000 1 \n", + "2630 0 2 1897428616 3298.0 26.0 82471.666667 1 \n", + "2629 0 3 1897428616 3293.0 6.0 82330.000000 1 \n", + "2727 0 24 1897429175 2968.0 28.0 74223.333333 1 \n", + "2726 0 23 1897429175 2958.0 20.0 73966.666667 1 \n", + "2730 0 21 1897429175 2969.0 4.0 74228.333333 1 \n", + "2923 0 44 1897430382 1576.0 10.0 39408.333333 1 \n", + "2919 0 43 1897430382 1567.0 16.0 39188.333333 1 \n", + "2922 0 41 1897430382 1578.0 11.0 39459.166667 1 \n", + "3307 0 58 1897432218 2254.0 11.0 56359.166667 1 \n", + "3311 0 59 1897432218 2264.0 10.0 56608.333333 1 \n", + "3310 0 57 1897432218 2259.0 15.0 56487.500000 1 \n", + "3404 0 56 1897432677 3277.0 27.0 81947.500000 1 \n", + "3400 0 54 1897432677 3265.0 25.0 81645.833333 1 \n", + "3401 0 53 1897432677 3272.0 11.0 81809.166667 1 \n", + "4065 0 48 1897435633 1296.0 20.0 32416.666667 1 \n", + "4064 0 47 1897435633 1293.0 23.0 32344.166667 1 \n", + "4063 0 45 1897435633 1289.0 13.0 32235.833333 1 \n", + "\n", + " Layer Cell Event T_drift X(mm) LR Alpha \n", + "1307 1 48 9 203.125000 10.937500 R - \n", + "1306 3 47 9 78.958333 4.251603 R - \n", + "1310 4 45 9 373.125000 20.091346 L - \n", + "1971 1 48 13 201.875000 10.870192 R + \n", + "1968 2 46 13 187.708333 10.107372 L + \n", + "1977 4 45 13 186.875000 10.062500 L + \n", + "2059 1 20 14 367.291667 19.777244 R - \n", + "2056 2 18 14 62.291667 3.354167 L - \n", + "2055 4 17 14 141.458333 7.616987 L - \n", + "2524 2 58 21 23.958333 1.290064 L - \n", + "2525 3 59 21 213.125000 11.475962 R - \n", + "2528 4 57 21 329.791667 17.758013 L - \n", + "2633 1 4 22 332.291667 17.892628 R - \n", + "2630 2 2 22 196.458333 10.578526 L - \n", + "2629 3 3 22 54.791667 2.950321 R - \n", + "2727 1 24 23 385.000000 20.730769 R - \n", + "2726 3 23 23 128.333333 6.910256 R - \n", + "2730 4 21 23 390.000000 21.000000 L - \n", + "2923 1 44 25 334.583333 18.016026 R - \n", + "2919 3 43 25 114.583333 6.169872 R - \n", + "2922 4 41 25 385.416667 20.753205 L - \n", + "3307 2 58 28 38.333333 2.064103 L - \n", + "3311 3 59 28 287.500000 15.480769 R - \n", + "3310 4 57 28 166.666667 8.974359 L - \n", + "3404 1 56 29 386.666667 20.820513 R - \n", + "3400 2 54 29 85.000000 4.576923 L - \n", + "3401 4 53 29 248.333333 13.371795 L - \n", + "4065 1 48 33 339.791667 18.296474 R - \n", + "4064 3 47 33 267.291667 14.392628 R - \n", + "4063 4 45 33 158.958333 8.559295 L - " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"total number of events: \", DF_off[\"Event\"].nunique())\n", + "display(DF_off.head(30))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.clf()\n", + "fig, ax = plt.subplots(nrows=1, ncols=1, tight_layout=False, figsize=(15, 8))\n", + "sign = {'L':-1, 'R': 1}\n", + "histo = DF_off[\"X(mm)\"].values*np.array([sign[sig] for sig in DF_off[\"LR\"].values])\n", + "data, bins, __ = ax.hist(histo, bins=np.arange(-21,21.5,0.5), range=(-21, 21), histtype='step', color=\"darkred\")\n", + "ax.set_xlabel(r\"$X[mm]$\", size=15)\n", + "ax.set_ylabel(r\"Counts/bin\", size=15)\n", + "ax.set_title(r\"Distribution of the relative positions $X[mm]$ inside a cell\", size=15)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As expected, the histogram of the relative positions recalls a uniform distribution for a cell: less counts are to be found in $0$ - representing an events that *directly* hits the wire - while higher counts can be seen located at both halfs of the semi-cells." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Visualizing the events" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create an array that will be used to visualize the detector chamber:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "d = np.array([[4*i+j for i in range(16)] for j in range(1,5)])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we create a restricted dataframe with only the events we want to visualize. In this specific case we wanted to visualize 4 events of 4 hits and so we used a function that kept only events with such characteristic.
" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "disp_data = DF_off\n", + "d1 = DF_off[(DF_off['Chamber'] == 1)]\n", + "d2 = DF_off[(DF_off['Chamber'] == 2)]\n", + "d3 = DF_off[(DF_off['Chamber'] == 3)]\n", + "d4 = DF_off[(DF_off['Chamber'] == 4)]\n", + "\n", + "event_list1 = [1112,14,34,9,22]\n", + "event_list2 = [34814,34734,34788,34716,34709]\n", + "event_list3 = [69199,69207,69237,69217,69184]\n", + "event_list4 = [148328,148322,148761,148319,148356]\n", + "\n", + "def filter_by_ev(df, column, min_ev):\n", + " freq = df[column].value_counts()\n", + " frequent_values = freq[freq >= min_ev].index\n", + " \n", + " return df[df[column].isin(frequent_values)]\n", + "\n", + "\n", + "def find_event(event_list1, event_list2, event_list3, event_list4):\n", + " d1n = pd.DataFrame(index = [], columns = disp_data.columns)\n", + " for item in event_list1: \n", + " d1n = d1n.append(d1[d1['Event'] == item])\n", + "\n", + " d2n = pd.DataFrame(index = [], columns = disp_data.columns)\n", + " for item in event_list2: \n", + " d2n = d2n.append(d2[d2['Event'] == item])\n", + "\n", + " d3n = pd.DataFrame(index = [], columns = disp_data.columns)\n", + " for item in event_list3: \n", + " d3n = d3n.append(d3[d3['Event'] == item])\n", + "\n", + " d4n = pd.DataFrame(index = [], columns = disp_data.columns)\n", + " for item in event_list4: \n", + " d4n = d4n.append(d4[d4['Event'] == item])\n", + " \n", + " return (d1n, d2n, d3n, d4n)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "d1n, d2n, d3n, d4n = find_event(event_list1, event_list2, event_list3, event_list4)\n", + "det = [d1n, d2n, d3n, d4n]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is code to draw the chamber and to add events in it. The wires are marked in black at the center of the cell, the events are the red dots. The cells in which the hit took place are colored in blue. The chamber is not at scale, the height should be much lower.
\n", + "\n", + "The function is divided in two parts: one that draws the grid and enlightens the cells interested by an event and another that actually draws the red dot, with a specific position and with the L/R ambiguity resolved. This is because it was written in two parts, first to check if the preliminary results we obtained, pertaining only the description of the events with the cells, and later on to check if the final results, with complete description of the event were correct. " + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "def draw_chamber(array_indexes, array_cells, de):\n", + " \n", + " # first declare some variables and the figure in which the rectangles that constitute the grid will be put\n", + " cmap = colors.ListedColormap(['white'])\n", + " fig = plt.figure(figsize=(24,5), edgecolor = 'r')\n", + " ax = fig.add_subplot()\n", + " ax.axis('off')\n", + " ax.add_artist(Line2D((0, 16), (0, 0), color='black', linewidth=2))\n", + " ax.pcolor(d,edgecolors='white', linewidths=1, cmap=cmap)\n", + " ax.set_xticks([])\n", + " ax.set_yticks([])\n", + " ax.set_title('\\n Detector {}\\n'.format(de.at[0, 'Chamber']), fontdict = {'fontsize':20})\n", + " size, x_start, x_end, y_start, y_end = 16, 0., 16, 0., 4.\n", + " jump_x = (x_end - x_start) / (2.0 * size)\n", + " jump_y = (y_end - y_start) / (16)\n", + " x_positions = np.linspace(start=x_start, stop=x_end, dtype = int, num=size, endpoint=False)\n", + " y_positions = np.zeros((16))\n", + " l1, l2, l3, l4 = d[3], d[1], d[2], d[0]\n", + " x_pos = np.linspace(start=0, stop=len(array_cells), dtype = int, num=size, endpoint=False)\n", + " y_pos = np.zeros((len(array_cells)))\n", + " \n", + " # now draw the grid, in particular colour differently cells that have registered hits\n", + " for j in range(4):\n", + " if j % 4 == 0:\n", + " for i in range(16):\n", + " if (4*i+4) in display_example:\n", + " rect = patches.Rectangle((0+i,0),1,1,linewidth=1,edgecolor='black',facecolor='lightskyblue')\n", + " ax.add_patch(rect)\n", + " else: \n", + " rect = patches.Rectangle((0+i,0),1,1,linewidth=1,edgecolor='black',facecolor='none')\n", + " ax.add_patch(rect)\n", + " label = int(l1[i])\n", + " text_x = x_positions[i] + 0.15 \n", + " text_y = y_positions[i] + jump_y + 0.6\n", + " circle_x = x_positions[i] + jump_x \n", + " circle_y = y_positions[i] + 0.5\n", + " circle = patches.Circle((circle_x,circle_y),radius = 0.03,linewidth=1,edgecolor='black',facecolor='black')\n", + " ax.add_patch(circle)\n", + " ax.text(text_x, text_y, label, color='black', ha='center', va='center')\n", + " if j % 4 == 1:\n", + " for i in range(16):\n", + " if (4*i+2) in display_example:\n", + " rect = patches.Rectangle((0.5+i,1),1,1,linewidth=1,edgecolor='black',facecolor='lightskyblue')\n", + " ax.add_patch(rect)\n", + " else: \n", + " rect = patches.Rectangle((0.5+i,1),1,1,linewidth=1,edgecolor='black',facecolor='none')\n", + " ax.add_patch(rect) \n", + " label = int(l2[i])\n", + " text_x = x_positions[i] + 0.65 \n", + " text_y = y_positions[i] + jump_y + 1.60\n", + " circle_x = x_positions[i] + jump_x + 0.5 \n", + " circle_y = y_positions[i] + 1.5\n", + " circle = patches.Circle((circle_x,circle_y),radius = 0.03,linewidth=1,edgecolor='black',facecolor='black')\n", + " ax.add_patch(circle)\n", + " ax.text(text_x, text_y, label, color='black', ha='center', va='center')\n", + " if j % 4 == 2:\n", + " for i in range(16):\n", + " if (4*i+3) in display_example:\n", + " rect = patches.Rectangle((0+i,2),1,1,linewidth=1,edgecolor='black',facecolor='lightskyblue')\n", + " ax.add_patch(rect) \n", + " else: \n", + " rect = patches.Rectangle((0+i,2),1,1,linewidth=1,edgecolor='black',facecolor='none')\n", + " ax.add_patch(rect)\n", + " label = int(l3[i])\n", + " text_x = x_positions[i] + 0.15 \n", + " text_y = y_positions[i] + jump_y + 2.60\n", + " circle_x = x_positions[i] + jump_x \n", + " circle_y = y_positions[i] + 2.5\n", + " circle = patches.Circle((circle_x,circle_y),radius = 0.03,linewidth=1,edgecolor='black',facecolor='black')\n", + " ax.add_patch(circle)\n", + " ax.text(text_x, text_y, label, color='black', ha='center', va='center')\n", + " if j % 4 == 3:\n", + " for i in range(16):\n", + " if (4*i+1) in display_example:\n", + " rect = patches.Rectangle((0.5+i,3),1,1,linewidth=1,edgecolor='black',facecolor='lightskyblue')\n", + " ax.add_patch(rect)\n", + " else: \n", + " rect = patches.Rectangle((0.5+i,3),1,1,linewidth=1,edgecolor='black',facecolor='none')\n", + " ax.add_patch(rect)\n", + " label = int(l4[i])\n", + " text_x = x_positions[i] + 0.65\n", + " text_y = y_positions[i] + jump_y + 3.60\n", + " circle_x = x_positions[i] + jump_x +0.5\n", + " circle_y = y_positions[i] + 3.5\n", + " circle = patches.Circle((circle_x,circle_y),radius = 0.03,linewidth=1,edgecolor='black',facecolor='black')\n", + " ax.add_patch(circle)\n", + " ax.text(text_x, text_y, label, color='black', ha='center', va='center')\n", + " \n", + " # draw the actual events (L/R ambiguity resolved and positions at scale with the original one in the cell)\n", + " for i in range(len(display_example)): \n", + " j = de.at[i, \"Cell\"]\n", + " if j % 4 == 0: \n", + " for l, x in zip(l1, x_positions):\n", + " if j == l:\n", + " if de[\"LR\"][i] == 'R':\n", + " x_hit = x + 0.5 + (de[\"X(mm)\"][i]*0.5)/L2\n", + " elif de[\"LR\"][i] == 'L':\n", + " x_hit = x + 0.5 - (de[\"X(mm)\"][i]*0.5)/L2\n", + " y_hit = y_positions[i] + 0.5\n", + " circle = patches.Circle((x_hit,y_hit),radius = 0.04,linewidth=1,edgecolor='r',facecolor='r')\n", + " ax.add_patch(circle)\n", + " if j % 4 == 2: \n", + " for l, x in zip(l2, x_positions):\n", + " if j == l:\n", + " if de[\"LR\"][i] == 'R':\n", + " x_hit = x + 1 + (de[\"X(mm)\"][i]*0.5)/L2\n", + " elif de[\"LR\"][i] == 'L':\n", + " x_hit = x + 1 - (de[\"X(mm)\"][i]*0.5)/L2\n", + " y_hit = y_positions[i] + 1.5\n", + " circle = patches.Circle((x_hit,y_hit),radius = 0.04,linewidth=1,edgecolor='r',facecolor='r')\n", + " ax.add_patch(circle)\n", + " if j % 4 == 3: \n", + " for l, x in zip(l3, x_positions):\n", + " if j == l:\n", + " if de[\"LR\"][i] == 'R':\n", + " x_hit = x + 0.5 + (de[\"X(mm)\"][i]*0.5)/L2\n", + " elif de[\"LR\"][i] == 'L':\n", + " x_hit = x + 0.5 - (de[\"X(mm)\"][i]*0.5)/L2\n", + " y_hit = y_positions[i] + 2.5\n", + " circle = patches.Circle((x_hit,y_hit),radius = 0.04,linewidth=1,edgecolor='r',facecolor='r')\n", + " ax.add_patch(circle)\n", + " if j % 4 == 1: \n", + " for l, x in zip(l4, x_positions):\n", + " if j == l:\n", + " if de[\"LR\"][i] == 'R':\n", + " x_hit = x + 1 + (de[\"X(mm)\"][i]*0.5)/L2\n", + " elif de[\"LR\"][i] == 'L':\n", + " x_hit = x + 1 - (de[\"X(mm)\"][i]*0.5)/L2\n", + " y_hit = y_positions[i] + 3.5\n", + " circle = patches.RegularPolygon((x_hit,y_hit), numVertices = 6, radius = 0.04,linewidth=1,edgecolor='r',facecolor='r')\n", + " ax.add_patch(circle)\n", + " \n", + " \n", + " return plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABUkAAAFfCAYAAABz3E2sAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3hUZfrG8fud9EKLEroEkTWhJoRVbKggioCrFKm6KOAq9l3U1XWVJoIuItW14voTxEUFwYaogCiCSAkKsmBZNSDSBBMmfXJ+f0zIQjJJSMScN8z3c11cE2aGmZs358xz3mdOMY7jCAAAAAAAAACClcftAAAAAAAAAADgJpqkAAAAAAAAAIIaTVIAAAAAAAAAQY0mKQAAAAAAAICgRpMUAAAAAAAAQFCjSQoAAAAAAAAgqNEkBQAAAAAAABDUaJICAAAAAAAACGo0SQEAAAAAAAAENZqkAAAAAAAAAIIaTVIAAAAAAAAAQY0mKQAAAAAAAICgRpMUAAAAAAAAQFCjSQoAAAAAAAAgqNEkBQAAAAAAABDUaJICAAAAAAAACGo0SQEAAAAAAAAENZqkAAAAAAAAAIIaTVIAAAAAAAAAQY0mKQAAAAAAAICgRpMUAAAAAAAAQFCjSQoAAAAAAAAgqNEkBQAAAAAAABDUaJICAAAAAAAACGo0SQEAAAAAAAAENZqkAAAAAAAAAIIaTVIAAAAAAAAAQY0mKQAAAAAAAICgRpMUAAAAAAAAQFCjSQoAAFDDGWP+ZYxxjvrjM8b8Yoz5xhjzujHmVmPMKSfw/RxjzMoT9XqVfO+VxhjHjfcukSPMGNPHGPOcMWaLMSbDGJNljPnCGDPeGFPL7YwAAAA4fqFuBwAAAMAJs1hSWtHPtSQ1k3SBpCslTTTG3OE4zr9cynayaSlpoSSvpBWS3pIUK+kySQ9IGmiMOc9xnP3uRQQAAMDxokkKAABw8ni9ZBPUGBMqabik6ZKeN8bkOo4z341wJ5lMSbdIesFxHO+RO40x4fI3T3tJGiPpNnfiAQAAoDI43B4AAOAk5jhOgeM4T0u6ueiuqcaYqJLPM8YMNsasMMYcNMbkGGO2GWP+boyJOOo51x11qPuFJQ7xH1vi9c42xrxqjPnJGJNnjEk3xjxljGkcKKcxJs4YM7Ho0PWsotMFbDbGTDbGxBhjEore+8Ki5x/93itLvFaqMeY1Y8xeY0yuMeZ7Y8wTxphGAd73yKkKTjfG3GaM+dwYk13R6QQcx9nlOM4TRzdIi+7Pk/Rw0V8vKu81AAAAYA/2JAUAAAgOL8i/Z2NzSV3lPzxckmSMeU7+vU13yr8X5CFJnSVNkNTNGNPdcZwC+Q/lH1f0Ot9L+tdRr7/yqNe7XtIzknIlLZGULqmVpJGSrjDGdHYc54ejnt9C/kPWm0vaIOmf8n+Z/ztJf5b0ZFGmcZKuK3reuKPe+7ujXqu3pNckGUmvFuVMlTRK0pVFh8B/p9Kmy39qgrckvS3JF+A5xyu/6LbgV7wGAAAAqhFNUgAAgCDgOE6hMeYj+RuMZ6moSWqMuU7+BukiSUMdx8k+8m+K9g4dI/9h5dMdx0mTlGaMGSPpO8dxxpZ8H2PM7yQ9JX/j8kLHcXYd9VhXSe/J35Dsc9Q/m1uU62+O40wq8XqnSjrsOE6OpLHGmIskNS/jvWPlb9yGSrrIcZyPjnrsr5ImS3pa0qUBhqijpBTHcf4b4LHKGl50u/QEvBYAAACqAYfbAwAABI8jDcv6R913h/x7PA4/ukFaZIKkA5KGVuI9RkkKk3TH0Q1SSXIcZ7n8e5ZeceTq78aYVEnnyr+X6iMlX8xxnP1FDdLjcaWkUyT9++gGaZHH5G/cdjfGnBbg3z56Ihqkxpg/SLpR/r1yH/21rwcAAIDqwZ6kAAAAwcMU3TqSZIyJltRB0n5JdxpjAv2bXElJlXiPc4puLzTG/D7A4/GSQuQ/lH6D/If1S9K7juMUVuJ9AulYdLu85AOO4xQYY1ZJSpCUIumHEk9Z9yvfW8aYcyW9JP8V7/s5jnPw174mAAAAqgdNUgAAgOBx5KJJ+4pu68nfOK0v/2H1J8IpRbd3V/C82KLbukW3u8p6YiXUKbrdXcbjR+6vG+Cxn37NGxtjzpH0jqRCSZc7jvOrm64AAACoPjRJAQAAgoAxxiOpS9FfPy26/aXodpPjOB1L/6sqOfKadRzHyTiO5x8qum1yAt+7YRmPNyrxvKM5VX1TY8yRCz4VSrrMcZy1VX0tAAAAuINzkgIAAASH6ySdJv/elCskyXGcw5K2SmpjjImrxGsVyn/IfCBHGoQXHOdrHXn+ZUWN3Ir4JMkYE+j9NxXdXlTyAWNMqKTzi/668TizVajoYlTvyH9e1+40SAEAAGommqQAAAAnMWNMqDHmBkmz5d9b8s8lLoQ0VVK4pDnGmFKHoRtj6hljSu5lekBSszLecpakfEmPF13pvuTrhRfteSlJchxng6RPJCVL+muA559ijIks8d6Sv+Fb0uuSfpY02BjTucRjd0o6XdL7juOUPB9plRhjLpX0pqQcSd0cx/nsRLwuAAAAqp9xnCofWQQAAAALGGP+JWmYpMXyXyVekmLkbyReIP9h5r9Iut1xnP8L8O9nS7pZ/gbju/Jf1ChOUgv5D9F/3nGcm456/nxJg+RvEG6Qfy/KVY7jrCp6/BpJc+Q/3+lSSTvkv+L9kTz7HMdJPOr1WkhaWfT4hqKfjaRWki6VlOg4zndFz71R0pNF/8+3JWVL+t5xnBeLHr9S0ivyN4RfKfq/pBa9zk+SznMc59sAY9fiyHscD2PMmUUZIiW9JmlLoOc5jjP2eF8TAAAA7qFJCgAAUMMd1eg7olD+K6zvk/SFpPclveQ4zs/lvEZvSTdJOkv+Cxv9LH+DcZmkuY7j/Oeo58ZLmiapm6RT5T86adzRDUFjTDtJoyVdLP85Qr2SfpS0WtK/Hcc55gr0xphTJN0j6SpJzeXfO/M7+c/1OdFxnKyi54VImiB/k7aZ/OfY/9BxnIuOeq3fS/qb/IfX15G/OfqWpAmO4/xYxthVtkl6kYpOW1Aex3HM8b4mAAAA3EOTFAAAAAAAAEBQ45ykAAAAAAAAAIIaTVIAAAAAAAAAQY0mKQAAAAAAAICgRpMUAAAAAAAAQFCjSQoAAAAAAAAgqNEkBQAAAAAAABDUaJICAAAAAAAACGo0SQEAAAAAAAAENZqkAAAAAAAAAIIaTVIAAAAAAAAAQY0mKQAAAAAAAICgRpMUAAAAAAAAQFCjSQoAAAAAAAAgqNEkBQAAAAAAABDUaJICAAAAAAAACGo0SQEAAAAAAAAENZqkAAAAAAAAAIIaTVIAAAAAAAAAQY0mKQAAAAAAAICgRpMUAAAAAAAAQFCjSQoAAAAAAAAgqNEkBQAAAAAAABDUaJICAAAAAAAACGo0SQEAAAAAAAAENZqkAAAAAAAAAIIaTVIAAAAAAAAAQY0mKQAAAAAAAICgFlrB4zmSIqojSGU1bZ6gXT9873aMGiUkJEQ+n8/tGDUKY1Y1EVHRys3OcjtGjcKyVnmMWdUwbpXHZ1rlsZxVDeNWeYxZ5TFmlceYVQ31s/JY1iqPMauy7x3HSXA7hG2M4zjlPX5IUp1qylIpxhhN2pjndowa5b6O4arg9+0Wn6QQt0MEYoyxdcwkqUAVf9HhCtbPyrN4/SyUpUcdWL5+WsvicbN6WeMzrXIs/kyztnZKVq+f1o6bxWNmLYvHjDlB1Vg9btTPyrG4fjqSjNshArF4/SyU9KCkiW4HCcQY4ziOY+Xv1E1WTkYAAAAAAAAAoLrQJAUAAAAAAAAQ1GiSAgAAAAAAAAhqJ3WT9NWxN+ihbk007epkt6PUKAkJCWrXrp2Sk5PVqVMnt+PUCNOnT1fbtm3Vpk0bTZs2ze041gq0Ti57YoymD+ioGYM66bmbeypj348uJrTP8OHDFR8fr7Zt2xbfN3DgQCUnJys5OVkJCQlKTuYz7mjp6em6+OKLlZSUpDZt2mj69OmSpFdeeUVt2rSRx+PR+vXrXU5pn7LGbezYsWrSpEnxMvf222+7nNQeh35K1zN/6q6pfdvp8f4dtPqlmZKk3Ts264lhF2jagBS9cMdVyjmc4XJSe+Tk5Oiss85Shw4d1KZNG40ZM0aS9MADD6h9+/ZKTk7WpZdeqh9/pBYcUdaYUQsq5vP5lJKSot69e0uiDhyvkuNGHahYyTHbvHmzzjnnHLVr105XXHGFMjKoAyU90quVpg1I0YxBnTRraGdJzAsqEmieTi0o36FDh9S/f38lJiYqKSlJa9asoRagXFaegP1ESb3ijzpn4M165cHr3Y5S46xYsUKnnnqq2zFqhC1btuiZZ57RunXrFB4erh49eqhXr15q1aqV29GsE2id7PLH0br05nGSpNXzZ+mDpyeqz/2z3Yponeuuu0633nqr/vjHPxbf9+9//7v459GjR6tOHSuvr+ea0NBQPfbYY+rYsaMyMzOVmpqq7t27q23btlq4cKFuvPFGtyNaqaxxk6Q///nPuuuuu1xOaB9PSKh6/vlRNUlKUa43UzOHnq0zOnfTa+NvUs8/P6LTU7to/ev/0qr/e6z4cy7YRUREaPny5YqNjVV+fr7OP/98XX755br77rs1YcIESdKMGTM0fvx4Pfnkky6ntUNZY0YtqNj06dOVlJRU3KCiDhyfkuMmUQcqUnLMRo4cqSlTpujCCy/UnDlz9I9//KP4Mw7/c8NT7ymm3v/mnMwLKlZynk4tKN8dd9yhHj166NVXX1VeXp6ysrJUt25dagHKdFLvSdoi9QJF16nndgyc5LZt26bOnTsrOjpaoaGhuvDCC7Vo0SK3Y1kp0DoZGVu7+Of8bK+M4QJ7R+vSpYvi4uICPuY4jhYsWKDBgwdXcyq7NWrUSB07dpQk1apVS0lJSdq1a5eSkpJ05plnupzOXmWNG8pWu34jNUlKkSRFxNRSfItEZez9Ufu/36EWHS+QJJ3RuZu2fkBNOMIYo9jYWElSfn6+8vPzZYxR7dr/qwVeL7XgaGWN2RHUgsB27typt956SyNHjiy+jzpQsUDjhvIFGrPt27erS5cukqTu3bvrtddecytejcK8oOqoBaVlZGRo1apVGjFihCQpPDxcdevWpRagXCd1kxRVY4zRpZdeqtTUVD399NNux7Fe27ZttWrVKh04cEBZWVl6++23lZ6e7nasGuXdWQ9o8uWnK+2d+bpk1Bi349QYH330kRo0aMBey+X47rvvtGnTJp199tluR6lRSo7brFmz1L59ew0fPlwHDx50OZ2dDv74nX7cvlnN2p6lBi3baNuHb0iSvnj/NR3as9PldHbx+XxKTk5WfHy8unfvXryc3X///WrWrJnmzZun8ePHu5zSLmWNmUQtKMudd96pRx99VB4P053KKGvcqANlCzRmbdu21ZIlSyT5T/PA3KA0Y4zm3NJTM4ecrXWvPVt8P/OCspU3T6cWlPbtt9+qfv36uv7665WSkqKRI0fK6/W6HQuWY6sBpaxevVobN27UO++8o9mzZ2vVqlVuR7JaUlKS/vrXv6p79+7q0aOHOnTooNDQk/pMFifcZbdO0L3vfKvkywdrzctPuB2nxpg/fz7fFpfj8OHD6tevn6ZNm3bMXmooX8lxGzVqlL755hulpaWpUaNGGj16tNsRrZObdVhz7xqo3qOnKDK2tvqNeVprFjypmUPOVq43UyFh4W5HtEpISIjS0tK0c+dOrVu3Tlu2bJEkTZw4Uenp6Ro6dKhmzZrlckq7lDVmErUgkDfffFPx8fFKTU11O0qNUta4UQfKVtaYzZkzR7Nnz1ZqaqoyMzMVHk4dKOmm51fqtpfW6fpZb2jNgn/qvxs+ksS8oDzlzdOpBaUVFBRo48aNGjVqlDZt2qSYmBhNnjzZ7ViwHE1SlNK4cWNJUnx8vPr06aN169a5nMh+I0aM0MaNG7Vq1SrFxcXxDV4VdegxSFuXc1jq8SgoKNDChQs1cOBAt6NYKT8/X/369dPQoUPVt29ft+PUGIHGrUGDBgoJCZHH49ENN9xATSjBl5+veXcNVHLPwWrbrY8kKb5FokY88bZue+lTdegxUKc0Pd3llHaqW7euLrroIi1duvSY+4cMGcKhqWUoOWbUgsBWr16tJUuWKCEhQYMGDdLy5ct1zTXXuB3LemWNG3WgbGWNWWJiopYtW6YNGzZo8ODBatmypdtRrVO7vn/OGRsXrzYXX6n0rZ8d8zjzgtLKmqdTCwJr2rSpmjZtWnz0Rf/+/bVx40aXU8F2NElxDK/Xq8zMzOKfly1bdsxVtRHY3r17JUk//PCDFi5cyLd4lbD/h6+Kf9626k3VT+D8MMfj/fffV2Jiopo2bep2FOs4jqMRI0YoKSlJf/nLX9yOU2OUNW67d+8u/nnRokXUhKM4jqPXxv9J9Vsk6oJr7iy+//DP/ppQWFioFc9O0tn9/uRWROvs27dPhw4dkiRlZ2cXf5Z99dX/asGSJUuUmJjoVkTrlDVmErWgLJMmTdLOnTv13Xff6eWXX1bXrl01d+5ct2NZr6xxow6UrawxOzI3KCws1EMPPaSbbrrJ5aR2ycv2KtebWfzzV2vfV4OWbZgXlKO8eTq1ILCGDRuqWbNm2r59uyTpgw8+UOvWrV1OBdud1McEz7/vGv13wyp5D+3XpB4tdMlND+r3V3Gl+/Ls2bNHffr494QpKCjQkCFD1KNHD5dT2a9fv346cOCAwsLCNHv2bNWrxwXDAgm0Tm7/+B3t/36HjPGobqPTdBVXsDzG4MGDtXLlSu3fv19NmzbVuHHjNGLECL388ss048uwevVqvfjii2rXrp2Sk5MlSQ8//LByc3N12223ad++ferVq5eSk5P17rvvupzWHmWN2/z585WWliZjjBISEvTUU0+5nNQe36d9ok1vzVPDM9pqxqBOkqRLb52gAz98rTUL/ilJatv1KqVeOczNmFbZvXu3hg0bJp/Pp8LCQg0YMEC9e/dWv379tH37dnk8HjVv3pwr2x+lrDGTRC2opEWLFlEHquCee+6hDlTS/PnzNXu2f5u2b9++uv565qBHO3xgj14cfbUkqdBXoOQeg3TmeZdp7l0DmBeUobx5OrWgbDNnztTQoUOVl5en008/Xc8//zy1AOUyjuOU9/ghSXWqKUulGGM0aWOe2zFqlPs6hquC37dbfJJC3A4RiDHG1jGTpAJZ+kUH62flWbx+FsrSow4sXz+tZfG4Wb2s8ZlWORZ/pllbOyWr109rx83iMbOWxWPGnKBqrB436mflWFw/HUnG7RCBWLx+Fkp6UNJEt4MEYoxxHMex8nfqJisnIwAAAAAAAABQXWiSAgAAAAAAAAhqNEkBAAAAAAAABDWapAAAAAAAAACCGk1SAAAAAAAAAEGNJikAAAAAAACAoEaTFAAAAAAAAEBQo0kKAAAAAAAAIKjRJAUAAAAAAAAQ1GiSAgAAAAAAAAhqNEkBAAAAAAAABDWapAAAAAAAAACCGk1SAAAAAAAAAEGNJikAAAAAAACAoEaTFAAAAAAAAEBQo0kKAAAAAAAAIKidlE3Suj98LU9+vtsxALjJcRT33XbJcdxOAgAnTLg3U7F7d7kdAwCAmoE5AYBKCHU7wInU6It16vr4PWq0db1yatfTyjse1tYeg+WE/vb/zYL8PG1Y/IL2fb9d9ZufqdQrhyk0LPw3f9+a7t1339X777/vqVOnjoYPH67GjRu7Hcl6X3/9tV588UXl5OR4rrzySp177rluR7KL4+j0T95V18fuVr2d3+pQ4wQtu3W8XtqzSwd/SlfjMzsouecQeTwn5XdEJ4zjOFq4cKE++eQT07BhQ40cOVL16tVzO5b1Nm/erAULFsgYowEDBqh9+/ZuR7Lezz//rGeeeUZ79+41559/vq666ioZY9yOZZ2wrMPqNG+GznlhijwF+Vp7ZgdNP721cn7XXr+/arjCo6Ldjmi9jz/+WEuWLPFER0fr2muvVcuWLd2OZL1du3Zpzpw5ysjI8Fx22WW65JJL3I5kvby8PM2ZM0c7duxQYmKirr/+eoWFhbkdy3pLly7Ve++954mLi9OIESPUsGFDtyNZb8eOHZo7d65yc3M9ffr0UefOnd2OZBfHUYtPlqnb1LtVL/0b/dK4ud69ebzm7d2lQ3t2qklSijr0GMScoAKO4+jVV1/VmjVrTOPGjTVy5EjVrVvX7VjW27Rpk1555RXz5ZdfXrJ48eLFjuNscTsTjo9xyv9G5ZCkOtWUpVKMMZq0Ma/47+0XPqvuU0YrJDdHnqL/U15UjHa3+b3mP73sN81SkJ+np0ZcrD1fb1V+TpbCIqPV8Iw2+tNzK6xqlN7XMVwV/L6r1UMPPaRJkyYpKytLoaGhiomJ0WeffaZWrVq5Ha2YMcaqMVu3bp26du2qnJwc+Xw+RUdHa/bs2bruuuvcjnaMkutndeo6ZbSSF81ReLa3+D6vMZprPLqp0KewyGidcXZXXTv1NasaMbatnzfeeKPmzZsnr9eriIgI1atXT2lpaWrQoIHb0YrZtn6+/fbb6t+/v3JyciRJkZGRWrRokS677DKXkx3LpnHbvXu3UlJSdPDgQeXl5SkmJkbDhg3T7Nmz3Y52DDc/0yTJFBTo1suaKyzbq/CcLElSnqQCSd3CIvR14+a6dd5aRUTHupaxJNs+05599lndcccdysrKUkhIiCIjI/Xhhx8qNTXV7WjHsGn93L59u8466yxlZWWpoKBA0dHRevDBB/XXv/7V7WjHsGnMcnNzdd5552nbtm3KyspSdHS0OnTooA8//NCqRqlNYyZJ48aN06OPPqqsrCyFhYUpJiZG69evt+qLDNvGbM2aNerevbuys7NVWFio6OhoPfnkk7r22mvdjnYMN+vnxVPvUcprz5SaE7xkPPpToU9hUTFq1fkSXTNlAXOCcowYMUL//ve/i+cEcXFx2rx5s+rXr+92tGK2rZ9vvPGGBg4cqJycHDn+YNmSrnIc5z23sx3NGOM4jmPPwm+Jk+Zrk3rp3yosJ7u4QSpJ4dle1fvhq9/8vb9P+0R7v92m/KKJS35OlvZ8u00/bF7zm793TeU4jiZMmKCsLP+YFRQUKCMjQzNnznQ5md3Gjx8vr9crn88nScrKytLf/vY3l1PZ5dT//ueYjSFJinEcnVnoH7P8nCx9vfYDHUj/2o14NcKhQ4f0/PPPy+v1j2Nubq5+/vlnzZs3z+VkdrvvvvuUnZ0tx3HkOI6ys7NZPyvw4osv6ueff1Zenn8C5fV69cwzz+jw4cMuJ7NLSEG+ojIOFjdIJSlcUr6kRvm5yti7S9s/etu1fDXB/fffX7zN4fP55PV6NWHCBJdT2W3atGnKyMhQQUGBJP82x7hx41xOZbePPvpI27dvL17WsrKy9MUXX2jt2rUuJ7NXYWGhJk6cWDxm+fn5+uWXX/TEE0+4nMxu48aNk9frVWFhoST/snb//fe7nMouFc4Jsr366pNlOrjrv27EqxEOHDiguXPnlpoTzJ8/3+Vkdrv33nuL5wSSjKRoSQ+5mwrH66RpkrrJBNpF35GMYXjLU/LQBmOMQkJCXEpTMwQ6HIRDRKqG9bNsgZYpYwzLWgUCfX7xmVY+j8dTau8Nx3Gs2qOjpgi4LYJigT6/WD/LFxISEnBbDWUrq05SP8tmjCm1XHk8HsasAoE+vxizynPkUD/L4fF4Su2hyZygYmVsX/iqOweq5qRZug+0SFR+RKQKj1ph86JitK9Vu9/8vZt3OFdNW6cqPCpGMkbhUTFq2raTTutwzm/+3jWVMUaTJk1SdHR08WFv9erV05133ul2NKtNmDBBtWrVUnh4uEJDQxUVFaWpU6e6HcsqexJTlBcZrSPl3JH/0JrNIaEyxqPwqBi1vvhKxTU93c2YVqtdu7Zuv/12xcTEyOPxKDo6Wg0bNrTuEC7bTJkyRdHR0QoLC1NYWJiio6P1j3/8w+1YVrvuuusUHx+v6Ojo4mVt9OjRiomJcTuaVXyhYfKeEq+8qP+NS46kMEk7wyN1SrOWSrygl2v5aoKpU6cqKipKoaGhioiIUK1atTR27Fi3Y1lt9OjRqlu3riIjIxUSEqKoqCg98sgjbsey2gUXXKCUlJTi+hkTE6POnTtzrshyGGM0ceLEY+YEcXFxuv32292OZrUJEyYoNjaWOUE59vyug/KPmhNIpecE7S7pp7qNmruW0Xb16tXTzTfffMycoFGjRho6dKjb0az22GOPKTo6WqGhofJ4PD5JWZLsOlcNynTSnJNUkk79eosunv43Jax9XxkNm2nFnx/RjouvlKrhW+9Cn0+fL1ugAzu/1SnNWqp996vlsWwPBdvObyJJq1ev1ooVKwpr167tGTp0qE455RS3Ix3DtvObSNLOnTu1YMEC5ebmFvbs2dPToUMHtyOV4vb5+5puWq2uU+9Ww22btPd37bXs9oe15Kd0/bJvlxq1aqekC6+wbm8YG9fPZcuW6dNPP3Xq169vrr32WusaVzaunzt27NDrr78uSerbt6/OOOMMlxOVZtu4ZWZmau7cudq/f79zzjnnGBsvDOP2Z5okheTmKHnhszr/yfEKy83Wh6ld9HSrdvK1SFJyz8FWnQNdsvMzbdOmTXrnnXcKIyMjPQMHDlSTJk3cjlSKbevn/v37NW/ePB0+fLiwa9eunnPOsW8HANvGzOfz6eWXX9a3336rVq1aacCAAdbtdWXbmEn+C6utXLmysE6dOp6hQ4cqLi7O7UjHsHHM0tPTtWDBAuXl5RX26tXLY+PFIt2un03SPlHXqfeo0ZcbtLdVOy27faIW79mpjH0/qtHv2iupS2/mBMfh3Xff1bp165z4+HhzzTXXMCc4Dtu3b9frr7/ubNmy5d25c+fe6jjON25nKolzkgZ2UjVJj4jZt1veUxpIlm2QuM3GD9wiPkl2dZSL2PiBe5QCSaFuhwjE7Q2iI2L37tLh+o2r5YuSX8vi9bNQlh51YPn6aS2Lx83qZc2GzzTJ3ywNy/Yqp65dXyqWZPFnmrW1U7J6/bR23CweM2tZPGbMCarG6nGzoX4yJzghHPnPr2kdi9fPQkkPSprodpBAaJIGZuXGzq/lrd/I7TS1svkAACAASURBVAgALHA43r69hADg1/BFRMoXEel2DAAAagzmBACOl5V7bAAAAAAAAABAdaFJCgAAAAAAACCo0SQFAAAAAAAAENRokgIAAAAAAAAIajRJAQAAAAAAAAQ1mqQAAAAAAAAAghpNUgAAAAAAAABBjSYpAAAAAAAAgKBGkxQAAAAAAABAUKNJCgAAAAAAACCo0SQFAAAAAAAAENRokgIAAAAAAAAIajRJAQAAAAAAAAQ1mqQAAAAAAAAAghpNUgAAAAAAAABBjSYpAAAAAAAAgKBGkxQAAAAAAABAUKNJCgAAAAAAACCo0SQFAAAAAAAAENRokgIAAAAAAAAIajRJAQAAAAAAAAQ1mqQAAAAAAAAAghpNUgAAAAAAAABBjSYpAAAAAAAAgKBGkxQAAAAAAABAUKNJCgAAAAAAACCo0SQFAAAAAAAAENRokgIAAAAAAAAIaqEVPB4rqbA6glQBDd6qsfH3GSLJKfpjG4/sHDMj//prYzaJ9bOqbPx9esT6WVlHln8bs0l2j5uNuSQ+06rKxt9nSNGtjdkkO9eDmrDNYWM2W3NJ9mZjTlB5Rv5xszGbRP2sKht/n8wJKs9IauR2CFSOcZyyl/GmpyU4u9K/r8Y4xy80PEIFebluxwAQAOsngJMJn2kAAFQe9ROw2veO4yS4HcI25TZJjTHOpI151Rin5ruvY7jKG1ME5DPGhDBulWOMYVmrJMasSgqNMR5qQeVQCyrPGCOWs8pjWau0AmNMKGNWOdTPymPMqoQ5QRVQPyuP2lkljjGm3P4RSik0xngcxzFuB8HxY/d3AAAAAAAAAEGNJikAAAAAAACAoEaTFAAAAAAAAEBQ+9VN0vzcHM2+9lxNH5iqx/t30Hv/HHcicp30tm/fruTk5OI/tWvX1rRp09yOZZ3hw4crPj5ebdu2Lb7vlVdeUZs2beTxeLR+/XoX09kp0JiNHTtWTZo0KV7e3n77bRcT2inQuG3evFnnnHOO2rVrpyuuuEIZGRkuJrTPoZ/S9cyfumtq33Z6vH8HrX5ppiRp2RNjNH1AR80Y1EnP3dxTGft+dDmpPdLT03XxxRcrKSlJbdq00fTp0yVJAwcOLF4/ExISlJyc7HJSe5S1nfHFe6/q8f4d9LfUCO38coPLKe2Tk5Ojs846Sx06dFCbNm00ZswYSdSD8pQ1ZtSCivl8PqWkpKh3796SpAceeEDt27dXcnKyLr30Uv34I3WgpJJjRh2oWEJCgtq1a6fk5GR16tRJEvOCijzSq5WmDUjRjEGdNGtoZ0nS+0+O16TLEjRjUCfNGNRJ//n4HZdT2iXQckYdqNihQ4fUv39/JSYmKikpSWvWrKEWoEb61RduchxHedleRUTHypefrydHXKQr7pqq09qffaKz1ghVOQm0z+dTkyZN9Omnn6p58+a/UTKrlXmS9lWrVik2NlZ//OMftWXLFknStm3b5PF4dOONN2rKlCnFxSvYlHVBgEBjNnbsWMXGxuquu+6q7phWKe8iCoHG7fe//72mTJmiCy+8UHPmzNF///tfTZgwoToj26DMCzdl7NutzP0/qUlSinK9mZo59GxdO/VV1YlvqsjY2pKk1fNnae+329Tn/tnVndtVZdWC3bt3a/fu3erYsaMyMzOVmpqq119/Xa1bty5+zujRo1WnTh09+OCD1RnZdWVdeKKs7YzI2NoyHo8WTbxFPf/8iJq2TnUhtfvKWtYcx5HX61VsbKzy8/N1/vnna/r06Vq6dGmw14MyL9xU1pjddtttQV8LKroI0dSpU7V+/XplZGTozTffVEZGhmrX9teBGTNm6Msvv9STTz5ZXXGtUNkxO1qw1gFVcOGmhIQErV+/XqeeemrxfcwLyr9w0yO9WunWuWsUU+9/Y/b+k+MVHh2rLn/8S3VFtE55c/ZAyxlzAkkVXLhp2LBhuuCCCzRy5Ejl5eUpKytLHo8n2GsBF26qgX71nqTGGEVEx0qSfAX5KizIlwzLQGV88MEHatmyZbA2SMvVpUsXxcXFHXNfUlKSzjzzTJcS2S/QmKFigcZt+/bt6tKliySpe/fueu2119yIZq3a9RupSVKKJCkippbiWyQqY++PxQ1SScrP9spQE4o1atRIHTt2lCTVqlVLSUlJ2rVrV/HjjuNowYIFGjx4sFsRrVPWdkb86Umqn0AtKIsxRrGx/nHLz89Xfn4+62IFyhozakH5du7cqbfeeksjR44svu/IpFiSvF7qQEmBxuwI6kDlMC9AdaAOlC8jI0OrVq3SiBEjJEnh4eGqW7cutQA10gk5J2mhz6cZgzpp4iVNdMbZ3XRau7NOxMsGjZdffpkNIfzmZs2apfbt22v48OE6ePCg23FqhLZt22rJkiWS/Idzpaenu5zIXgd//E4/bt+sZm39n//vznpAky8/XWnvzNclo8a4nM5O3333nTZt2qSzz/7fkRcfffSRGjRooFatWrmYzD5sZ1SNz+dTcnKy4uPj1b179+JljXpQtkBjRi0o35133qlHH31UHs+x04r7779fzZo107x58zR+/HiX0tmprDGTqAPlMcbo0ksvVWpqqp5++mm349QIxhjNuaWnZg45W+tee7b4/jX//qemD+ioV8feoOwM6sDRAi1n1IHyffvtt6pfv76uv/56paSkaOTIkfJ6vZKoBah5TkiT1BMSottfXq97l/5XO7eu109fbzkRLxsU8vLytGTJEl199dVuR8FJbNSoUfrmm2+UlpamRo0aafTo0W5HqhHmzJmj2bNnKzU1VZmZmQoPD3c7kpVysw5r7l0D1Xv0lOK9SC+7dYLufedbJV8+WGtefsLlhPY5fPiw+vXrp2nTph3zLfv8+fP50iwAtjOqJiQkRGlpadq5c6fWrVunLVu2UA8qEGjMqAVle/PNNxUfH6/U1NKnu5g4caLS09M1dOhQzZo1y4V0dipvzCTqQHlWr16tjRs36p133tHs2bO1atUqtyNZ76bnV+q2l9bp+llvaM2Cf+q/Gz7S2VffqLuX/Ee3vbxetU5tqLem3uN2TKsEWs6oA+UrKCjQxo0bNWrUKG3atEkxMTGaPHmyJGoBap4TenX7qFp11SK1i3Z8suxEvuxJ7Z133lHHjh3VoEEDt6PgJNagQQOFhITI4/Hohhtu0Lp169yOVCMkJiZq2bJl2rBhgwYPHqyWLVu6Hck6vvx8zbtroJJ7Dlbbbn1KPd6hxyBtXb7IhWT2ys/PV79+/TR06FD17du3+P6CggItXLhQAwcOdDGd3djOqJq6devqoosu0tKlS6kHx+noMaMWlG316tVasmSJEhISNGjQIC1fvlzXXHPNMc8ZMmQIh6Yepbwxow6Ur3HjxpKk+Ph49enTh8+v41C7vn/MYuPi1ebiK5W+9TPVOqWBPEV14Ky+I7Rz62cup7RLoOWMOlC+pk2bqmnTpsVHrPTv318bN2485jnUAtQUv7pJevjgPmVnHpIk5edk65tPl3OOsErg22JUh927dxf/vGjRomOu4I6y7d27V5JUWFiohx56SDfddJPLieziOI5eG/8n1W+RqAuuubP4/v0/fFX887ZVb1ITjuI4jkaMGKGkpCT95S/HXjDh/fffV2Jiopo2bepSOjuxnVE1+/bt06FD/nHLzs4uXr6oB2Ura8yoBWWbNGmSdu7cqe+++04vv/yyunbtqrlz5+qrr/5XB5YsWaLExEQXU9qlrDGTqAPl8Xq9yszMLP552bJlfH5VIC/bq1xvZvHPX619Xw1atlHGvv/Vga3LF6tByzZuRbROWcsZdaB8DRs2VLNmzbR9+3ZJ/muutG7dmlqAGin0175A5r7demXMCDk+nxynUO2691dSl14nIttJLysrS++9956eeuopt6NYa/DgwVq5cqX279+vpk2baty4cYqLi9Ntt92mffv2qVevXkpOTta7777rdlRrBBqzlStXKi0tTcYYJSQksMwFEGjcDh8+rNmz/Vdl79u3r66//nqXU9rl+7RPtOmteWp4RlvNGOS/muylt07Q+tef1/7vd8gYj+o2Ok1XBdmV7cuzevVqvfjii2rXrp2Sk5MlSQ8//LB69uzJ+anLUNZ2xtblr2vJo3+W9+A+vXD7lWr0uw4a/sRbbse1xu7duzVs2DD5fD4VFhZqwIAB6t27t6699lrqQRnKGrPp06dTCyrp3nvv1fbt2+XxeNS8efNgu5pxlVEHyrZnzx716eM/YqWgoEBDhgxRjx49tGjRIuYFZTh8YI9eHO0/pVuhr0DJPQbpzPMu07//fp1279gsI6N6jZvrqvs5LdIRZS1n1IGKzZw5U0OHDlVeXp5OP/10Pf/88xo5ciS1ADWOcRyn7AeNcSZtzKvGODXffR3DVd6YIiCfMSaEcascYwzLWiUxZlVSaIzxUAsqh1pQecYYsZxVHstapRUYY0IZs8qhflYeY1YlzAmqgPpZedTOKnGMMeX2j1BKoTHG4ziOcTsIjt8JPScpAAAAAAAAANQ0NEkBAAAAAAAABDWapAAAAAAAAACCGk1SAAAAAAAAAEGNJikAAAAAAACAoEaTFAAAAAAAAEBQo0kKAAAAAAAAIKjRJAUAAAAAAAAQ1GiSAgAAAAAAAAhqNEkBAAAAAAAABDWapAAAAAAAAACCGk1SAAAAAAAAAEGNJikAAAAAAACAoEaTFAAAAAAAAEBQo0kKAAAAAAAAIKjRJAUAAAAAAAAQ1ELdDvBb8+Tnq/GWdQrNzdaP7c5WXkwttyMBAH4LhYVqtHW9IjMPaXfrVOXUPcXtRMBxCcnNUZPP10qSdrXvLF9EpMuJAAA4eYTk5arxF5/KU1CgXe07ux0HgMVqXJN026q3tO3DNxQeFauz+9+g+glnlvnc01cv1R/uu1bGKZRjjELz8vTxDfdr7fB7JGOqMbW7tm/frieffFKHDx/WlVdeqd69e7sdyXqHDx/WjBkztGPHDiUnJ+vmm29WeHi427Gs5jiO5s+frw8++ECnnnqqbrvtNjVt2tTtWNbbsGGDnn/+eRUUFGjIkCHq0qWL25Gs5z24X6vnz9Ive3eqeftz1OnK69Tkyw3q95d+Csv2yvF4FJqbq7S+w/X+3Y9LHg6a8Pl8evbZZ7V27Vo1a9ZMd955p+Li4tyOZb1v13+oze8uUEhomDpdOUyNE1NO+Hu0feNFXTrpNhWG+DfJPL4CvffX6friymEn/L2qQ3p6umbOnKkDBw7o0ksv1YABA2SCaJurKnJzc/XEE09o8+bNOvPMM3X77bcrJibG7VjWW7Jkid544w3VqlVLo0aNUqtWrdyOZL1t27bpqaeeUlZWlq666ir17NnT7UjWy8zM1IwZM/TVV1+pY8eOuummm5gTVMBxHKW9M1/frFuh2Lh4nTv4FtWu39i1PGcue1W9xv9JhcYjGSkkP1//dS1N2T777DO98MIL8vl8Gjp0qM4//3y3I1lv3759mj59unbt2qXzzz9f119/vTxs9+NXMo7jlP2gMc6kjXnVGKd8K557RCuem6T8nCzJGIVHRutPz3ygJq07lnpu7L4fdeMfkhSWm33M/XlR0Vo8aZ6+6dLrN8l4X8dwlTem1W39+vW66KKLlJWVJcdxFB0drb///e+677773I52NJ8xJsSWcTt8+LBSUlK0c+dO5eTkKCoqSu3bt9fHH3+s0FB7vlcwxli1rI0aNUovvviivF6vQkJCFBsbqw0bNqhly5ZuRytm25gtXbpU/fr1U1ZWliQpKipKTz31lK699lqXkx2j0BjjsaUWZB7YoxkDU5WdcUi+gjyFRUar/e8v0uqNHyvCm3HMc/Mio7XizsnaNOCmas9pUy1wHEdXXHGFVqxYoaysLIWHhysuLk6ff/656tev73a8YsYY2bKcSdL6xS9oySN3+Lc5JIVFROnax19Tq86XnLD3iN+xWdcO61JqWyU/Ikpzn1+pPcfRlLVpWfvqq6/UqVMneb1e+Xw+RUdHa8SIEZoxY4bb0Y5WYIwJtWXM8vPzde6552rr1q3Kzs5WZGSkTjvtNG3cuNGqRqlt9XPChAmaPHmysrKy5PF4FBUVpY8++kgpKSf+i4yqsm3M1q1bp65dux4zJxg7dqzuvvtut6Mdzao5QWZmppKTk7Vr1y7l5uYqKipKKSkpWrVqlUJCQtyOV8y2+rlwwk1Ke+dl5edkyRMSqvDoWN320qeKa9Ki2rPU+36Hhg/6fak665UU8/HH0nnnVXumQN566y1dffXVys7254yKitKzzz6rIUOGuJzsGI4xptz+UXXavXu3OnTooEOHDik/P18xMTG6/PLL9corr7gd7WiFxhiP4zh8W1yD1Kg2+4f/erR4siLHUV62Vx/NfTzgcxPfe00KsAKHZ2cp5ZWnfsuYVpk6daq8Xm/xRlpWVpYmT57sciq7vf/++9qzZ49ycnIkSdnZ2dq6das2bdrkcjJ75ebm6plnnpHX65Xk32stMzNT//rXv9wNZrkJEyYUN0gl/7I2btw4FxPZb8sHi5TjzZCvwD8ZyM/JUos178kpLCz13PCcLHVc8GR1R7ROenq6li9fXrys5eXl6ZdfftGiRYtcTma35c889L9tDkn5udla/uzDJ/Q92i1+QSF5OaXuD8nPVfvX/3VC36s6PPfcc8rMzJTP55Pk3+b45z//qfz8fJeT2Wv9+vX6z3/+UzwxzsnJ0e7du7VixQqXk9ntkUceKf5MKywslNfr1bRp01xOZbd//OMfpeYEDz98Yj/TTjbLli3T3r17lZubK8m/nbZ582Z9/vnnLiezV35OtjYs+b/i+lnoK1BuVqY2vjHXlTxt3npJnoLSDeQoSXrKnp7A+PHji+uAxJzgeLzyyivKyMgo3sbwer164403tGfPHpeToaarUU3SkNCwY/5ujEehEVEBn1sQHiEnwK7WhcaoIDL6N8lno8jIyFK7nIeFhZXxbEhSeHjpvXIKCwsVERHhUiL7hYSElFrOQkJCGLMKBBofxqx8oWHhMubYZS3XcaQyvp8t4NyOCg8PV2GJJrIxhsMFKxASVnp8QsNP7PKUHxElJ8DeSI7xKD8y8PaNzSIiIkrtXeXxeDj0rRwRERGltjkcx2H9rEDJbVmPx6PISD7vyxMVFVVqXWQ5K1+g8WH9LJ8JCSl1WjuPJ0ShLm2PFURGyfGUrrOFkhRtT08g0OcXc4LyRURElPpMY/3EiVCjtlr/cO8MhUVEKTQ8UmGR0YqqU09dRwY+bHzbZQNUGBqqkvuSFkREad01d/72YS3xwAMPKC4uTtHR0YqMjFRUVJRmz57tdiyrde/eXZ06dVJsbKwiIiIUExOjq666Su3atXM7mrVCQ0M1efJkRUdHF49Z48aNddNN1X+Yc03y2GOPqVatWoqKilJkZKRiYmI0a9Yst2NZrf1lAxTXpIXCo2MVEhahsMhoHR5yq/JjaquwxIZSXmS0/xzUQa5hw4a65ZZbFBMTo4iICMXGxqpVq1YaMGCA29GsduW9MxQWGa3QiEiFRUQpIqaWet456YS+x+Z+I+ULLb0x7wsL16b+fzqh71UdbrnlFjVq1Kh4WYuOjtaUKVOsOizVNikpKerVq1fxNkdsbKw6d+6srl27uh3NarNmzTqmdp5yyin629/+5nYsq40ZM0Z169Y9Zk7ANkf5evTooY4dOx4zJ+jXr59at27tdjRrhYaF67JbxissMloh4REKj4pR7fqN9fs+w13J88UVf1RhaOkdhHIl6bbbqj1PWaZOnarY2Njiz7Xo6GjNnDnT7VhWGzJkiFq0aFG8fkZHR+uuu+5SvXr13I6GGq5GnZNUkvZ8s1XffPahwiKj1LbrVYqqXfZKUH/H57ri79cp7vuv5Hg8yo2trWX3ztSOblf9ZvlsOjfYEQcPHtTChQuVnZ2trl272ljYrTr/kOTfc3Tx4sX6/vvvlZiYqMsuu8y6C0/Ydq4ryX/C8TVr1qhu3brq37+/oi36hlayc8x2796tJUuWyOfz6fLLL1eLFtV/vqYKWHVOUkkqyM/Tlg8W6vCBvWqS1FEtOp6vOj9+p973D1OjLzeoMCRUvvAIfXjLeKVdfaMrGW2sBR9++KE2bdqkhg0bql+/ftYdVWDbOdUk6UD6N9qx5j15PCFqfdEVqnVqwxP+Hs02fKSeY0eq1r7dciR5T22ot8Y9q/TU47uIm23Lmtfr1auvvqpffvlF5513nlJTU92OVJJV5ySV/Hu+LF26VNu3b1dCQoL+8Ic/WLf3rY31c8uWLVqxYoViYmLUt29f1a1b1+1Ix7BxzH7++WctXLhQOTk56tatm5KSktyOVJJ1cwKfz6fFixfrhx9+UOvWrdW9e3cr5wS21c/0LZ/ph8/XKqp2PbW7pJ/CXDw6otEX69T7weGqs/t7OcYoq+6punrPTi2zaDmTpB9//FFLlixRYWGhevbsqYSEBLcjlWTVOUkl/ymkXn31Ve3bt0+pqak2XuyKc5LWQDWuSVoV0T/vVWhujjIaNvvNr2pv22SlhrBug6gmsHHj23aMWZVY1yQtT+QvPyvCm6GMBs0CHsZcXagFlWfjJK86xe77UZJ0uJJXAGZZqzTrmqQ1AfWz8hizKmFOUAXBXj+PV8z+n+TxFSgzvonuSy19qhNUyLomaQ1Ak7QGsudS3b+hrLh4tyMAAKpBTp045dSJczsGUGmVbY4CAIDj5/0NjgYBcPKx61geAAAAAAAAAKhmNEkBAAAAAAAABDWapAAAAAAAAACCGk1SAAAAAAAAAEGNJikAAAAAAACAoEaTFAAAAAAAAEBQo0kKAAAAAAAAIKjRJAUAAAAAAAAQ1GiSAgAAAAAAAAhqNEkBAAAAAAAABDWapAAAAAAAAACCGk1SAAAAAAAAAEGNJikAAAAAAACAoEaTFAAAAAAAAEBQo0kKAAAAAAAAIKjRJAUAAAAAAAAQ1GiSAgAAAAAAAAhqNEkBAAAAAAAABDWapAAAAAAAAACCGk1SAAAAAAAAAEGNJikAAAAAAACAoEaTFAAAAAAAAEBQo0kKAAAAAAAAIKjRJAUAAAAAAAAQ1GiSAgAAAAAAAAhqNEkBAAAAAAAABDWapAAAAAAAAACCGk1SAAAAAAAAAEEt1O0AJymf2wFqmJCiW8bt+HkkGTFmlRUixqyyQip+CsrAsnb8jPji9tdgWTt+bHNU3pH1kzGrHLY5Ko/1s/KOzAlQeSxnlcP6WXmsmzWQcRynzAebntbc2ZX+QzXGAQDYJjQ8QgV5uW7HwEmO5QwAgMqjfgKoou8dx0lwO4Rtym2SSjokqU41ZakUY4wqyI4SLB4znyzdW83iMZOkAlm6N7gxRpM25rkdo0a5r2O4rctaoSzdw4/lrGpY1iqPZa3yLF7OrK2dktXbHdaOm8VjZi2Lx4w5QdVYPW7Uz8qxuH46snTPSIvXz0JJD0qa6HaQQIwxjuM4Vv5O3WTlZAQAAAAAAAAAqgtNUgAAAAAAAABBjSYpAAAAAAAAgKB2UjdJ09PTdfHFFyspKUlt2rTR9OnT3Y5UIxw6dEj9+/dXYmKikpKStGbNGrcjWWn48OGKj49X27Zti+/7+eef1b17d7Vq1Urdu3fXwYMHXUxon1fH3qCHujXRtKuTSz226v+m6r6O4fIe3O9CMnsFWs7S0tLUuXNnJScnq1OnTlq3bp2LCe1z6Kd0PfOn7prat50e799Bq1+aKUl6+/F7NbVvW00f0FEvju6v7MxDLie1S3k1c+bMmTrzzDPVpk0b3XPPPS6mtEt+bo5mX3uupg9M1eP9O+i9f46TJGX98rOeG3W5plzZWs+NulzZGdSCI3JycnTWWWepQ4cOatOmjcaMGXPM41OmTJExRvv3UwuOKGvMqAUV8/l8SklJUe/evSVJd999txITE9W+fXv16dNHhw5RBwIpOW4SdaA8CQkJateuXfG6KDEnOB6P9GqlaQNSNGNQJ80a2vmYx5gXBBZoWaMWlC9Qb4NagPKc1E3S0NBQPfbYY9q2bZvWrl2r2bNn68svv3Q7lvXuuOMO9ejRQ//5z3+0efNmJSUluR3JStddd52WLl16zH2TJ09Wt27d9NVXX6lbt26aPHmyS+nslHrFH3X9rDdL3X/op3R9vfYD1W14mgup7BZoObvnnns0ZswYpaWlafz48UxWSvCEhKrnnx/VXxZ+oZtf+FhrFvxTe779Umd07qY7FqTpjgUbdepprbRyziNuR7VKWTVzxYoVWrx4sT7//HNt3bpVd911l9tRrREaHqGRTy3THf/eoNvnr9eONcv0w+ef6sPnH1XLsy7WXYu/VMuzLtbK5x91O6o1IiIitHz5cm3evFlpaWlaunSp1q5dK8nfqH/vvfd02mnUgqOVNWbUgopNnz79mO3Y7t27a8uWLfr888/1u9/9TpMmTXIxnb1Kjht1oGIrVqxQWlqa1q9fL4k5wfG64an3dPvL63XrvLXF9zEvKF/JZY1aUL5AvQ1qAcpzUjdJGzVqpI4dO0qSatWqpaSkJO3atcvlVHbLyMjQqlWrNGLECElSeHi46tat63IqO3Xp0kVxcXHH3Ld48WINGzZMkjRs2DC9/vrrbkSzVovUCxRdp97/t3fn0VFV6frHn1OpTJWByBAZEgZbhEiQyRCcULChQbkig4ig4oBevA44oOC9/ROHBhRQUOSioCKCLU7dDYJGxTAZjQghIOIFGghNkFEZU5mq6vz+iKYJZCAYOTvU97NWr6WntHx6s895a791zq6Tji9+fpR6PzhesvhxvROVN88sy9KRI0ckSYcPH1bjxo2diGas2AaN1CSpgyQpPCpG8S1a68i+H3XBJT0U4i75ceambVN1eB/14HgV1cwZM2ZozJgxCg8PlyTFx8c7GdMolmUp3BMtSfL7ihXwFUuWpY3LP1LHPrdIkjr2uUUbly10MqZRLMtSdHTJmBUXF6u4uFjWL9f+hx56SBMnTiz9e5SoaMyoBZXLwI/gTwAAIABJREFUzc3V4sWLNXz48NJjPXv2lPuXOtClSxfl5uY6Fc9Y5Y0bdaD6WBOcPtYF1UMtqFhFvQ1qASpzVjdJj5eTk6O1a9cqNTXV6ShG27Ztmxo0aKDbb79dHTp00PDhw5WXl+d0rFpj7969atSokaSShsO+ffscTmS+jcs/Umx8EzW6oJ3TUWqNqVOn6tFHH1ViYqJGjRrFt5+VOPhjjn7ctE6JyZ3LHF+94E21uvRPDqUy3/E1c/PmzVq5cqVSU1N15ZVX6ttvv3U6nlECfr9eGnyxxv2xic5PvVpN23bWsZ/2KbZBSS2IbdBIx37e73BKs/j9frVv317x8fHq0aOHUlNTtXDhQjVp0kTt2lELylPemFELKvfggw9q4sSJcrnKX+688cYb6t279xlOZb7yxo06UDnLstSzZ0916tRJM2fOlMSa4FRYlqU37r1G04akatWHr0liXVCV8uYataBip9LboBbgREHRJD127JgGDBigqVOnKjY21uk4RvP5fMrKytI999yjtWvXKioqisdD8Lspyvdq6evPqseIsVX/wyg1Y8YMTZkyRTt37tSUKVNKvx1FWYXeY5o36kb1eWSyIqL/fe1f+toEudxutb9miIPpzHVizfT5fDp48KAyMzM1adIkDRo0SLZtOx3TGK6QED0wf7XGpG1X7verteefG5yOZLyQkBBlZ2crNzdXq1at0vr16zVu3Dg9/fTTTkcz1oljtmHDBmpBJRYtWqT4+Hh16tSp3NfHjRsnt9utoUOHnuFkZqto3KgDlcvIyFBWVpY++eQTTZ8+XStWrHA6Uq0wYvYy3f/XVbr95Y/09XsztH3NStYFVShvrlELKlZVb4NagPKc9U3S4uJiDRgwQEOHDlX//v2djmO8hIQEJSQklN5xO3DgQGVlZTmcqvY499xztXv3bknS7t27eRypCj/nbtXBXTl6cfDFeu7aljqyL1fThqbq6IE9Tkcz2pw5c0qvZzfccAMbtJfDX1yst0fdqPbX3KTkq/uVHl/z0Vv6YeXHuvEvb/FIbznKq5kJCQnq37+/LMtS586d5XK5+FGdckTGxKlFp67a/NVniq4XryP7S2rBkf27FV23gcPpzBQXF6errrpKCxYs0Pbt29WuXTs1b95cubm56tixo/bsoRac6NcxS0tLoxZUIiMjQwsXLlTz5s01ePBgpaen6+abb5ZUUkMXLVqkt99+mzpwgorGjTpQuV8fb46Pj1e/fv20atUq1gSnILZBybhF141Xm259tS1rBeuCKpQ316gFFaust0EtQEXO6iapbdu68847lZSUpIcfftjpOLVCw4YNlZiYqE2bNkmSvvjiC1144YUOp6o9rrvuOs2ZM0dSyYW3b9++DicyW8OWbfXnL3Zp9OItGr14i2LjE3T/298opn5Dp6MZrXHjxlq+fLkkKT09XS1btnQ4kVls29aHT9+tBi1a64qbHyw9vinjU614c7Junfo3hUV6HExopopq5vXXX6/09HRJJY9cFhUVqX79+k7FNMqxg/uVf7TkF1GLC/K19Zt0NWjeSkld/0NZi+ZKkrIWzdWFV/6HkzGNsn///tJfkc3Pz9eSJUvUoUMH7du3Tzk5OcrJyVFCQoKysrLUsCG1QCp/zFq3bk0tqMSECROUm5urnJwczZ8/X927d9e8efOUlpam5557TgsXLpTHQx04UUXjRh2oWF5eno4ePVr615999pmSk5NZE1ShKD9PhXlHS/96S+YSJVx4MeuCSlQ016gFFauot0EtQGXcTgf4PWVkZGju3Llq27at2rdvL0kaP368rrnmGoeTmW3atGkaOnSoioqKdN5552n27NlORzLSTTfdpGXLlunAgQNKSEjQU089pTFjxmjQoEF6/fXX1bRpU73//vtOxzTKO4/frO1rVijv0AFN6NVCfxzxhFKuv93pWEYrb57NmjVLI0eOlM/nU0REROmeRCixI/srrV38thqen6yXBl8sSep53zP6aOLD8hcX6o17SvYdSmybqn7/M93JqEapqGbecccduuOOO5ScnKywsDDNmTOHb9x/cXT/br0/9k7Zfr9sO6C2PQYqqeu1anpRF70zeohW/+NNxTVM1JCJ7zgd1Ri7d+/WsGHD5Pf7FQgENGjQIPXp08fpWEaraMzi4uKoBdV03333qbCwUD169JBU8oMdr7zyisOpzEcdqNjevXvVr1/JEys+n09DhgxRr169lJKSwpqgEsd+2qu5j9wgSQr4fWrfa7BaXcZe8ZWpaK5FR0dTCypRXm8jJSWFWoAKWVXsJ3NIUp0zlKVaLMtiL5xqMnjM/JJCnA5RHoPHTJJ8MvSLDsuyNCGryOkYtcrjHcNMnWsBGfrUAfPs9DDXqo+5Vn0GzzNja6dk9OcOY8fN4DEzlsFjxprg9Bg9btTP6jG4ftqSjPx2xODzMyDpCUnjnA5SHsuybNu2jfwzdZKRixEAAAAAAAAAOFNokgIAAAAAAAAIajRJAQAAAAAAAAQ1mqQAAAAAAAAAghpNUgAAAAAAAABBjSYpAAAAAAAAgKBGkxQAAAAAAABAUKNJCgAAAAAAACCo0SQFAAAAAAAAENRokgIAAAAAAAAIajRJAQAAAAAAAAQ1mqQAAAAAAAAAghpNUgAAAAAAAABBjSYpAAAAAAAAgKBGkxQAAAAAAABAUKNJCgAAAAAAACCouZ0OAAC/l7h//VPnbspWXr2G2tXuEtkhIU5HgsHq7Nquhj9kKT+uvna2v0y2mxKJ0xdx6Cclrv1S/tAw/avTlfJFepyOBABAUKu/9XvV2/aDjjRsqt3JKZJlOR0JgGFYAdaQI0eOaOLEidqwYYOSk5M1evRoxcTEOB3LaLZta/bs2Vq0aJGrbt26euSRR5SUlOR0LON98803mj59uvLz80OGDBmifv36OR3JOO58r/o9NlhNVy+T3x0qBQI6Ztu6OzlFeV3+qCtuflDusHCnYxrN5/Pp5Zdf1rJly6wmTZpo9OjRatq0qdOxfhchRYW67vGbdV7GpwqEhkqSfGHhev+lhdrT5uJqvdc/v/lCqxe8KUlKuf4O/aFzt5qOe9bJycnRxIkTtXv3bqtbt2669957FVKbv9CwbV326jO6ZPYk+cPCJFly+Yv18Z9f0Q/X3FQj/4niwgKtnDtFuzauUd2EFrrq9tGKOqd+jbz32cq2bf3tb3/T/PnzQzwej+677z6lpKQ4Hct433//vV544QUdPHgwpG/fvrr11ltl0VSo1OHDh/Xcc89p48aNatu2rR577DHWBFUIBAKaPXu2Fi9e7KpXr54eeeQRtW7d2ulYxsvMzNT//u//qqCgwDV06FD17dvX6UjGCj9yUIPuv04NNq9Xsd8n2QEdjqqjv81epmMtmGuV8fl8mjZtmpYvX24lJCRo9OjRSkxMdDqW8T777DPNnj3b2rp16w3ffvtthm3by5zOhFNj2bZd2euHJNU5Q1mqxbIsVZH9jPF6vWrXrp127typwsJCRUREKDExUdnZ2fJ4zLlzxKQxk6T77rtPs2fPltfrlWVZ8ng8WrlypTp06OB0tFKmjdnnn3+uvn37Kj8/X5Lk8Xg0duxYPfbYYw4nK8uyLE3IKnLsv3/1pEfU/sNZCi0qKD0WkLRX0nlhEWrQqp1GvLFMLoMaMY93DDNqrvXt21dLliyR1+tVSEiIoqOjlZ2drebNmzsdrVRNzbOuLz+hlLdfVGhhfpnj+bF19fJnO+Q/xYZ61qJ5+sf4e1VcUPI+oRGR6v//XlX73oN/c8aaZNJc27p1qzp27Ki8vDz5/X55PB716tVLH374odPRyqjOXDvvy090/WM3KazAW+Z4cXiEXn83S4eanv+bsgT8fs247Qrt+ef38hXmyxUaqqg69TTyvbWKiqv3m967Jpk0zyRp3LhxGj9+vLzekj+XyMhILVq0SN27d3c4WVkmfe5YvXq1rrrqKnm9Xtm2raioKA0fPlxTp051OloZJo1ZXl6eLrroIu3atat0TdCsWTOtXbtWkZGRTscrZdKYSdKIESM0b9485eXlyeVyKTIyUhkZGWrXrp3T0UqZNmZpaWkaMGBA6TXN4/HomWee0cMPP+xwsrKcXhP86vpHB+v85R/J7SsuPeaXtDU8Uh98+TNrggrYtq0+ffpo2bJl8nq9crvdio6O1rp164y6ecK083P27Nm67777Ss9PSV5Jt9u2/Z6DsU5iWZZt2zbffJ6APUlrQEZGhvbu3avCwkJJUkFBgfbs2aOvvvrK4WTmsm1br776aumFw7Zt5eXlaebMmQ4nM9vkyZNLG6RSSYP++eefdzCRmZIXzyvTIJVKLnYeSR2KCrRny3c6sGOzI9lqg59++klpaWml56ff71deXp7ee8+oul5j2n701kkNUkly+X1KWPvlKb/P8jcnlTZIJam4IF/L35xUIxnPVvPnzy9tkEol17SPPvpIhw8fdjjZ6Wv39zdOapBKksvnU+slv735u2/bRu3b9oN8v8zZQHGxCvOOavNXn/7m9z6bTZky5fjFivLz86mfVXjllVeUl5dXuvDMy8vTjBkzHE5ltpUrV2r//v1l1gQ//vijMjMzHU5mLr/fr9dff115eXmSSu4qzcvL0+uvv+5wMrNNmjSpzDXN6/Vq8uTJDiYyWCCgC5YuKNMglaQQSQmF+bJXL3MkVm2wf/9+ffHFF6Vzzefzyev16oMPPnA4mdmeffbZMuenSpahYxyKg2qiSVoDoqOjFQgEyhwLBAKKiopyKFHtEB5e9u4st9ut2NhYh9LUDrGxsXK5yp62Jt2tbIriyPLPPbekI5LsQEBhFfwzkCIiIk46FhoaqujoaAfS/P6KKpgLVsCvIs+pPyIZXs4/W94x/FtMTIxCf9ni4Hgn1ofapDAmTgHXyR+v/O7Qas2nioRFRikQ8Jd7HBU7sVa6XC7FxcU5lKZ2iI2NlfuEvZnLqw/4t6ioqHLXBGdr/awJLpfrpDoQGhrKFgVVKG9NwNqzApYlX3j51y6XJBn0FIZpIiIiTrqmhYSEMNeqUM71y1bJMhS1AE3SGtClSxddd911ioqKksfjUVRUlPr27asuXbo4Hc1YlmVp5syZioyMVFRUlGJiYpSQkKBRo0Y5Hc1ozz33nOrWravo6GhFRUUpKipKr732mtOxjJNx5xgVRZRdEBdI+s5yaXOER5cMvldxjcx5RMQ0UVFRGj9+fOn5GR0drVatWmnYsGFOR/tdZNz1PyfNF587VIeatCjZ1P8U9R3zksKjYhQWGaUwT5TCo2J13RizHks1ze23366WLVuWXtM8Ho8mTZpUqxsxq24eKV9Y2fwBy1IgNFTf18CepHUTzlPqwLsVGuEpmWuR0Wp6URe1vvya3/zeZ7PXXntNHo9H0dHRio6OVv369TVu3DinYxlt9OjRaty4cen5GRkZqVmzZjkdy2iXXXaZrr322jJrgv79++vii6u3v3UwsSxLr776apnPHImJiXrooYecjma0SZMm6Zxzzim9pkVFRXF+VsSytGroyJM+63klrWraUiGt2juTqxaIjY3VX/7yl9LrWXR0tJKSknTLLbc4Hc1oM2bMUExMjKKjoxUWFlakkgbpA07nwqlhT9IaYtu2li9frq1bt+oPf/iDrrzySuM2tjdtzCRp8+bN+vLLLwOxsbGua6+91qj9miQzx+zQoUNKS0tTYWGhv1u3biEm7QfzK8f3H7JtdXrnZV02a5zC8kse31qT3Fkv/7G/YpM7K7Eaja8zxaT9h361bt06rV692m7QoIF1zTXXnHRHkdNqcp61+2CWur7ypMKPlnzJu/XyXkr78wzlV/PHcI7+tFf/zFwiSWp5SQ9F142vkXw1ybS5VlxcrI8//lgHDhywU1JSrIsuusjpSCep7lxr+u0y/WncvYr7MUeStLd1ey1+cpZ+Ou/CGsv0r/XfaO+2jaoT30QtL+lh3GcO0+aZJO3YsUNLly71R0REhPTu3Vt16pj3Ede0zx1er1eLFy/WsWPH/JdffnlIy5YtnY50EtPGzLZtLVu2TNu2bVPLli3VtWtXpyOdxLQxk6RNmzYpIyMjUKdOHde1115r3JdlJo7ZoUOH9Mknn6ioqCjQvXt3l4k/puP4muBXgYAum/kXpbz9klyF+bIlfXt5b2WOnytfhFnrTxPrZ3Z2ttasWWPHx8dbvXv3NnJNYNqY7dmzR59//rm9YcOGDyZOnHivbdv7nc50IvYkLR9N0iBi8Jj5VbItjHEMHjNJ8qnkCXLjmPSBKPLwzyqKijnlH99xiokfiH4RkKFPHdT4PLNtRR76SUWeaPkreCzrbMBcq77TnWvhRw7KDnGrKCr4Hhs1eJ4ZWzsloz93GDtuBo+ZsQweM9YEp8focTNiTfALy+9XxJGfVRhdR4HQMKfjlMvg+mlLMrKhZvD5GZD0hCQjH12hSVo+Iz/sAECNcLmqfScggphlMV9Qowpjz3E6AgAA+IUdEqL8cxo4HQOAwYy8YwMAAAAAAAAAzhSapAAAAAAAAACCGk1SAAAAAAAAAEGNJikAAAAAAACAoEaTFAAAAAAAAEBQo0kKAAAAAAAAIKjRJAUAAAAAAAAQ1GiSAgAAAAAAAAhqNEkBAAAAAAAABDWapAAAAAAAAACCGk1SAAAAAAAAAEGNJikAAAAAAACAoEaTFAAAAAAAAEBQo0kKAAAAAAAAIKjRJAUAAAAAAAAQ1GiSAgAAAAAAAAhqNEkBAAAAAAAABDWapAAAAAAAAACCGk1SAAAAAAAAAEGNJikAAAAAAACAoEaTFAAAAAAAAEBQo0kKAAAAAAAAIKjRJAUAAAAAAAAQ1GiSAgAAAAAAAAhqNEkBAAAAAAAABDWapAAAAAAAAACCGk1SAAAAAAAAAEGNJikAAAAAAACAoOau4vUYSb4zEeQ0uGVmNlNzSeZmc0uyJfmdDlIOU8csROZmk6q+tqB8Jv55uiUFfvmfaZhnp8+0uWap5LpmWq5fMddOj4l/niZ/5pDMrO0umZnrV6ZmMzWXZG42k89PU8csRNTPs5GJf56mrwlMHDOXpGZOh0D1WLZtV/hiQtNm9q6d/zqDcQCcDdxh4fIVFTodA2c55hnOFOYaAADVR/0EjLbDtu3mTocwTaVNUsuy7AlZRWcwTu33eMcwVTamKJffsqwQxq16LMsS52f1cH6eloBlWS7mWvUw16qPa9rpYa5Vm8+yLDdjVj2WZTHPqokxOy2sCU4Dc636GLPTYluWVWn/CCcJWJblsm3bcjoITh17kgIAAAAAAAAIajRJAQAAAAAAAAQ1mqQAAAAAAAAAglqNNUkDfr9euilFbz5wfU295VlvypQpatOmjZKTk3XTTTepoKDA6UjGueOOOxQfH6/k5OTSY48++qhat26tiy66SP369dOhQ4ccTGieD568S3+5uomm3tC+zPGv5k/X8/3aaMrAdvpk6hiH0plp586d6tatm5KSktSmTRu9+OKLkqSff/5ZPXr0UMuWLdWjRw8dPHjQ4aRmObRnp2bd3UMv9G+rKQPbKeOv08q8vuKtF/R4xzDlHTzgUELzVDTXsrOz1aVLF7Vv314XX3yxVq1a5XBScxQXFmj6LZfqxRs7acrAdvp8xlOSpI+njNEL/ZP14qCOmvvIQOUfpRYcr6CgQJ07d1a7du3Upk0bjR07tvS1adOmqVWrVmrTpo0ee+wxB1Oaye/3q0OHDurTp48kasGpOHHMfjV58mRZlqUDB6gDJzpxzKgDVWvevLnatm1bOkYS64KqlDdmEnWgMocOHdLAgQPVunVrJSUl6euvv6YOnILyxu1X1ALUJjXWJM14Z5riW7Suqbc76+3atUsvvfSSVq9erQ0bNsjv92v+/PlOxzLObbfdprS0tDLHevTooQ0bNmj9+vW64IILNGHCBIfSmanTf9yq219eVObY1m+XaeOyjzTy3Sw99ME6XXHrww6lM5Pb7dbzzz+vH374QZmZmZo+fbo2btyoZ599VldffbW2bNmiq6++Ws8++6zTUY3iCnHrmocm6uG/faf/mvOlvn5vhvZu2yippIH6z8wvFNewqcMpzVLRXHvsscc0duxYZWdn6+mnn2bBchx3WLiGv/qZRr67Rg+8s1qbv/5M/1r/jc7vcrVGvpetke9lqX7Tllr2xnNORzVKeHi40tPTtW7dOmVnZystLU2ZmZlaunSpFixYoPXr1+v777/XqFGjnI5qnBdffFFJSUmlf08tqNqJYyaVfCn0+eefq2lT6kB5Thwz6sCpWbp0qbKzs7V69WpJrAtOxYljRh2o3MiRI9WrVy/93//9n9atW6ekpCTqwCkob9wkagFqnxppkh7em6tNKz9RyvV31MTbBQ2fz6f8/Hz5fD55vV41btzY6UjG6dq1q+rWrVvmWM+ePeV2uyVJXbp0UW5urhPRjNWi0xXy1DmnzLFvPnhVV93+qNxh4ZKk6LrxTkQzVqNGjdSxY0dJUkxMjJKSkrRr1y4tWLBAw4YNkyQNGzZM//jHP5yMaZzYBo3UJKmDJCk8KkbxLVrryL4fJUmLnx+l3g+Olyx+zPF4Fc01y7J05MgRSdLhw4epB8exLEvhnmhJkt9XrICvWLIsXXBJD4X8Uguatk3V4X27nIxpHMuyFB1dMm7FxcUqLi6WZVmaMWOGxowZo/DwknoQH089OF5ubq4WL16s4cOHlx6jFlSuvDGTpIceekgTJ06URR04SXljRh04PawLqo86ULEjR45oxYoVuvPOOyVJYWFhiouLow5UoaJxk6gFqH1qpEm6aPIj6j1ygiwXW5yeqiZNmmjUqFFq2rSpGjVqpDp16qhnz55Ox6p13njjDfXu3dvpGMY7sGOLtmd9qem3XqaZw6/Wzu9XOx3JWDk5OVq7dq1SU1O1d+9eNWrUSFJJc2vfvn0OpzPXwR9z9OOmdUpM7qyNyz9SbHwTNbqgndOxjHb8XJs6daoeffRRJSYmatSoUdwJc4KA36+XBl+scX9sovNTr1bTtp3LvL56wZtqdemfHEpnLr/fr/bt2ys+Pl49evRQamqqNm/erJUrVyo1NVVXXnmlvv32W6djGuXBBx/UxIkT5TruMy21oHLljdnChQvVpEkTtWtHHShPeWNGHaiaZVnq2bOnOnXqpJkzZ570OuuCk5U3ZtSBim3btk0NGjTQ7bffrg4dOmj48OHKy8ujDlShonGjFqA2+s1dzR9WLFZU3Xg1ubBjTeQJGgcPHtSCBQu0fft2/fjjj8rLy9O8efOcjlWrjBs3Tm63W0OHDnU6ivECfp/yjx7Sf835Ur0ffFbvjB4i27adjmWcY8eOacCAAZo6dapiY2OdjlNrFHqPad6oG9Xnkclyhbi19PVn1WPE2Kr/xSB24lybMWOGpkyZop07d2rKlCml38SjhCskRA/MX60xaduV+/1q7fnnhtLXlr42QS63W+2vGeJgQjOFhIQoOztbubm5WrVqlTZs2CCfz6eDBw8qMzNTkyZN0qBBg6gHv1i0aJHi4+PVqVMnp6PUGuWNmdfr1bhx4/T00087mMxcFc0z6kDVMjIylJWVpU8++UTTp0/XihUrSl9jXVC+8saMOlAxn8+nrKws3XPPPVq7dq2ioqJ4tP4UlDduTz75JLUAtdJvbpLuWPeVfli+SM9d21LvPH6ztq1eqnf/Z1hNZDurLVmyRC1atFCDBg0UGhqq/v3766uvvnI6Vq0xZ84cLVq0SG+//Ta37p+C2PgEJXe/XpZlKTE5RZbLpbxDbJx9vOLiYg0YMEBDhw5V//79JUnnnnuudu/eLUnavXs3jyOVw19crLdH3aj219yk5Kv76efcrTq4K0cvDr5Yz13bUkf25Wra0FQdPbDH6ajGKG+uzZkzp/Svb7jhBn6wowKRMXFq0amrNn/1mSRpzUdv6YeVH+vGv7xFLahEXFycrrrqKqWlpSkhIUH9+/eXZVnq3LmzXC4XP6Twi4yMDC1cuFDNmzfX4MGDlZ6erptvvplaUInyxuyWW27R9u3b1a5dOzVv3ly5ubnq2LGj9uyhDkgVzzPqQNV+3YIgPj5e/fr1Kx0j1gUVK2/MqAMVS0hIUEJCglJTUyVJAwcOVFZWFnWgChWNG7UAtdFvbpL2un+cHk/brtGLt+imCfN03sXddOO4OTWR7azWtGlTZWZmyuv1yrZtffHFFydteI/ypaWl6bnnntPChQvl8XicjlMrtOl2nbZ+u1SStH/HZvmLixQVV9/hVOawbVt33nmnkpKS9PDD//5Rq+uuu05z5pRcz+bMmaO+ffs6FdFItm3rw6fvVoMWrXXFzQ9Kkhq2bKs/f7FLoxdv0ejFWxQbn6D73/5GMfUbOpzWDBXNtcaNG2v58uWSpPT0dLVs2dKpiMY5dnB/6S/XFxfka+s36WrQvJU2ZXyqFW9O1q1T/6awSGrBifbv31/6K8/5+flasmSJWrdureuvv17p6emSSh65LCoqUv361ANJmjBhgnJzc5WTk6P58+ere/fumjdvHrWgEuWN2Ycffqh9+/YpJydHOTk5SkhIUFZWlho2pA5IFc8z6kDl8vLydPTo0dK//uyzz5ScnMy6oBIVjRl1oGINGzZUYmKiNm3aJEn64osvdOGFF1IHqlDeuHXs2JFagFrJ7XSAYJWamqqBAweqY8eOcrvd6tChg+6++26nYxnnpptu0rJly3TgwAElJCToqaee0oQJE1RYWKgePXpIKtmk/ZVXXnE4qTneefxmbV+zQnmHDmhCrxb644gn1Knvbfrwybs09Yb2CgkN0w1Pvc437cfJyMjQ3Llz1bZtW7Vv316SNH78eI0ZM0aDBg3S66+/rqZNm+r99993OKlZdmR/pbWL31bD85P10uCLJUk973tGrS9nP7CKVDTXZs2apZEjR8rn8ykiIqLcvdaC1dH9u/X+2Dtl+/2y7YDa9hiopK7XatJ1SfIXF+ptqcywAAAOuUlEQVSNe0rmW2LbVPX7n+kOpzXH7t27NWzYMPn9fgUCAQ0aNEh9+vRRUVGR7rjjDiUnJyssLExz5syhHlSBWoAzgTpQub1796pfv36SSh7tHTJkiHr16qXzzz+fdUEFKhoz6kDlpk2bpqFDh6qoqEjnnXeeZs+eXVpHqQMVK2/cgNrIqmz/Ecuy7AlZRWcwTu33eMcw9nSpPr9lWSGMW/VYliXOz+rh/DwtAcuyXMy16mGuVR/XtNPDXKs2n2VZbsaseizLYp5VE2N2WlgTnAbmWvUxZqfFtiyr0v4RThKwLMtl2zbfQtQi/Bw9AAAAAAAAgKBGkxQAAAAAAABAUKNJCgAAAAAAACCo0SQFAAAAAAAAENRokgIAAAAAAAAIajRJAQAAAAAAAAQ1mqQAAAAAAAAAghpNUgAAAAAAAABBjSYpAAAAAAAAgKBGkxQAAAAAAABAUKNJCgAAAAAAACCo0SQFAAAAAAAAENRokgIAAAAAAAAIajRJAQAAAAAAAAQ1mqQAAAAAAAAAghpNUgAAAAAAAABBze10ABNEHjyg5t8skRUIaEfn7sqr39DpSABqgLsgXy0yP1fEkUP6MTnF6Tg4i4V6j6nF158rzHtUu9pd4nQc/A5if9yhplkr5AuL0PZLeqowpo7TkQAAAADUoFrVJA0EAlr14Wv6Pv1vCouMVtdho9SsXZff9J4pc6foyulPyO8Ok2QrxFesb259RCvvGStZVs0Ed9jXX3+tiRMn6tixYxo4cKDuuusuuVzcRFyZPXv26IknntCWLVvUoUMHjR07VnXqsCCujL+4WF/Om6otmZ8r6pwG6jb8cTU8P9mxPM2++UL9HxkkWZasgF9WIKCGklRQIEVEOJbrRGlpaXr55Zfl9/t122236cYbb3Q6kvF+zt2mJa8+o8N7c9W8w+W66vbHFBoR6Vie85ct1HX/favskBBZgYCsgF9xklRcLIWGOpbreF6vV+PHj9dXX32lxMREPfXUU2revLnTsYxm27bWffqe1i6Yo6d2bFL/A3tkh4VLsuTyF+vT/56uDf9xi9MxjbN+/XqNGzdOBw4cUK9evfTQQw/J7a5VHzfPuEOHDmns2LFav369WrVqpaefflrx8fFOxzJaIBDQK6+8or///e+KiYnR6NGjlZqa6nQs43355ZeaPHmy8vLyNGjQIA0fPlzWWbLe+b3s3r1bY8eO1ZYtW9SxY0eNHTtWsbGxTscyWnFxsSZPnqwlS5aoQYMGeuKJJ3ThhRc6Hct4H3/8saZPn65AIKA777xTAwcOdDqS8bZu3aonn3xSu3bt0hVXXKHHH39cEQat81A7WbZtV/yiZdkTsorOYJzKfTTpEX3799dVXOCVJIWGR2rYSwv0h5SrTuv9Gm5co6HDuyu0IL/M8aJIjz584UPtSL262u/5eMcwVTamZ1p6err69Omj/PyS/48ej0d33323pkyZ4nCyMvyWZYWYMm4///yzLrzwQv3000/y+XwKDw9Xs2bNtH79eoWHhzsdr5RlWTLp/Jz3yA3a/PVnKi7IlyxLYREejZi9XI0uuOiMZwk7dkT3/am5wvKPlTnuleR58klp7Ngznqk8f/3rX3XXXXfJ6y25pnk8Hj3zzDN6+OGHHU5WRsCyLJcpc+3gjzl6aXCKCr3HZAf8codHqknr9vrPN5Y5stCLPLhf/3XN+QotLFtH8iRFTZkiPfjgGc90okAgoEsvvVTr1q1TQUGBQkJCFBMTo/Xr1ysxMdHpeKVMu6Yte3Oy0mf+RTcUePWqpOgTXi8Oj9Br72frcMJ5TsQrZdLnjuzsbF1++eXyer2ybVsej0d9+vTRu+++63S04/ksy3KbMmb5+flq27atcnNzVVhYqNDQUNWvX18bN25UXFyc0/FKWZZlzDyTpHvvvVdvvvlmmfr58ccf68orr3Q42b+ZNmZLlixR3759S8csKipKI0aM0OTJkx1OVoZRa4IDBw6oTZs2OnjwoIqLixUeHq4WLVpo3bp1CgsLczpeKdPmWt++fbVkyRJ5vV5ZliWPx6PMzEwlJzt388SJTBuzuXPnasSIEWWuaRMmTNADDzzgcLIybMuyKu0fnUnbtm1Thw4ddOzYMQUCAUVGRiolJUXLljmzJqhAwLIsl23bxgRC1WrV7YSr//FGaYNUkooL85X5/qun/X5Jn74nd2HBScfD8r1KXvz2ab+vSV555ZXSBqlUcjfRa6+95mAi8y1dulRer1c+n0+SVFhYqN27d2vt2rUOJzNXcWGBNq5YVNIglSTbVlGBV+s+fc+RPM1Xpct2nVyLPJL01ltnPE9FXnzxxdIPQ1LJ+Tlt2jQHE5nvhxWLVVxUIDvglyT5CvO16//W6vDeXEfy/CEjTXY5d+ZHSdLs2Wc8T3l27Nih7777TgUFJfXO7/eroKBAixYtcjiZ2TLf/V8VF3h1m05ukEqSFQjogmULz3Aqs82bN095eXmlC0+v16sPP/xQRUXmNL9Ns2bNGu3bt0+FhYWSSu7AOnbsmJYvX+5wMrPNnj37pPo5c+ZMBxOZb/r06WXGLC8vT7NmzXIwkfnS09Pl9XpVXFwsqWRNsGvXLq1fv97hZObKy8vTxx9/XDrXbNuW1+s17csy45S3JnjppZccTGS+BQsWqKCgQIFAQFLJl46rVq3S7t27HU6G2q5WNUnDPGWXKa4Qt6LOqX/a7+eNqydf6Ml3Bvrcoco75+x4zKlevXonPeYWExPjUJraoU6dOqUX21/5fD6j7ugwTYg7VC5X2XnmDg2TJ/YcR/Lk16krVfQtZ926ZzZMJerWrXvS1hd1DcpnoojoWLlcIWWO2YGAwj3ltbF+f/mxdWVbFZTSBg3ObJgKxMTEyO/3lzkWEhLCNa0KETEl47NPkr+c1wPuUBXEcr4er27duic9cREaGsrj9pWIi4s76fwMBAKcn1WIji57zXe73apf//TXBMGgfv36rAmqqU6dOifdbejz+diCqxLh4eEnfbYNDw/n820V6tate9Ldj4xZ5eLi4k66pgUCgZPqA1BdtapJOuiZ2QqLjFJ4VIzCPTGq0zBRf/zP/3fa77f++jvkDwtT4LgLki0pEBaurMH/VQOJnffkk08qMTFRMTExio2NVVRUlN4y6E46E3Xv3l19+/ZVVFSUYmJi5PF4dP/996t169ZORzOWKyREA8bOVGhEpMKjYhTmiVZ8iySl3vCfjuTZ2fEKHWnUTL7Qso9C5UnS0087kqk806ZNU/369RUTE6OYmBjVqVOHO72rcNGfblTTtqkKi4xWeFSMQsMj1XvkBEU61JDfdumf5D2nvvzusnuP5knSE084kulE9evX17hx4xQZGamYmBhFR0frsssuY6+rKgx8cpbCo2I1JdKjE5858btCVBzh0Q89GMPj3X///WrVqpWio6MVGxuryMhIzZkzh33QK5GcnKwRI0bI4/EoJiZGUVFRGjBggLp27ep0NKPNnTtXHo9HsbGxiomJUbNmzfTnP//Z6VhGe+aZZ9SkSZMya4K5c+c6HctoPXr00LXXXltmTfDggw+qZcuWTkczltvt1qxZsxQZGanY2FhFR0erTZs2uvvuu52OZrSXX35Z9erVK10TxMXFcad3FYYMGaKUlBRFR0crJiZGkZGReuGFF9gzGL9ZrdqTVJKO7P9R/1qfKXd4pP6Q0k2h4b9tY956237Qn8bfp4TsryRJu9tcrM8ef0l7W3c4rfczaW+wXxUUFCg9PV35+fm65JJL1LhxY6cjncio/Yd+lZmZqX/961+64IIL1L59e6fjnMS0/fsk6edd27Vr4xpFxMTpDynd5AoJqfpf+p1EHP5ZPZ57UK3S/y6Xr1iHmrTQnTu36u+GzbOjR49q6dKlCgQCuuKKK1SvXj2nI53IqD1JpZJHt7ZnrdSxn/aqYcu2im/h7BcYnp/2quezD+j8FYvl8vn0c7OWuiVnkz4xbK798MMP+u6773Tuueeqa9euJu3XJMnMa1rewQPKWfulknI26fa0d3Xuto2yXSHK6dxdn/73yzrSuJnTEY373OHz+ZSenq7Dhw8rJSXFxB8IM2pP0l+tXbtWW7ZsUbNmzYz8ASLT9u+TpF27dikzM1Mej0fdu3c3at94ycwxy8/P19KlS5Wfn69LL71UjRo1cjrSiYxbE9i2rczMTO3cuVOtW7fWRRed+b32q2LiXNu2bZvWrFmjc845R926dVOIg2uC8pg4ZkeOHNGyZcsUCATUtWtXE+8kNWpPUqnkztHly5dr//79ateunVq1auV0pBOxJ2ktVOuapL8Xy+eTZdsK/MZfIjZtsVJLGPeBqDYwsaFgpEBAIb5i+cPCOT9Pj3FNUlNZfr9cfh9z7TTVhmuaq7hItitEtkGLPeZatRnZJDWdiQ0F0zFmp4U1wWlgrlUfY3ZajGuS1gI0SWshNon6he12i9MdOAu5XPKHmXV3Cc5OdkiI/AY1z1DzAqHm/JoxAAAAgJrFJlEAAAAAAAAAghpNUgAAAAAAAABBjSYpAAAAAAAAgKBGkxQAAAAAAABAUKNJCgAAAAAAACCo0SQFAAAAAAAAENRokgIAAAAAAAAIajRJAQAAAAAAAAQ1mqQAAAAAAAAAghpNUgAAAAAAAABBjSYpAAAAAAAAgKBGkxQAAAAAAABAUKNJCgAAAAAAACCo0SQFAAAAAAAAENRokgIAAAAAAAAIajRJAQAAAAAAAAQ1mqQAAAAAAAAAghpNUgAAAAAAAABBjSYpAAAAAAAAgKBGkxQAAAAAAABAUKNJCgAAAAAAACCo0SQFAAAAAAAAENRokgIAAAAAAAAIajRJAQAAAAAAAAQ1mqQAAAAAAAAAghpNUgAAAAAAAABBjSYpAAAAAAAAgKBGkxQAAAAAAABAULNs2674Rcuq+EUAAAAAAAAA5bJt23I6A05dpU1SAAAAAAAAADjb8bg9AAAAAAAAgKBGkxQAAAAAAABAUKNJCgAAAAAAACCo0SQFAAAAAAAAENRokgIAAAAAAAAIajRJAQAAAAAAAAS1/w/ErKmQh1G9aAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABUkAAAFfCAYAAABz3E2sAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3hUZfrG8fud9EKLEKoaVlEiLRBUbKhgFAELZaliAV172bXsqqsgqKDrojTL6sLuTxBEBUURRERAEURKcEFElhUNEKWbMGmTyfn9MSGGkAQmBs4b5vu5Lq7gzOTM7cOZ8573mVOM4zgCAAAAAAAAgFDlcTsAAAAAAAAAALiJJikAAAAAAACAkEaTFAAAAAAAAEBIo0kKAAAAAAAAIKTRJAUAAAAAAAAQ0miSAgAAAAAAAAhpNEkBAAAAAAAAhDSapAAAAAAAAABCGk1SAAAAAAAAACGNJikAAAAAAACAkEaTFAAAAAAAAEBIo0kKAAAAAAAAIKTRJAUAAAAAAAAQ0miSAgAAAAAAAAhpNEkBAAAAAAAAhDSapAAAAAAAAABCGk1SAAAAAAAAACGNJikAAAAAAACAkEaTFAAAAAAAAEBIo0kKAAAAAAAAIKTRJAUAAAAAAAAQ0miSAgAAAAAAAAhpNEkBAAAAAAAAhDSapAAAAAAAAABCGk1SAAAAAAAAACGNJikAAAAAAACAkEaTFAAAAAAAAEBIo0kKAAAAAAAAIKTRJAUAAAAAAAAQ0miSAgAA1HDGmH8ZY5xSf/zGmF+MMVuMMe8aY+4yxpxUje/nGGMWV9fygnzvxcYYx433PhJjzBnGGG9xfaa6nQcAAABHL9ztAAAAAKg270lKL/57LUknS7pI0jWSnjLG3Os4zr9cynZCM8aES3pdUpHbWQAAABA8mqQAAAAnjnfLNkGLm3dDJY2TNMUYk+84znQ3wp3gHpGUIulBBWoNAACAGoTT7QEAAE5gjuMUOo7zD0l3FD801hgTU/Z1xpiBxphPjTH7jDF5xpiNxpi/GmOiSr3mxlKnul9c5hT/EWWWd64x5m1jzE/GmAJjTIYx5hVjTJPychpjEowxTxlj1htjcoovF7DOGDPGGBNnjEkqfu+Li19f+r0Xl1lWqjHmHWPMTmNMvjHmB2PMi8aYxuW878FLFfzOGHO3MeZrY0xuMJcTMMZ0lPSYpFGSvj7a3wMAAIA9OJIUAAAgNPxb0nBJp0rqImnuwSeMMf9U4GjTbZJmSdovqZMCTb+uxpg0x3EKFTiV/4ni5fwg6V+llr+41PJukvSqpHxJcyRlSGoh6WZJVxljOjmO82Op1zeX9GlxttWSXlLgy/wzJP1R0svFmZ6QdGPx654o9d5bSy2rp6R3JBlJbxfnTJV0u6RrjDEXOI6zVYcbp8ClCeZK+lCSv5zXHKa44fx/CtRmjKQLj+b3AAAAYBeapAAAACHAcZwiY8xnCjQYz1Fxk9QYc6MCDdLZkgY7jpN78HeKjw4dLulOSeMcx0mXlG6MGS5pq+M4I8q+jzHmDEmvKNC4vNhxnO2lnusi6WMFGpK9Sv3a1OJcjziOM7rM8upLOuA4Tp6kEcaYSySdWsF7xyvQuA2XdInjOJ+Veu7PCjQx/yHp8nJK1EFSe8dxvi/nucqMkfQ7SR0cxyk0xgT56wAAALABp9sDAACEjoMNywalHrtXUqGkoaUbpMVGSdojaXAQ73G7pAhJ95ZukEqS4ziLFDiy9CpjTC0pcGq8pPMVOBLzmbILcxxnd3GD9GhcI+kkSW+WbpAW+7sCjds0Y8wp5fzus8E2SI0xXSXdLelxx3G+CeZ3AQAAYBeOJAUAAAgdBw9zdCTJGBMrqZ2k3ZLuq+AoyHxJyUG8x3nFPy82xpxdzvOJksIUOJV+tQKn9UvSR47j/NY7w3co/rmo7BPFR3kulZQkqb2kH8u8ZGUwb2SMqStpiqQvFWjAAgAAoAajSQoAABA6Dt40aVfxz3oKNE4bKHBafXU4qfjng0d4XXzxz7rFP7dX9MIg1Cn+mVnB8wcfr1vOcz8F+V5jJdWXlOY4zlFdvxQAAAD24nR7AACAEGCM8UjqXPyfXxb//KX451rHcUxlf4J4q4PLrHOEZS4pft3+4p9Nq/5/d9h7N6rg+cZlXleaE+R7dZAUI+lbY4xz8I8CN6CSpMHFj6UHuVwAAAC4gCNJAQAAQsONkk5R4GjKTyXJcZwDxpgNkloZYxIcx9l7lMsqUuCU+fKsUOBu8gfvFH8kK4p/XmGMeeQoTrn3S5IxJqycIzjXFv+8RNI/Sz9hjAnXr3eeX3MUuY5klqRV5TzeWFJ3SVskLdbhp/UDAADAQhxJCgAAcAIzxoQbY26RNEmBoyX/WOZGSGMlRUqaXHydzbK/X88Y06HMw3sknVzBW06U5JP0fPGd7ssuL9IYc9HB/3YcZ7WkLySlSPpzOa8/yRgTXea9pUDDt6x3Je2VNNAY06nMc/cpcBf6hY7j/ObGpeM4Ix3HubnsH0l/K37JiuLHRv7W9wIAAMCxx5GkAAAAJ45rjTFJxX+PU6CReJECRzf+IulWx3HeLP0LjuNMLr7D/B2SthhjPlLg6McESc0VOEV/iqTbSv3aJ5IGGGPeV+DmS4WSljqOs9RxnG+NMUMlTZa0wRgzX9J3Ctzx/mCeXZJallredQocdfm0MaZP8d+NpBaSLi9+7dZS7/17SbOMMR9KypX0g+M4rxcfGTtU0luSlhhj3ir+f0ktXs5Pkm4Nop4AAAAIETRJAQAAThzXFP8pkuRVoBm5UtJCSW9UdDq94zh3GmPmKdAIvUyBGxvtVaDB+DdJU8v8yr0KHJXaVYFTyz2SnpC0tHh5U40x6yTdL+lSBRqUXkk7JL0tqWyj9vvio1UfknStpLsk5SnQGP27pJ2lXv6apFMlDSh+fbikJZJeL17We8aYCyQ9IukKBW7m9JOklyWNchxnR6UVBAAAQEgyjhPsNeoBAAAAAAAA4MTBNUkBAAAAAAAAhDSapAAAAAAAAABCGk1SAAAAAAAAACGNJikAAAAAAACAkEaTFAAAAAAAAEBIo0kKAAAAAAAAIKTRJAUAAAAAAAAQ0miSAgAAAAAAAAhpNEkBAAAAAAAAhDSapAAAAAAAAABCGk1SAAAAAAAAACGNJikAAAAAAACAkEaTFAAAAAAAAEBIo0kKAAAAAAAAIKTRJAUAAAAAAAAQ0miSAgAAAAAAAAhpNEkBAAAAAAAAhDSapAAAAAAAAABCGk1SAAAAAAAAACGNJikAAAAAAACAkEaTFAAAAAAAAEBIo0kKAAAAAAAAIKTRJAUAAAAAAAAQ0miSAgAAAAAAAAhpNEkBAAAAAAAAhDSapAAAAAAAAABCGk1SAAAAAAAAACEt/AjP50mKOh5BgpWUlKQffvjB7Rg1SlhYmPx+v9sxahRqVjXULXjULHhRMbHKz81xO0aNw7oWPGoWPGpWNWzXgse6FjxqFjxqVjVs04LHuhY81rOqCY+K/tmXl9vI7Ry2MY7jVPb8fkl1jlOWoBhjdITsKMPimvklhbkdojwW10ySCnXkLzpcYXndrGRxzYpk6VkHxhiNXlPgdowa5+EOkaxrQbL482kti2tm7dgpsV2rCou3aday+PPJnKBqrK4b27TgWLxNcyQZt0OUh/WsaorXNSv/Td1k5WQEAAAAAAAAAI4XmqQAAAAAAAAAQhpNUgAAAAAAAAAh7YRukg4dOlSJiYlq3bq121FqlKSkJLVp00YpKSnq2LGj23FqhHHjxql169Zq1aqVXnjhBbfjWKu8z+Rjjz2mtm3bKiUlRZdffrl27NjhYkL7lFez/v37KyUlRSkpKUpKSlJKSoqLCe2z/6cMvfqHNI3t3UbP922nZW9MkCT95+O39XzfdnokNUrbvlntckr7ZGRk6NJLL1VycrJatWqlcePGSZJGjBihpk2blqxzH374octJ7VFRzdatW6fzzjtPbdq00VVXXaWsrCyXk9ojLy9P55xzjtq1a6dWrVpp+PDhkhgLKuPLz9OkIedrXP9UPd+3nT5+6QlJ0ht/HqTxAzpq/ICOeqZHC40fwD5bWX6/X+3bt1fPnj0lSW+99ZZatWolj8ejVatWuZzOXmXrxjhwZGVrxjhwZM/0aKEX+rXX+AEdNXFwJ0nSgheHa1y/Dho/oKP+eUd3Ze1iLCitvHk684LK5Wbv17QH+2ts79Ya27uNfli3gjkBKnVC37hp6dKlio+P1/XXX6/169cfp2T2OtoLjiclJWnVqlWqX7/+cUglyfKLjR+pZuvXr9eAAQO0cuVKRUZGqlu3bnrppZfUokWLYx3P2ptPVFS38j6TWVlZql27tiRp/Pjx+uabb/Tyyy8f17w2CKZmpd1///2qU6eOHn/88WMVzeqb6ZR3kfasXZnK3v2Tmia3V743WxMGn6shY9+WkZHxeDT7qTvV/Y/PqNlZqS6kdl9FNwTIzMxUZmamOnTooOzsbKWmpurdd9/VzJkzFR8frwceeOBYR7N6XQumZjfccIOee+45XXzxxZo8ebK+//57jRo1yoXk7qmoZo7jyOv1Kj4+Xj6fTxdeeKHGjRuns84663iNBdaOnVL52zXHcVSQ61VUbLz8Pp9eHnaJrnpgrE5pe27Ja+aOfUjR8bXV9Q9/Pd6RXVfZTU7Gjh2rVatWKSsrSx988IE2btwoj8ejW2+9Vc8991zIHgxwpP3bsnUbMWLE8RoHauycoGzNzj777OM5Dlhdt4puqPNMjxa6a+pyxdX7dc6ZdyBL0fGBsWDZ9Ina+b+N6vXopOOS1RaVbdOONE8/xvOCGnnjppmPD1Xz9hfq7F5DVegrkC8vR9m7MpkTiBs3VcTKyUh16dy5sxISEtyOgRPcxo0b1alTJ8XGxio8PFwXX3yxZs+e7XYsK5X3mTw4KZYkr9crY9hOl1bZdsxxHM2cOVMDBw48zqnsVrtBYzVNbi9JioqrpcTmLZW1c4cSf5esBklnupzOXo0bN1aHDh0kSbVq1VJycrK2b9/uciq7VVSzTZs2qXPnzpKktLQ0vfPOO27GtIoxRvHx8ZIkn88nn88nYwxjQSWMMYqKDdTMX+hTUaFPKlUfx3H0n4/fVrtu/d2KaKVt27Zp7ty5uvnmm0seS05O1plnMg5Upry6oXLl1YxxoGoONkglyZfLWBAM5gWHyzuQpa1rPlfHa2+SJIVHRCqmVl3mBKjUCd0kRdUYY3T55ZcrNTVV//jHP9yOY73WrVtr6dKl2rNnj3JycvThhx8qIyPD7Vg1yqOPPqqTTz5Z06ZN08iRI92OU2N89tlnatiw4fE4arnG2rdjq3ZsWqeTW5/jdpQaZevWrVq7dq3OPTdwpNrEiRPVtm1bDR06VPv27XM5nZ1K16x169aaM2eOpMDpvYwJh/L7/UpJSVFiYqLS0tJK1jPGgooV+f0aP6CjnrqsqU4/t6tOafPrNm3rms8Vn5Co+qcwFpR233336dlnn5XHw3QnGBXVjXGgYuXVjHHgyIwxmnxnd00YdK5WvvNayeMfTXxMY678ndLnTddltw93MaF9KpunMy843N7t/1Ncvfp6e8TNGj/wbL0z8lYV5HrdjgXLsdeAwyxbtkxr1qzRvHnzNGnSJC1dutTtSFZLTk7Wn//8Z6Wlpalbt25q166dwsOtPZPPSk899ZQyMjI0ePBgTZw40e04Ncb06dP5trgS+TkHNPWB/up5/3OHHJmAyh04cEB9+vTRCy+8oNq1a+v222/Xli1blJ6ersaNG+v+++93O6J1ytZs8uTJmjRpklJTU5Wdna3IyEi3I1olLCxM6enp2rZtm1auXFlyKRHGgop5wsJ0z4xV+sv877Vtwyr99N9fL7+y7qM3OYq0jA8++ECJiYlKTQ3NUyirqqK6MQ5UrKKaMQ4c2W1TFuvuN1bqponva/nMl/T96s8kSVfcNUp/mfc/pVw5UMtnvOhySrtUNk9nXnC4Ir9fO75dq3P73qp7pn+lyJg4LZ7yrNuxYDmapDhMkyZNJEmJiYnq1auXVq5c6XIi+w0bNkxr1qzR0qVLlZCQwDd4VTRo0CBORzpKhYWFmjVrlvr3Z2JcHr/Pp2kP9FdK94Fq3bWX23FqDJ/Ppz59+mjw4MHq3bu3JKlhw4YKCwuTx+PRLbfcwphQRnk1a9mypRYsWKDVq1dr4MCBOu2001xOaae6devqkksu0fz58w95nLGgYjG16qp5amd998UCSZK/sFAbFr2rtpf/3uVkdlm2bJnmzJmjpKQkDRgwQIsWLdJ1113ndizrVVQ3xoGKVVQzxoEjq90gMOeMT0hUq0uvUcaGrw55vl23AdqwiEuYlVbRPJ15QfnqJDZV7cRmJWdftO7aWzu+TXc5FWxHkxSH8Hq9ys7OLvn7ggULDrmrNsq3c+dOSdKPP/6oWbNm8S1eEDZv3lzy9zlz5qhly5Yupqk5Fi5cqJYtW6pZs2ZuR7GO4zh6Z+Qf1KB5S1103X1ux6kxHMfRsGHDlJycrD/96U8lj2dmZpb8ffbs2YwJpVRUs4NjQlFRkZ588knddtttbkW0zq5du7R//35JUm5ubsm2jLGgYgf27VJudqBmvrxcbflyUcm11P775SdqkHSm6jRkLCht9OjR2rZtm7Zu3aoZM2aoS5cumjp1qtuxrFdR3RgHKlZRzRgHKleQ61W+N7vk75tXLFTD01pp94+/jgUbl37AdSNLqWyezrygfLXqN1Ldhs20a+smSdKWlYuU2DzZ5VSw3Ql9TvDAgQO1ePFi7d69W82aNdMTTzyhYcOGuR3Laj///LN69QocdVVYWKhBgwapW7duLqeyX58+fbRnzx5FRERo0qRJqlevntuRrFTeZ/LDDz/Upk2b5PF4dOqpp4bkne0rU9F2bMaMGTTjK/BD+hdaO3eaGp3eWuMHBO5cfPldo+QvyNecZ/8o775d+vc916jxGe009MW5Lqe1x7Jly/T666+rTZs2SklJkSQ9/fTTmj59utLT02WMUVJSkl555RWXk9qjoppt3rxZkyYF7sbbu3dv3XTTTW7GtEpmZqZuuOEG+f1+FRUVqV+/furZs6f69OnDWFCB7F2Zemv4MDl+vxynSG3S+iq5cw9J0tcLZnKqfRBmz56tu+++W7t27VKPHj2UkpKijz76yO1Y1nvooYcYB4I0ffp0xoFKHNjzs16/P3AEfJG/UCndBujMC67Q1Af6afcP38kYj+o2PkXXhtid7StT2TydeUHFrvrz83rz0Rvk9xUooVlz9R3xmjYsepc5ASpkHMep7Pn9kuocpyxBMcboCNlRhsU180sKcztEeSyumSQVytIvOiyvm5UsrlmRLD3rwBij0WsK3I5R4zzcIZJ1LUgWfz6tZXHNrB07JbZrVWHxNs1aFn8+mRNUjdV1Y5sWHIu3aY4k43aI8rCeVU3xumblv6mbrJyMAAAAAAAAAMDxQpMUAAAAAAAAQEijSQoAAAAAAAAgpNEkBQAAAAAAABDSaJICAAAAAAAACGk0SQEAAAAAAACENJqkAAAAAAAAAEIaTVIAAAAAAAAAIY0mKQAAAAAAAICQRpMUAAAAAAAAQEijSQoAAAAAAAAgpNEkBQAAAAAAABDSaJICAAAAAAAACGk0SQEAAAAAAACENJqkAAAAAAAAAEIaTVIAAAAAAAAAIY0mKQAApdT6eZsivdluxwCAKonK2qe43T+5HQMAjpu4XZmKyv7F7Rg4QUTkelXrpwy3Y8Al4W4HOFEUFBRoypQp2rRpk84880zddNNNioyMdDuW9T766CMtXLjQU6dOHQ0dOlRNmjRxO5L1/vvf/+r1119XXl6e55prrtH555/vdiTreb1evfbaa/rhhx/Uvn17DR48WB4P3xFVxnEczZo1S1988YVp1KiRbr75ZtWrV8/tWMdUnW3/08UTH9MZi+fIHx6p5Tc9qNUD75IvNv6ol5H53Tp9veBtyRi1Teurxme0PYaJTwx79+7Vq6++qp07d5oLL7xQ1157rYwxbseymt/v17Rp05Senq6kpCTdfPPNio2NdTuW9T7//HPNmTPHExsbqyFDhui0005zO1K1isrer3P//Xd1fGOCTFGRvrlygD67fbgOJDat8jJ/2bldq977t/K92TrjvMt0+rldqzHxiamgoECTJ0/Wd999p5YtW+qmm25SRESE27GsN3/+fH388ceehIQEDRs2TI0aNXI7kvW+++47TZ06Vfn5+Z5evXqpU6dObkc67mr9lKHOL45Q8oK3VOTxaOV19+mrIX9Ufq065b4+P+eAvpo9Wft/ylDT5PZq120Ac4IjcBxHb7/9tpYvX26aNGmim2++WXXr1nU71jERnpuj1BmTdP7kZxTmy9d/L+quJXc/qX2ntAh6WTu+Xav/LJwlGaN2V/RTo9NbH4PEOBaM4ziVPb9fUvlbGJcZY3SE7MdNQUGBLrroIq1fv145OTmKjY1VmzZttHTpUqsapTbVTJKefPJJjR49Wjk5OQoPD1dcXJy++uortWgR/EboWLGtZitXrlSXLl2Ul5cnv9+v2NhYTZo0STfeeKPb0Q5hU92ysrKUmpqqbdu2KS8vT3FxcerataveffddqxoxNtVMkm699VZNmzZNXq9XUVFRqlevntLT09WwYUO3o5Uwxmj0moJqWVaTr7/UwFvT5PEXKqywUJJUEB0rX2ycJn70o5ywsCMu49vP5+mNBwfIV5AnSYqIitZ1z72lM86/vFoyVpeHO0Ras65lZmaqffv22rdvnwoKChQXF6cbbrhBkyZNcjvaIWz6fDqOo549e2rJkiXyer2KiYnRySefrNWrVys+/ugb+seaTTWTpNdee0333nuvcnJyFBYWpujoaC1ZskSpqaluRztEVbdrkd5s3XHl7xTmK1BEfq4kqTAiQo4nXFOmr9TepDODXuaurZs06foL5MvNUZG/UBHRsep6y6O6+KYHg17WsWTTNi0/P18XXHCBNm7cWDInaNeunZYsWWJVo9S2z+cTTzyhZ599Vjk5OYqIiFBcXJxWrVpl1RcZttVs+fLlSktLU25uroqKihQbG6uXX35ZQ4YMcTvaIapzX62s+ls26IbrzpfxFyq80CdJ8kXFqDAySpPmb1VhzKFfHuZl/6IJg85R1u5MFebnKSImTi06Xabrnptp1ZzApm2aJA0bNkxvvvlmyZwgISFB69atU4MGDdyOVqK61rM7r0hSVPZ+ReblSJL8YeEqCg/XzIlzlZF60VEvZ+OSDzT9L4MPmRMMGfuOWnS67DdnrE7F65o9K78l+NqkGixbtqxkZ0iScnJytGHDBn3xxRcuJ7OX4zgaNWpUSc0KCwuVlZWlCRMmuJzMbiNHjpTX65Xf75cUWNceeeQRl1PZ7f3331dmZqby8gKDlNfr1ccff6z//ve/Liez1/79+zVlyhR5vV5JgUnf3r17NW3aNJeTHTu1fs5QUXhESYNUkiLzchSzf49Mkf+olvHRhL/Kl58rOY7kOPLl5eqjiY8dq8gnhNdff1179+5VQUFgx9br9erVV1/VgQMHXE5mr2+//VaLFy8u+Xzm5uZq+/btmjt3rsvJ7Pboo4+W7HP4/X55vV6NGjXK5VTVJzInW2GFvpIGqSSF+3zyR0QqfldmlZa57I0Jyj+QpSJ/YLvoy8vRwn+cODU7Fj777DNt2rTpkDnBf/7zH61YscLlZPYqKirSU089VVIzn8+nX375RS+++KLLyez2xBNPyOv1qqioSFJgXXv00UddTnV8xe/cIX9EZEmDVJIi8nMVnp+niDzvYa//ZskcZe/5WYX5gTmBL9erzV8s0L7t3x+3zDXNnj17NHXq1MPmBNOnT3c52bFRa9eOkgapJIX5C1UUFq7aP/0Y1HLmlzMnWDDp8eqOi2OEJmk18Hg85X7bw6H7lStbH2OMwo7iaK1QVt46xXpWuYrqQ90qVl5tjDHU7AiM5/Dtl6ecx/Arj8dz2NEbjuNYdUSHbdjnqJry6sM+R+WMxyNjyu6rsZ5Vhn2O4BljDtvmezweanYE5W2/qFnlytt+OXJkqFuFytvnYE5wZOWtU+XNE2An1u5qcMEFF6hjx46Ki4uTMUZxcXE6++yzuVZkJYwxGj16tGJjY0tOe6tXr57uu+8+t6NZbdSoUapVq5YiIyMVHh6umJgYjR071u1YVrv66qvVvHlzxcXFyePxKC4uTr169dLvfvc7t6NZq3bt2rrnnntKahYbG6tGjRpZdwpXdfqlaXN5CgtVGPHrJVIKYuJ0oEETOUe5U9Pjj88oIjpGnvAIecIjFBEdqyv/OOZYRT4h3HjjjUpMTFRsbGzJunb//fcrLi7O7WjWOuOMM3TVVVcdsk07/fTT1bNnT7ejWW3s2LGKiYlReHi4oqKiVKtWLY0YMcLtWNUmP76OfNExKoj+9fRSX2S0PP5CZTVsVqVlXjTkj4quVVfhkdEynjBFRMeo2z1PV1fkE9JFF12k9u3bH/L57NSpU0heK/JoGWP01FNPHTInSEhI0D333ON2NKuNGjVK8fHxIT0nyGp0ssIKfSqMjCp5rCA6VgVxteSLOfzyM626XKt6TU5VREysjPEoMiZObS7ro7qNTz2esWuUevXq6Y477jhkTtC4cWMNHjzY7WjHxP4mSSqI+XUftDAiQh6/X/uaBXfpjx5/elYR0bHyhIX/Oie4d3R1x8UxwjVJq4nf79ebb76pLVu26PTTT1e/fv2sO0LBtppJgUsVfPrpp0W1a9f2DB48WCeddJLbkQ5hY822bdummTNnKj8/v6h79+6edu3auR3pMLbVLT8/X9OmTdP27dvVtm1bXX311dYdqWZbzSRpwYIF+vLLL50GDRqYIUOGWNe4qu7rXMXv2qELXhmlNu9PlS8mVktvH6Gvew2Vv9TO95Hs+uE7ffPpHEmBnfH6p5xebfmqi23XusrOztbUqVO1e/du57zzzjOXXWbX9Zok+z6fjuPo3Xff1fr169WsWTMNHjzYqmugS/bVTJLWrl2refPmFUVHR3v69++vpk2rfkOjY+W3bNcicr3qMONFnT95jDyFhVrb9w9aPvTPyq1Xv8p5vPt2K33edBXkevW7jpfo1Hb2Nfts26b5/RPmo0oAACAASURBVH7NmDFD//vf/9SiRQv169fPuqOubPx8fv7551q8eHFRnTp1PIMHD1ZCQoLbkQ5hY80yMjI0c+ZMFRQUFPXo0cPTtq19N4s8ltcklaTYvTt1/mtj1G72a/JHRGrZzY9qbb/bVBgdU+7rffl5Sp83XVm7dqjxGW2V3LmndXMC27ZpUuBmyytXrnQSExPNddddd8LOCTy+ArV9d4o6vzhCkTkHtKH7QH1+2+PKrsKXjbu2btI3i9+XMUatulyrk0625xrLB3FN0vLRJA0hFtfML8mujnIxi2smSYWSwt0OUR7L62Yli2tWJEvPOjhWO97R+/fIFxMnf1R0tS/bBjbufBezel2ztGbWsrhm1o6dUvVs1yJyvfIU+pRf68S8+3BZFm/TrGXx55M5QdVYXbdj2SQ9KCprn/wRUYfdrKkmsnib5kiysqFW3etZWEG+Ir3Zv+lLxpqAJmn5rN1JBADADXl17TqiHQCC4Yux6wgfADjW8mvXczsCTiD+yCjlBnEmGU4sVh6xAQAAAAAAAADHC01SAAAAAAAAACGNJikAAAAAAACAkEaTFAAAAAAAAEBIo0kKAAAAAAAAIKTRJAUAAAAAAAAQ0miSAgAAAAAAAAhpNEkBAAAAAAAAhDSapAAAAAAAAABCGk1SAAAAAAAAACGNJikAAAAAAACAkEaTFAAAAAAAAEBIo0kKAAAAAAAAIKTRJAUAAAAAAAAQ0miSAgAAAAAAAAhpNEkBAAAAAAAAhDSapAAAAAAAAABCGk1SAAAAAAAAACGNJikAAAAAAACAkEaTFAAAAAAAAEBIo0kKAAAAAAAAIKTRJAUAAAAAAAAQ0miSAgAAAAAAAAhpNEkBAAAAAAAAhDSapAAAAAAAAABCGk1SAAAAAAAAACGNJikAAAAAAACAkEaTFAAAAAAAAEBICz/C8/GSio5HkCrwyM5stuaS7M0WJskp/mMbW2tmFPj82phNsrdutuaS7M3mkd2fT1SNreuajbkke7PZmkuyN1tY8U8bs0ls16rKxn9PWz8Dkr3ZmBMEzyhQNxuzSWzTqsrGf0/mBAgJxnEqXsebnZLkbM/44TjGAQDg6IRHRqmwIN/tGABQbdiuATiRsE3D8cB6VjXhUdE/+/JyG7mdwzaVNkmNMc7oNQXHMU7N93CHSFVWU5TLb4wJo27BMcawrgWJmlVJkTHGw1gQHMaC4PH5rBrqFrRCY0w4NQsO61nwqFmVMCeoAmOM2E8LDvtpVeIYYwzrWnCK1zXjdg4cPQ5LBgAAAAAAABDSaJICAAAAAAAACGk0SQEAAAAAAACEtN/cJPXl52nSkPM1rn+qnu/bTh+/9ER15Drhbdq0SSkpKSV/ateurRdeeMHtWNYZOnSoEhMT1bp165LH3nrrLbVq1Uoej0erVq1yMZ2dyqvZiBEj1LRp05L17cMPP3QxoZ3Kq9u6det03nnnqU2bNrrqqquUlZXlYkL77P8pQ6/+IU1je7fR833badkbEyRJC14crnH9Omj8gI765x3dlbVrh8tJ7ZGRkaFLL71UycnJatWqlcaNGydJ6t+/f8nnMykpSSkpKS4ntUdeXp7OOecctWvXTq1atdLw4cMlMRYcSUV1YzyoWEU1Yyw4Mr/fr/bt26tnz56SpMcee0xt27ZVSkqKLr/8cu3YwThQVtmaMQ4cWVJSktq0aaOUlBR17NhREmPBkTzTo4Ve6Nde4wd01MTBnSRJC18eqdFXJGn8gI4aP6Cjvv18nssp7VLeesY4cGS52fs17cH+Gtu7tcb2bqMf1q1gToAa6TffuMlxHBXkehUVGy+/z6eXh12iqx4Yq1PanlvdWWuEqlwE2u/3q2nTpvryyy916qmnHqNkVqvwIu1Lly5VfHy8rr/+eq1fv16StHHjRnk8Ht1666167rnnSgavUFPRDQHKq9mIESMUHx+vBx544HjHtEplN1Eor25nn322nnvuOV188cWaPHmyvv/+e40aNep4RrZBhTduytqVqezdP6lpcnvle7M1YfC5GjL2bdVJbKbo+NqSpGXTJ2rn/zaq16OTjnduV1U0FmRmZiozM1MdOnRQdna2UlNT9e677+qss84qec3999+vOnXq6PHHHz+ekV1X0efTcRx5vV7Fx8fL5/Ppwgsv1Lhx41SnTh3GAgVft/nz54f6eFDhjZsqqtndd98d8mPBkW5CNHbsWK1atUpZWVn64IMPlJWVpdq1A+PA+PHj9c033+jll18+XnGtEGzNSgvVcUBHuHFTUlKSVq1apfr165c8xryg8hs3PdOjhe6aulxx9X6t2cKXRyoyNl6dr//T8Yponcrm7OWtZ8wJJB3hxk0zHx+q5u0v1Nm9hqrQVyBfXo6M8TAn4MZNNc5vPpLUGKOo2HhJkr/Qp6JCn2RYB4LxySef6LTTTgvVBmmlOnfurISEhEMeS05O1plnnulSIvuVVzMcWXl127Rpkzp37ixJSktL0zvvvONGNGvVbtBYTZPbS5Ki4mopsXlLZe3cUbIzJEm+XK8MY0KJxo0bq0OHDpKkWrVqKTk5Wdu3by953nEczZw5UwMHDnQronWMMYqPD+xn+Hw++Xw+GWMYC46gorqhYhXVjLGgctu2bdPcuXN18803lzx2sEEqSV4v40BZ5dXsIMaB4DAW4HhgHKhc3oEsbV3zuTpee5MkKTwiUjG16jInQI1ULdckLfL7NX5ARz11WVOdfm5XndLmnOpYbMiYMWMGO0I45iZOnKi2bdtq6NCh2rdvn9txaoTWrVtrzpw5kgKnc2VkZLicyF77dmzVjk3rdHLrwPb/o4mPacyVv1P6vOm67PbhLqez09atW7V27Vqde+6vZ1589tlnatiwoVq0aOFiMvv4/X6lpKQoMTFRaWlph9QMFauobowHFSuvZowFlbvvvvv07LPPyuM5dFrx6KOP6uSTT9a0adM0cuRIl9LZqaKaSYwDlTHG6PLLL1dqaqr+8Y9/uB2nRjDGaPKd3TVh0Lla+c5rJY8vf/MljevXQW+PuEW5WYwDpZW3njEOVG7v9v8prl59vT3iZo0feLbeGXmrCnK9kpgToOapliapJyxM98xYpb/M/17bNqzST/9dXx2LDQkFBQWaM2eOfv/737sdBSew22+/XVu2bFF6eroaN26s+++/3+1INcLkyZM1adIkpaamKjs7W5GRkW5HslJ+zgFNfaC/et7/XMk3xlfcNUp/mfc/pVw5UMtnvOhyQvscOHBAffr00QsvvHDIEVfTp0/nS7NyhIWFKT09Xdu2bdPKlStLLomBypVXN8aDypVXM8aCin3wwQdKTExUamrqYc899dRTysjI0ODBgzVx4kQX0tmpsppJjAOVWbZsmdasWaN58+Zp0qRJWrp0qduRrHfblMW6+42Vumni+1o+8yV9v/oznfv7W/XgnG9194xVqlW/keaOfcjtmFYpbz1jHKhckd+vHd+u1bl9b9U9079SZEycFk95VhJzAtQ81Xp3+5haddU8tbO++2JBdS72hDZv3jx16NBBDRs2dDsKTmANGzZUWFiYPB6PbrnlFq1cudLtSDVCy5YttWDBAq1evVoDBw7Uaaed5nYk6/h9Pk17oL9Sug9U6669Dnu+XbcB2rBotgvJ7OXz+dSnTx8NHjxYvXv3Lnm8sLBQs2bNUv/+/V1MZ7e6devqkksu0fz5892OUqOUrhvjwdEpXTPGgootW7ZMc+bMUVJSkgYMGKBFixbpuuuuO+Q1gwYN4tTUUiqrGeNA5Zo0aSJJSkxMVK9evdh+HYXaDQI1i09IVKtLr1HGhq9U66SG8hSPA+f0HqZtG75yOaVdylvPGAcqVyexqWonNis5o7h1197a8W36Ia9hToCa4jc3SQ/s26Xc7P2SJF9errZ8uUgNkrguzNHi22IcD5mZmSV/nz179iF3cEfFdu7cKUkqKirSk08+qdtuu83lRHZxHEfvjPyDGjRvqYuuu6/k8d0/bi75+8alHzAmlOI4joYNG6bk5GT96U+H3jBh4cKFatmypZo1a+ZSOjvt2rVL+/cH9jNyc3NL6oTKVVQ3xoOKVVQzxoKKjR49Wtu2bdPWrVs1Y8YMdenSRVOnTtXmzb+OA3PmzOEzW0pFNZMYByrj9XqVnZ1d8vcFCxaw/TqCglyv8r3ZJX/fvGKhGp7WSlm7fh0HNix6Tw1Pa+VWROtUtJ4xDlSuVv1GqtuwmXZt3SRJ2rJykRKbJzMnQI0U/lsXkL0rU28NHybH75fjFKlNWl8ld+5RHdlOeDk5Ofr444/1yiuvuB3FWgMHDtTixYu1e/duNWvWTE888YQSEhJ09913a9euXerRo4dSUlL00UcfuR3VGuXVbPHixUpPT5cxRklJSaxz5SivbgcOHNCkSYE7MPbu3Vs33XSTyynt8kP6F1o7d5oand5a4wcE7iZ7+V2jtOrdKdr9w3cyxqO6jU/RtSF2F8vKLFu2TK+//rratGmjlJQUSdLTTz+t7t27c33qCmRmZuqGG26Q3+9XUVGR+vXrp549e2r27NmMBZWoqG5DhgxhPKhARTUbN24cY0GQ/vKXv2jTpk3yeDw69dRTQ+7O9lXFOFCxn3/+Wb16Bc5YKSws1KBBg9StWzfGgkoc2POzXr8/cEm3In+hUroN0JkXXKE3/3qjMr9bJyOjek1O1bWPcgr0QRWtZ4wDR3bVn5/Xm4/eIL+vQAnNmqvviNf0zshbmROgxjGO41T8pDHO6DUFxzFOzfdwh0hVVlOUy2+MCaNuwTHGsK4FiZpVSZExxsNYEBzGguDx+awa6ha0QmNMODULDutZ8KhZlTAnqAJjjNhPCw77aVXiGGMM61pwitc143YOHL1qvSYpAAAAAAAAANQ0NEkBAAAAAAAAhDSapAAAAAAAAABCGk1SAAAAAAAAACGNJikAAAAAAACAkEaTFAAAAAAAAEBIo0kKAAAAAAAAIKTRJAUAAAAAAAAQ0miSAgAAAAAAAAhpNEkBAAAAAAAAhDSapAAAAAAAAABCGk1SAAAAAAAAACGNJikAAAAAAACAkEaTFAAAAAAAAEBIo0kKAAAAAAAAIKTRJAUAAAAAAAAQ0sLdDlAtHEeJm79W3K6ftKtFax1IbOp2IgBADWT8fjVe/5Uic7KV2fps5deq63YkAACAkBO/a4cafPcfees31M4z2knGuB0JJzr6SlANbJJuXDpXG5e8r8iYeJ3b9xa18ITp9/dco1q7dqgoLEzhBfnackE3vf/U/6kwOsbtuFbYtGmTXn75ZR04cEDXXHONevbs6XYk6x04cEDjx4/Xd999p5SUFN1xxx2KjIx0O5bVHMfR9OnT9cknn6h+/fq6++671axZM7djWW/16tWaMmWKCgsLNWjQIHXu3NntSNbz7tutZdMn6ped23Rq2/PU8Zob5QkL+83LPXn1Z+r1YD+FFRTI8RiFF+Trq0F3a8ndT9X4HXO/36/XXntNK1as0Mknn6z77rtPCQkJbsey3uLFizVjxgxFRERo6NChat++vduRrJeRkaEJEyZoz549uvzyy9WvXz+ZGv75Odby8/P14osvat26dTrzzDN1zz33KC4uzu1Y1pszZ47ef/991apVS7fffrtatGjhdiTrbdy4Ua+88opycnJ07bXXqnv37m5Hsl52drbGjx+vzZs3q0OHDrrtttuYExyB4zhKnzddW1Z+qviERJ0/8E7VbtDkqH8/rCBfPR+7US2WfKDCyCh5/H4dOKmR3h7/rvYmnXkMk7vrq6++0r///W/5/X4NHjxYF154oduRrHdg3y4te2OCsnbtUFLKBUq9+gZ5PFU7Wbruj/9Vv3uuUXzpvtKFV2rOU/8nf1R0NSeHzYzjOBU/aYwzek3BcYxTuU//+Yw+/edo+fJyJGMUGRWjbbXr6aTdmfIUFZW8zhcZrXW9h2nhQ88f94wPd4hUZTU93latWqVLLrlEOTk5chxHsbGx+utf/6qHH37Y7Wil+Y0xYbbU7cCBA2rfvr22bdumvLw8xcTEqG3btvr8888VHm7P9wrGGKvWtdtvv12vv/66vF6vwsLCFB8fr9WrV+u0005zO1oJ22o2f/589enTRzk5OZKkmJgYvfLKKxoyZIjLyQ5RZIzx2DIWZO/5WeP7pyo3a7/8hQWKiI5Vi06X6bq/v/WbGjFR2ft1Z7fmisz1HvJ4QXScPnp0ojb0GBzU8mwaCxzH0VVXXaVPP/1UOTk5ioyMVEJCgr7++ms1aNDA7XglbPt8TpkyRXfdddchn8/33ntPaWlpLic7lE1127x5szp27Civ1yu/36/Y2FgNGzZM48ePdztaaYXGmHBbaubz+XT++edrw4YNys3NVXR0tE455RStWbPGqkapTeuZJI0aNUpjxoxRTk6OPB6PYmJi9Nlnn1n1RYZtNVu5cqW6dOlyyJxgxIgRevDBB92OVppVc4Ls7GylpKRo+/btys/PV0xMjNq3b6+lS5cqrBq+nK0uxhjZsp8mSbNG3ab0eTPky8uRJyxckbHxuvuNL5XQtPlR/f4lL/xFqW++qIj8vJLHioxRdsOT9dIH30lVbIKVZtN+miTNnTtXv//975WbmyspsM/x2muvadCgQS4nO4RjjDG2rGtZuzI1fkCqcrN/UVGhTxHRsTrzgm4a/LcZwS+sqEi3XpOsOju2ylNqvfBFRiu9zy365MG/Vzln8brGt8U1SI26JumSfz0baJBKkuMoOS9HsXt+PqRBKkkRBXlq8/7/uZDQPmPHjpXX6y0ZBHJycjRmzBiXU9lt4cKF+vnnn5WXFxiYc3NztWHDBq1du9blZPbKz8/Xq6++Kq830GDy+/3Kzs7Wv/71L3eDWW7UqFElDRgpsK498cQTLiay3/pPZivPmyV/YWAHzZeXo+++WKDs3Zm/abktFs8p9/HIPK86vPnib1q22zIyMrRo0aKSda2goEC//PKLZs+e7XIyu40cOfKwz+eTTz7pYiL7/fOf/1R2drb8fr+kwD7HSy+9JJ/P53Iye61atUrffvttycQ4Ly9PmZmZ+vTTT11OZrdnnnmm5PNZVFQkr9erF154weVUdvvb3/522Jzg6aefdjmV3RYsWKCdO3cqPz9fUmAcWLdunb7++muXk9nLl5er1XP+r2TOXuQvVH5Otta8P/Wol9Hu3SmHNEglyeM4is7aq8bfrK7WvLYYOXJkyTggMSc4Gv9Z+I7yvdkqKgzsY/jycrRx6Vxl7/k56GU1/G6d4vbuPKRBKh3sK/27WvKi5qhRTdKw8IhD/jtfRh6V/w2QP4LTICQpOjr6sEPOIyIiKng1JCky8vBvFouKihQVFeVSIvuFhYUdtp6FhYVRsyMorz7UrHLhEZEy5tB1zXGKFBb+27b5hZHRcio4ErUwqmZfuiUyMlJFZb5MNMZwuuARlFef6GhOt6pMVFTUYUdXeTyeKp/6FgqioqIO2+dwHIfP5xGU3Zf1eDx8Po8gJibmsM8i61nlyqsPn8/KmbCwwy5R5PGEKTyI05X9EeXvCxvHUWHkibmfXN72izlB5cIjoiRTdv/CUXgV+kCFkdEyFRxZTF8p9NSovdar/zJeEVExCo+MVkR0rH6sm6Cdp7dWYZkdpYLoWK287o8upbTLY489poSEBMXGxio6OloxMTGaNGmS27GslpaWpo4dOyo+Pl5RUVGKi4vTtddeqzZt2rgdzVrh4eEaM2aMYmNjS2rWpEkT3XbbbW5Hs9rf//531apVSzExMYqOjlZcXJwmTpzodiyrtb2inxKaNldkbLzCIqIUER2rCwbdrbh69X/TcjdfcrX8kVEqKrNjXxAdqxU3PfSblu22Ro0a6c4771RcXJyioqIUHx+vFi1aqF+/fm5Hs9qkSZMOGTtr166tZ5991u1YVrvzzjvVuHHjknUtNjZWzz33nFWnpdqmffv26tGjR8k+R3x8vDp16qQuXbq4Hc1qEydOPGTsPOmkk/TII4+4Hctqw4cPV926dQ/ZrrHPUblu3bqpQ4cOh8wJ+vTpo7POOsvtaNYKj4jUFXeOVER0rMIioxQZE6faDZro7F5Dj3oZK264XwXRsYc8Vhgeob2nnqFdLU7M+djYsWMVHx9fsl2LjY3VhAkT3I5ltZQrByihaZIiY36dE1x0/Z8UU7te0Mva87tk7Tq9lQrLNETpK4WmGnVNUkn6ecsGbflqiSKiY9S6y7Wq5zjqMXyYmi9fqKLi60V+NegefXb78Gq5XkmwbLu+iSTt27dPs2bNUm5urrp06WLjwG7V9YekwJGj7733nn744Qe1bNlSV1xxhXU3nrDtWldS4ILjy5cvV926ddW3b1/FxsYe+ZeOIxtrlpmZqTlz5sjv9+vKK69U8+ZHd72m48iqa5JKUqGvQOs/maUDe3aqaXIHNe9QPRe2r/fjZl39yPVqsPk/csLC5YuO1Sd/elYbel4X9LJsHAuWLFmitWvXqlGjRurTp491ZxXY+PncsmWLPvroI4WFhemaa65Ro0aN3I50GNvq5vV69fbbb+uXX37RBRdcoNTUVLcjlWXVNUmlwJFp8+fP16ZNm5SUlKSrr77auqNvbVvPJGn9+vX69NNPFRcXp969e6tu3bpuRzqEjTXbu3evZs2apby8PHXt2lXJycluRyrLujmB3+/Xe++9px9//FFnnXWW0tLSrJwT2LSfJkkZ67/Sj1+vUEztempzWR9FBHNDZcfRBa88qXOmPi/jOPIUFmrrOZdq7sjJyv2NX4ofZON+2o4dOzRnzhwVFRWpe/fuSkpKcjtSWVZdk1QqnhMsfEfefbvVNLmDktpfUOVlRf+yVz0eH6rmKz4p7isZfTX4Hn122+O/qa/ENUlrnhrXJK1I5IEsxfyyR9mJTVXk4iHRNm5wawDrdohqAht3vm1HzarEuibpsRazb7cicr3KanRylXeKGAuCx+ezaqhb0KxrktYErGfBo2ZVwpygCmxsklYHj8+nWju3Ka92gvJr1anWZbOfViXWNUmPheruK9EkrXnsuVX3b1QQX1sF8bXdjgEAqOFy69WvtiMVAAAAELyiiAj90tS6M6xwgqOvBLvO5QEAAAAAAACA44wmKQAAAAAAAICQRpMUAAAAAAAAQEijSQoAAAAAAAAgpNEkBQAAAAAAABDSaJICAAAAAAAACGk0SQEAAAAAAACENJqkAAAAAAAAAEIaTVIAAAAAAAAAIY0mKQAAAAAAAICQRpMUAAAAAAAAQEijSQoAAAAAAAAgpNEkBQAAAAAAABDSaJICAAAAAAAACGk0SQEAAAAAAACENJqkAAAAAAAAAEIaTVIAAAAAAAAAIY0mKQAAAAAAAICQRpMUAAAAAAAAQEijSQoAAAAAAAAgpNEkBQAAAAAAABDSaJICAAAAAAAACGk0SQEAAAAAAACENJqkAAAAAAAAAEIaTVIAAAAAAAAAIY0mKQAAAAAAAICQRpMUAAAAAAAAQEijSQoAAAAAAAAgpIW7HeAE5Xc7QA0TVvyTuh09jyQjahasMFGzYIUd+SWoAOva0TMKbNeoWXAYP4NHzYLH57Nq2OcIHp/P4B2cEyB4rGfBYU6AkGAcx6nwyWannOpsz/jxOMYBANgmPDJKhQX5bscAAABAGeyn4XhhXQuezTULj4r+2ZeX28jtHLaptEkqab+kOscpS1CMMRq9psDtGDXKwx0idYR/b7f4Zek3U8YYW2smSYWy9Ghwy+tmJYtrViRLL81icc2sZnHdWNdOIBbXzNqxU2L/tios3r+1lsWfT+YEVWN13dimBcfibZojS49aZj2rmuJ1zcp/UzdZORkBAAAAAAAAgOOFJikAAAAAAACAkEaTFAAAAAAAAEBIO6GbpPt/ytCrf0jT2N5t9Hzfdlr2xgS3I9UI+/fvV9++fdWyZUslJydr+fLlbkey0tChQ5WYmKjWrVuXPLZ3716lpaWpRYsWSktL0759+1xMaJ/yanbQc889J2OMdu/e7UIye5VXs/T0dHXq1EkpKSnq2LGjVq5c6WJC+2RkZOjSSy9VcnKyWrVqpXHjxkmSHnzwQbVs2VJt27ZVr169tH//fpeT2qWiuknShAkTdOaZZ6pVq1Z66KGHXExpl7y8PJ1zzjlq166dWrVqpeHDh0tiLKhMRTU7iLHgcL78PE0acr7G9U/V833b6eOXnpAk7diUrhevv1DjB3TUxMGdlLH+K5eT2sfv96t9+/bq2bOnJMaBo1W2bhLjQGWSkpLUpk2bkv0yiXHgaDzTo4Ve6Ne+ZBtW2tL/G6uHO0TKu4+xoLTy1jXmBZXLzd6vaQ/219jerTW2dxv9sG6FPnz+Lxrbu7XG9eug1+/vq9xsxgL86oRuknrCwtX9j8/qT7P+ozv+/bmWz3xJP//vG7djWe/ee+9Vt27d9O2332rdunVKTk52O5KVbrzxRs2fP/+Qx8aMGaOuXbtq8+bN6tq1q8aMGeNSOjuVVzMp0Jz5+OOPdcopp7iQym7l1eyhhx7S8OHDlZ6erpEjRzJZKSM8PFx///vftXHjRq1YsUKTJk3SN998o7S0NK1fv15ff/21zjjjDI0ePdrtqFapqG6ffvqp3nvvPX399dfasGGDHnjgAbejWiMqKkqLFi3SunXrlJ6ervnz52vFihWMBZWoqGYSY0FFwiOjdPMrC3Tvm6t1z/RV+m75Av349ZeaN+4Rdb31r7pnxipddvtwzRv3sNtRrfP/7d15dBRl2v7xq9JZO+kkhhBZEgRGhLATgYgLKg4MCDPIIiroiwo6MiouoMBv5h1QB5FFAYFRWUVwxAVHEBAVwo4RMQREVBCIEogsyprO0tvvj0heAp2EsFWF/n7OmXNyOpPk8qar7nru7np64sSJJa5j6QNn5/S60QfKt2LFCmVmZmrjxo2SWBOcrYfe+FwD523UY2+nFz925Jc9+jF9uWKr0Qv8Of25xrqgbB+PfVrXXP8nPf3hVg18CozQGAAAIABJREFU92sl1G2gq6+7TU+8l6kn3stQfK16WjlztNkxYSGX9ZA0ump11UxuIUkKi3QooU4DHTuwz+RU1nbs2DGtXr1a/fr1kySFhoYqNjbW5FTW1LZtW8XFxZV4bMGCBerbt68kqW/fvvroo4/MiGZZ/momSU899ZTGjBkjw+DD9U7nr2aGYejYsWOSpKNHj6pGjRpmRLOs6tWrKyUlRZLkcDiUnJysvXv3qkOHDgoOLvpQ6+uuu07Z2dlmxrSc0ur22muvaejQoQoLC5MkJSQkmBnTUgzDUFRUlCTJ5XLJ5XLJMAx6QRlKq5lELyiNYRgKsxfVzON2yet2SYYhQ4YKThT1gvwTRxVdtbqZMS0nOztbixcvVv/+/Ysfow+Uz1/d6AMVRx84d4tfHqxOT74o0QvOCuuC0uWfOKasjLVqeccDkqTgkFBFOGJ1TZv2sv3eC2o1SdXRA3vNjAmLuayHpKc6vC9L+37YrKTGrc2OYmm7du1S1apV9cADD6hFixbq37+/cnNzzY5Vaezfv1/VqxctUqpXr64DBw6YnMj6Fi5cqJo1a6pZs2ZmR6k0JkyYoGeeeUZJSUkaPHgw74QpQ1ZWljZt2qTU1NQSj8+cOVOdOnUyKZX1nVq37du3a82aNUpNTdXNN9+sr77ilt5TeTweNW/eXAkJCWrfvr1SU1PpBeXwVzN6Qdm8Ho9evbulRv6xpq5OvU21mrRWl8HjtGTiML3Uqa4+GT9Uf3rsX2bHtJQnn3xSY8aMUVCQ/+UOfcA/f3WjD5TNMAx16NBB1157raZOnSqJNcHZMAxDMx+9XZN6p2rD/OmSpG2rPlZ0Qk1Vv4Ze4I+/5xrrgtL9tneXIq+I1wcj+uvVe1pp/vN/VWFeydnGxgVvqv71fzIpIawoIIakBc4Tmjv4LnUZNE7hUdFmx7E0t9utjIwMDRgwQJs2bVJkZCS3h+CicTqdGjlypJ5//nmzo1Qqr732msaPH689e/Zo/Pjxxe/8RkknTpxQjx49NGHCBEVH/9+5f+TIkQoODlafPn1MTGddp9fN7Xbr8OHDSk9P19ixY9WrVy/5fD6zY1qGzWZTZmamsrOztWHDBm3dutXsSJZ3es22bNlCLyhHkM2mgfM2aujS3cr+dqN++XGr0j+Yqi6DxmroJ7vUedBYzX/+r2bHtIxFixYpISFB1157rd/v0wf8K61u9IGyrVu3ThkZGfrkk080ZcoUrV692uxIlcIjs1bq8f9s0AOTP9YX772m3V+v0YoZL6n9I8PL/+EA5e+5xrqgdF6PR/u+36TUnn/VwHe+UmhEpFbOGlP8/RXTRykoOFjNb+9tYkpYzWU/JPW4XHp78F1qfvs9anxbN7PjWF5iYqISExOL33XVs2dPZWRkmJyq8rjyyiuVk5MjScrJyeF2pHLs3LlTu3fvVrNmzVS7dm1lZ2crJSVFv/zyi9nRLG327Nnq3r27JOnOO+9kg3Y/XC6XevTooT59+hTXSiqq3aJFi/T2229zS68f/uqWmJio7t27yzAMtW7dWkFBQXyojh+xsbG65ZZbtHTpUnrBWTpZswULFtALzlKEI1Z1rm2r7es/U8aiOWrUrujatkn7nsr+lnf3nbRu3TotXLhQtWvX1t133620tDTde++9kugDZSmtbvSBsp28vTkhIUHdunXThg0b6ANnIbpqUd2i4hLU6Nau2pWxWof3Zmni3S01unM9HTuQrUl9UnX8EL3gJH/PNdYFpYtJqKnohETValJ0N3Hj27pr3/eZkqSvP35L361Zorv+9Ra9ACVc1kNSn8+n+c8/rKp1Guime580O06lUK1aNSUlJemHH36QJC1fvlwNGzY0OVXl8Ze//EWzZ8+WVHQR3rVrV5MTWVuTJk104MABZWVlKSsrS4mJicrIyFC1atXMjmZpNWrU0KpVqyRJaWlpqlevnsmJrMXn86lfv35KTk7W008/Xfz40qVLNXr0aC1cuFB2u93EhNZUWt3uuOMOpaWlSSq65bKwsFDx8fFmxbSUgwcPFn86dl5enpYtW6YGDRrQC8rgr2YtWrSgF5ThxOGDxZ+868rP084v01S1dn1Fx1fX7q+L3rG2c8MKVUm62syYljJq1ChlZ2crKytL8+bNU7t27TR37lz6QDlKqxt9oHS5ubk6fvx48defffaZGjduTB8oR2Fergpyjxd/vSN9mRIbttQ/lu/VkMU7NGTxDkUnJOrxt7+UI55eIJX+XGNdUDpHfDXFXpmog1lFs42dG9KUUCdZP6z7VKvfHKf/mfChQiPoBSgp2OwAF9NPmeu1afHbqnZ1Y716d0tJUofHXlCDG9l/qCyTJk1Snz59VFhYqLp162rWrFlmR7Kke+65RytXrtShQ4eUmJio5557TkOHDlWvXr00Y8YM1apVS++//77ZMS3FX824JaRs/mo2bdo0PfHEE3K73QoPDy/ekwhF1q1bpzlz5qhJkyZq3ry5JOnFF1/UwIEDVVBQoPbt20sq+tCO119/3cyollJa3R588EE9+OCDaty4sUJDQzV79mxecf9dTk6O+vbtK4/HI6/Xq169eqlLly5q06YNvaAUpdUMpTt+MEfvD+8nn8cjn8+rJu17KrltZ0U4YvXx2Kfl9bgVHBau7v94zeyolvfYY4/RB84BfaB0+/fvV7duRe/odrvd6t27tzp27KhWrVrRB8pw4tf9mjPoTkmS1+NW8453q/4N7AtZltKea1FRUawLyvDnIeP17t/7yuMqVFxiHfUcMV2T771eHleBZg4omgslNUlVt79PMTkprMIoZz+ZI5JiLlGWCjEMQ6MyCs2OUakMSwm16v5BHkk2s0P4YxiGVWsmSW5Z9IUOi9fNkixcM68seteBhWtmaRauG8+1y4iFa2bZ3ilxfXsuLHx9a1kWPj5ZE5wbS9eNc1rFWPic5pNkyVdHeJ6dm9+fa5b8NzWTJRcjAAAAAAAAAHCpMCQFAAAAAAAAENAYkgIAAAAAAAAIaAxJAQAAAAAAAAQ0hqQAAAAAAAAAAhpDUgAAAAAAAAABjSEpAAAAAAAAgIDGkBQAAAAAAABAQGNICgAAAAAAACCgMSQFAAAAAAAAENAYkgIAAAAAAAAIaAxJAQAAAAAAAAQ0hqQAAAAAAAAAAhpDUgAAAAAAAAABjSEpAAAAAAAAgIDGkBQAAAAAAABAQAs2O8DF4tifrRpbNyg/KkZ7UtrKGxJidiQAAADAUoLz85T09WqF5DuV3eIGOeMSzI4EIABEHsxR4pYvVGB3aM+1beUJDTM7EgKZz6eEHVt0xU87dKRmXe1PbiEZhtmpYILLbkhquN3q9MJf1fDT9+QJCZUk+YwgffjKB/q55c0X7e/mnzimVbPHaf+P3+rKqxvplvufUVik46L9vcuBz+fTrFmztGjRoqC4uDgNGjRIycnJZseyvC+//FJTpkxRXl6erXfv3urWrZvZkSzvwIEDeumll7R79261atVKgwYNUlgYF2Jlcbvdmjx5slauXGnUrFlTQ4YMUa1atcyOZXnLli3TzJkzJUn9+/dXu3btTE5kfVlZWRozZoxycnKMW2+9VY8++qhsNpvZsSwtPz9fL7/8sjZu3Ki6detq2LBhio+PNzuWpfl8Pn344YeaN2+ezW6367HHHlOrVq3MjmW6a5Z/pC7/fEDeIJsM+WRzFWrj3Y9q5ROjJMPQ/p3fas3cico/flTJN3dRSpd7ZbBoLNPRo0c1evRobdu2TU2aNNGzzz4rh4M1QVm8Xq9mzZqlxYsXB1WpUkWDBg1SgwYNzI5leenp6fr3v/+t/Pz8oD59+qhr165mRzo7Xq/+NOpxNfn4rd/X64Yknz4a/Y52X9/hov7p47/u18pZY3Rk309KatxaN977hIIZzpbJ7XZr0qRJWrVqlZGYmKghQ4YoKSnJ7FgXlP23A+r1WBfFZW2Xz2aT4fXqWLUkvTtlsY5XO7f/1u1ffK6Mj9+SZKh1936qexFnUbiwDJ/PV9b3j0iKuURZKsQwDI3KKDzj8ZZvv6q2U/6p0HxniccLI6I0+dMsFUZFX/AshXlOvXp3Sx3dv0fuwgIFh4YrplqSBr7zlUIj7Bf8752rYSmhKuff+5J67LHHNGvWLDmdThmGIbvdrjVr1qhFixZmRytmGIalavb555+ra9euysvLkyTZ7XYNHz5czz77rMnJSrJS3Q4ePKjGjRvr8OHDcrlcioiIULNmzbR27VpLDWKsVDNJ6tq1q5YtWyan0ymbzaaoqChlZmaqdu3aZkcrZrWavfXWWxowYICczqL+Y7fbNW3aNPXu3dvkZCVZqW47d+5USkqKcnNz5fF4ZLfb1bFjR82fP9/saCVYqWYej0dt2rTR1q1blZeXp5CQEFWpUkVbt25VlSpVzI5XzEo1k6SRI0fqxRdfLD4+IyIitGjRIsu9kFHa9e3F4NifrYfvaKSQgrwSjxdGRGrxiGlaXrOOpva/Te6CPPl8PoWE29WqWz/9+ZmXL0m+s2Wl69vc3Fw1bdpUe/fuVUFBgcLDw3XVVVdp06ZNioiIMDteMasdn4888ojmzp2r3NxcBQUFKSIiQuvWrVOzZs3MjlbMajVbunSpevToUeKa44UXXtDTTz9tcrKS/J3Tms2frtteHnzmej3crn8v2an82IvTy078dkAT7myhvONH5HW7FBIWoRrJLfTw9DQFBVlnF0IrndN8Pp+6dOmilStXyul0Kjg4WFFRUdq8ebOl3jxxvr2z199u11UbV8rmdhc/5rHZtL9Bit6as67Cv2/jgtlaOHqgXPlF/TUkPEI9hk9Xsz/dec4ZL4bfn2u88nka65wNLpBm/51xxglXknyGobrrP70of/Onzet14tf9chcWSJLchfk6cegX/bzli4vy9y4HPp9Pb7zxRnFj9/l8ys3N1dSpU01OZm3jxo0rHpBKktPp1MsvW2uxYjVLlixRbm6uXC6XJCkvL0/ffPONtm/fbnIy6/r111+1dOnS4uPT4/EoNzdX7733nsnJrG306NHFNZOKjs/Ro0ebmMj65s2bVzwglYpq9vHHH+vo0aMmJ7Oubdu2adu2bcW9wOVy6cSJE1q6dKnJyaxt/PjxJY7PvLy8gO+f16R9JPlZiIfm5ar5/On68oOpcuU7ixfrrnynvvzgjUsds1JZs2aNDh48qIKCojVBfn6+9u3bp/T0dJOTWZfH49GMGTOUm5srqehdpbm5uZoxY4bJyaxt7NixZ1xzjBs3zsREZ6/5h9P9rtdlGLp6zeKL9ne/X71EhXm58rqL1gSugjzt+z5Tv+758aL9zcru4MGDWr58efFzze12y+l06oMPPjA52YVjK8hX7a9WlBiQSpLN41HC9i2y/3agwr9z1ZtjigekkuTKz9PqN8eed1ZcGpfdkLTQXvrtLIUX6fb30Igo+XzeEo/5fF6FhEdelL93uTj9dufg4GBFR1/4d/peTqKjo894pdNut867la0oMvLM49Dj8fh9HEXCw8PPeCwkJERRUVEmpKk8/N1OyS2WZXM4HArxs2c422GULjIysniofJLP5+OcVo7Te2VQUJBiY2NNSmMNhXaHfH7uqPAahgocsQqLdCjIVnJnLm5LLVtkZKS83pJrAq/XS/8sQ1BQ0Bl9ICQkhP5ZDn9rgsrSBwoi/a/3fEZQmWv58xUaYT9juxCf16PQiMpRNzOEh4efcU6z2WyV5rl2NnxBNnltpe1C6ZMnpOJ9L8zP85itGCuPy25Iuu7hv6swvOSFsMdmU15MnHan/vGi/M1aTVOV3LaLQiMiFRJhV2hEpJJv/rNqNU29KH/vcmAYhqZOnaqIiAhFRkbK4XAoMTFRgwcPNjuapY0ePVpxcXGKiopSZGSkIiMjNX36dLNjWVrXrl3VunXr4prZ7XY9/vjjlrpFxGoiIyP14osvFh+fUVFRql+/vvr27Wt2NEubMmWKHA6HoqKiFBUVpejoaE2ePNnsWJb2wAMPqF69eiWOz7Fjx/od1KNI3bp1NWDAANnt9uLjs02bNurcubPZ0Sxt+vTpstvtxcdnfHy8Ro4caXYsU33foafcoWHynjZo8YRFKP3+wbr5/mfkqFpdofaoomvcsAh1/1/eSVqWG264QZ07dy4+n0VGRqp79+5q2bKl2dEsyzAMvfHGGyWuOZKSkvTUU0+ZHc3Sxo4dqyuuuKL4nBYZGalp06aZHeusfNF/2Jnr9SCbCu1R+rHtxetlDdvdoZrJKQq1RykkPFIh4Xbd0OcJxSTUvGh/s7KLjo7Wv/71rxLXHMnJybrvvvvMjnbBeENCtKnHw3KFl9wSxRUWoe863KkCR8V3n+z6/yYrLNJR1D/tUQqPitGfnx1/oSLjIrvs9iSVpORP5qndhKGKOHJIhs+nrFa36pMRU3Wiao2Llsfn82n316v1a/YuVUmsqzrXtrXcxvZW2t/kpO3bt2vt2rXe6OjooM6dO1tqvybJevsPSdKRI0e0dOlSFRQUeG699VabFYd9Vqub1+vVZ599pr1796pJkyZq3bq12ZHOYLWaSdLmzZu1ceNGX9WqVY3bb79dwcHW+qw/K9Zs//79+vzzzyVJHTp0UEKC9T4l2mp1c7lcWrJkiQ4dOuRr1aqV0bRpU7MjncFqNZOKPrDj22+/VWJiojp06GC5aw4r1uynn37SihUrPOHh4bZOnTopJsZ6l7iXck9SSYr9+Ud1HtFfNbZ+JUk6dmWiPh86Ubtu6CipaN/9H9YuUWGeU1c1b6P4WvUuWbazZbXrW5/Pp5UrV2rXrl2qV6+e2rZta3akM1jx+Pzhhx+0bt06b0xMTFDnzp0t92KZFWt25MgRffLJJyosLPS2a9cuyIofplPaOe2a5f/VbS8PVuSv+2X4fNrT4kYtGTFNx6pf3HWN1+vV9vWf6vihX1StXhMlNbLeCxhWO6dJUmZmpr7++mtfQkKC0alTJ0uuCc6ndxput26e8k+1eP912dwueYNs2nLH/Vrx5Gh5zvEOiuOHftGPXy6XDEP12rRX1BVVzznfxcKepP5dlkNSSZLPp/Cjv8kdbpc73FqDN7NY8YT7O48k63yCzimseEF0Crcka3Wo31m8bpZk4Zp5ZdG7DixcM0uzcN14rl1GLFwzy/ZO6dIPSU8KcZ5QkNulgugrLvnfPl8Wvr61LAsfn6wJzo2l61bqOe3kej0sQm4Lfdix2Sx8TvNJsuRA7UL1TsPtVvjxIyqIipHXz3ZQlxuGpP5Z9iLxvBnGRftkPAAAAOBy4bKzZyaAS4z1OizGFxysvCvizY4Bk1nyHRsAAAAAAAAAcKkwJAUAAAAAAAAQ0BiSAgAAAAAAAAhoDEkBAAAAAAAABDSGpAAAAAAAAAACGkNSAAAAAAAAAAGNISkAAAAAAACAgMaQFAAAAAAAAEBAY0gKAAAAAAAAIKAxJAUAAAAAAAAQ0BiSAgAAAAAAAAhoDEkBAAAAAAAABDSGpAAAAAAAAAACGkNSAAAAAAAAAAGNISkAAAAAAACAgMaQFAAAAAAAAEBAY0gKAAAAAAAAIKAxJAUAAAAAAAAQ0BiSAgAAAAAAAAhoDEkBAAAAAAAABDSGpAAAAAAAAAACGkNSAAAAAAAAAAGNISkAAAAAAACAgMaQFAAAAAAAAEBAY0gKAAAAAAAAIKAxJAUAAAAAAAAQ0BiSAgAAAAAAAAhoDEkBAAAAAAAABLTgcr7vkOS+FEHOQXnZ4Z8V/z2DJfkkecwO4kewrFkzm6ybTbJmNkNFdbNarpOsWDOpKJf39/9ZjZVrJlkzm2TNunF8nptgFfVOn9lB/LByzax6zSFxfXuurPpcs2IuybrZrHx8WrVmNlm/f6LirPjvafU1AXBBGD5f6dfVibWu8u3d8/MljHP2gkPD5C4sMDsGAAAAcEFwfQvgcsI5DZcCz7NzExwWvt+Vn1fN7BxWU+aQ1DAM36iMwksYp/IblhKqsmoKvzyGYdioW8UYhsFzrYKo2TnxGoYRRC+oGHpBxXF8nhvqVmFuwzCCOadVDOe0iuPYPCesCc6BYRjinFYxnNPOic8wjDLnRziD1zCMIJ/PZ5gdBGePPUkBAAAAAAAABDSGpAAAAAAAAAACGkNSAAAAAAAAAAHtgg1JvR6PXr2nld4ceMeF+pWXvfHjx6tRo0Zq3Lix7rnnHuXn55sdyXIefPBBJSQkqHHjxsWPPfPMM2rQoIGaNm2qbt266ciRIyYmtB5/NZOkSZMmqX79+mrUqJGeffZZk9JZ0549e3TrrbcqOTlZjRo10sSJEyVJv/32m9q3b6969eqpffv2Onz4sMlJreXIL3s07eH2eqV7E43v2Uzr/jOpxPdXv/WKhqWEKvfwIZMSWk9pz7XMzExdd911at68uVq2bKkNGzaYnNQ68vPz1bp1azVr1kyNGjXS8OHDJdELylNa3ST6QXlOv6Z1Hv1NMwZ00riuDTVjQCflHaMXnM7j8ahFixbq0qVLicfHjRsnwzB06BB94HSn14w+UL7atWurSZMmxTWS6AXlGd25nib0aqFX726pyX2uK358/bwperlbI43v2UyfTBhqYkLrOXLkiHr27KkGDRooOTlZX3zxBWuCs+CvbifRC1CZXLAh6bp3JimhToML9esue3v37tWrr76qjRs3auvWrfJ4PJo3b57ZsSzn/vvv19KlS0s81r59e23dulVbtmzRNddco1GjRpmUzpr81WzFihVasGCBtmzZom+//VaDBw82KZ01BQcH6+WXX9Z3332n9PR0TZkyRdu2bdNLL72k2267TTt27NBtt92ml156yeyolhJkC9btT43R0x9+o7/NXqsv3ntN+3dtk1Q0QP0xfbliq9UyOaW1lPZce/bZZzV8+HBlZmbq+eefZ3B1irCwMKWlpWnz5s3KzMzU0qVLlZ6eTi8oR2l1ox+U7/Rr2lWzxugPrW/V4AXb9IfWt2rlrDEmprOmiRMnKjk5ucRje/bs0eeff65ategD/pxeM/rA2VmxYoUyMzO1ceNGSawLzsZDb3yugfM26rG30yVJO79aqW0rP9YT72boqQ8266b/edrkhNbyxBNPqGPHjvr++++1efNmJScnsyY4C/7qJtELUPlckCHp0f3Z+mHNJ2p1x4MX4tcFDLfbrby8PLndbjmdTtWoUcPsSJbTtm1bxcXFlXisQ4cOCg4OliRdd911ys7ONiOaZfmr2WuvvaahQ4cqLCxMkpSQkGBGNMuqXr26UlJSJEkOh0PJycnau3evFixYoL59+0qS+vbtq48++sjMmJYTXbW6aia3kCSFRTqUUKeBjh3YJ0la/PJgdXryRcngwxxPVdpzzTAMHTt2TJJ09OhR+sEpDMNQVFSUJMnlcsnlcskwDHpBOUqrG/2gbP6uabet+lgpXe6TJKV0uU/bVi40K54lZWdna/Hixerfv3+Jx5966imNGTNGBn3gDP5qRh84N/SCivvygzd0ywPPKDi0qA9ExdEHTjp27JhWr16tfv36SZJCQ0MVGxvLmqAcpdVNoheg8rkgQ9JF4wap0xOjZASxxenZqlmzpgYPHqxatWqpevXqiomJUYcOHcyOVenMnDlTnTp1MjuG5W3fvl1r1qxRamqqbr75Zn311VdmR7KsrKwsbdq0Sampqdq/f7+qV68uqWi4deDAAZPTWdfhfVna98NmJTVurW2rPlZ0Qk1Vv6aZ2bEs7dTn2oQJE/TMM88oKSlJgwcP5p0wp/F4PGrevLkSEhLUvn17paamlvg+vcA/f3WjH5TN3zXtiV8PKLpqUS+IrlpdJ347aFY8S3ryySc1ZswYBZ1Ss4ULF6pmzZpq1ow+4I+/mtEHynfyBbJrr71WU6dOPeP79IIzGYahmY/erkm9U7Vh/nRJ0qGfdmh3xlpN+Z8bNLX/bdrz7UaTU1rHrl27VLVqVT3wwANq0aKF+vfvr9zcXNYE5SitbvQCVEbnPdX8bvViRcYlqGbDlAuRJ2AcPnxYCxYs0O7du7Vv3z7l5uZq7ty5ZseqVEaOHKng4GD16dPH7CiW53a7dfjwYaWnp2vs2LHq1auXfD6f2bEs58SJE+rRo4cmTJig6Ohos+NUGgXOE5o7+C51GTROQbZgrZjxkto/Mrz8Hwxgpz/XXnvtNY0fP1579uzR+PHji1+JRxGbzabMzExlZ2drw4YN2rp1a/H36AWl81c3+kHpuKatuEWLFikhIUHXXntt8WNOp1MjR47U888/b2Iy6/JXM0n0gbOwbt06ZWRk6JNPPtGUKVO0evXq4u/RC/x7ZNZKPf6fDXpg8sf64r3XtPvrNfJ63Mo7fkR/m71WnZ58Se8M6U0f+J3b7VZGRoYGDBigTZs2KTIyklvrz4K/uo0YMYJegErpvIekP21er+9WLdLozvX0zrB7tWvjCr37974XIttlbdmyZapTp46qVq2qkJAQde/eXevXrzc7VqUxe/ZsLVq0SG+//TZv3T8LiYmJ6t69uwzDUOvWrRUUFMTG2adxuVzq0aOH+vTpo+7du0uSrrzySuXk5EiScnJyuC3VD4/LpbcH36Xmt9+jxrd102/ZO3V4b5Ym3t1SozvX07ED2ZrUJ1XHD/1idlTL8Pdcmz17dvHXd955Jx/YUYrY2Fjdcsstxfsu0wvOzql1ox+UrrRr2qgqCTp2sKgXHDuYo6i4qiYntY5169Zp4cKFql27tu6++26lpaXpvvvu0+7du9WsWTPVrl1b2dnZSklJ0S+/0Ack/zW799576QNn4eQWBAkJCerWrVtxjegFpYuuWlSzqLgENbq1q/Z8+5WiExLVuN0dMgxDSY1byQgKUu4R+oBUtGZKTEwsvmOlZ8+eysjIYE1QjtLqRi9AZXTeQ9KOj4/UsKW7NWTxDt0zaq7qtrxVd42cfSGyXdZq1aql9PR0OZ1O+Xw+LV++/IwN7+Hf0qVLNXr0aC1cuFB2u93sOJXCHXfcobS0NEkKFbN9AAAQ3ElEQVRFt94XFhYqPj7e5FTW4fP51K9fPyUnJ+vpp/9v8/q//OUvmj276Hw2e/Zsde3a1ayIluTz+TT/+YdVtU4D3XTvk5KkavWa6B/L92rI4h0asniHohMS9fjbX8oRX83ktNZQ2nOtRo0aWrVqlSQpLS1N9erVMyui5Rw8eLD404rz8vK0bNkyNWjQgF5QjtLqRj8oXWnXtMlt/6yMRXMkSRmL5qjhzX82Oal1jBo1StnZ2crKytK8efPUrl07zZ8/XwcOHFBWVpaysrKUmJiojIwMVatGH5D812zu3Ln0gXLk5ubq+PHjxV9/9tlnaty4Mb2gDIV5uSrIPV789Y70ZbryD43U6Na/aOdXKyRJB3/aLo+rUJGx9AFJqlatmpKSkvTDDz9IkpYvX66GDRuyJiiHv7qlpKTQC1ApBZsdIFClpqaqZ8+eSklJUXBwsFq0aKGHH37Y7FiWc88992jlypU6dOiQEhMT9dxzz2nUqFEqKChQ+/btJRVt0v7666+bnNQ6/NXswQcf1IMPPqjGjRsrNDRUs2fP5pX2U6xbt05z5sxRkyZN1Lx5c0nSiy++qKFDh6pXr16aMWOGatWqpffff9/kpNbyU+Z6bVr8tqpd3Viv3t1SktThsRfU4Eb2AytNac+1adOm6YknnpDb7VZ4eLjfvdYCVU5Ojvr27SuPxyOv16tevXqpS5cuuvrqq+kFZSitboWFhfSDCrr5gWf0zpDe2vjRm4qtlqTeY94xOxIuQ/SBsu3fv1/dunWTVHRrb+/evdWxY0d6QRlO/LpfcwbdKUnyetxq3vFu1b/hT3K7CjV/xEOacGdz2UJCdedzM+gDp5g0aZL69OmjwsJC1a1bV7NmzSruo6wJSuevbkBlZJS1/4hhGL5RGYWXME7lNywllD1dKs5jGIaNulWMYRg81yqImp0Tr2EYQfSCiqEXVBzH57mhbhXmNgwjmHNaxXBOqziOzXPCmuAcGIYhzmkVwzntnPgMwyhzfoQzeA3DCPL5fLwKUYnwcfQAAAAAAAAAAhpDUgAAAAAAAAABjSEpAAAAAAAAgIDGkBQAAAAAAABAQGNICgAAAAAAACCgMSQFAAAAAAAAENAYkgIAAAAAAAAIaAxJAQAAAAAAAAQ0hqQAAAAAAAAAAhpDUgAAAAAAAAABjSEpAAAAAAAAgIDGkBQAAAAAAABAQGNICgAAAAAAACCgMSQFAAAAAAAAENAYkgIAAAAAAAAIaAxJAQAAAAAAAAS0YLMDXCohzhOq88XnCnUe195mbXS4Vj2zIwEALCgme5eSNq2VKyJSu9t0UGGkw+xIAHDp+Xy68vtMJWzfoo6SVFgohYaanQpAJRPkcumqDWmKOvSLDtRrov3JLSTDMDsWAPhVqYakXq9XG+ZP17dpHyo0Ikpt+w7WVc2uK/fnrl71sf4y7D75bDYZXq8Mr0c/tu2ij/81W96QkEuQ3FxffPGFxowZoxMnTqhnz5566KGHFBTEm4jL8ssvv+if//ynduzYoRYtWmj48OGKiYkxO5aluVwuvfLKK/rss89UtWpV/eMf/1Djxo3NjmV5S5cu1eTJk+XxeHT//ffrrrvuMjuS5f2WvUvL3nhBR/dnq3aLG3XLA88qJDzivH+v4fHo9hH91WDZfPmCbPIFBSnI49ai52bqh/Y9LkBy8zidTr344otav369kpKS9Nxzz6l27dpmx7I0n8+nefPm6c0331RISIgGDhyoDh06mB3L8rZs2aKRI0fq0KFD6tixo5566ikFB1eqy81LLu/4ES17/XnlbN+ihNr19ccBwxUVl2BqprDjR9XrsS6q+uNWSdKNklSjhrR0qdSypanZpKI1weuvv67//ve/cjgcGjJkiFJTU82OZXlr167VuHHjlJubq169eql///4yGFaVKScnR8OHD9eOHTuUkpKi4cOHKzo62uxYluZxubRmziv68cvlutYWrBnbvlaIxy3D65UkHaqbrHf/vUQFjliTk1rLkiVLNGXKFHm9XvXr1089e/Y0O5Ll7dy5UyNGjNDevXt10003adiwYQoPDzc7Fio5w+fzlf5Nw/CNyii8hHHK9vHYQfrqvzPkyndKkkLCItT31QX6Q6tbSv2ZiMMH9bfbr1ZIQV6JxwvDI7T60Re0sc/AC5pxWEqoyqrppZaWlqYuXbooL6/ov99ut+vhhx/W+PHjTU5WgscwDJtV6vbbb7+pYcOG+vXXX+V2uxUWFqarrrpKW7ZsUVhYmNnxihmGYannWvfu3fXpp5/K6XTKMAzZ7XatX79eTZs2NTtaMavV7D//+Y8eeughOZ1F5zS73a4XXnhBTz/9tMnJSvAahhFklV5weF+WXr27lQqcJ+TzehQcFqGaDZrrrzNXnvdCr9n8abrt5WcU+nuPOckVFq43Fn6vE1VrnPXvslIv8Hq9uv7667V582bl5+fLZrPJ4XBoy5YtSkpKMjteMasdn6NHj9bzzz9ffHxGRETozTffVK9evUxOVpKV6paZmakbb7xRTqdTPp9PdrtdXbp00bvvvmt2tFO5DcMItso5zZWfpwm9UnR0f7Y8rgLZgkNkj43XU/M3K8LEAUKnEQ+p0SfvKNh1Wp2uvFLKzpZMHnw/+uijevPNN0v0zyVLlujmm282NdeprHRsStKyZcvUtWvX4ppFRkbqkUce0bhx40xOVoKl1gSHDh1So0aNdPjwYblcLoWFhalOnTravHmzQi30rmrDMGSVc5okvfVUd/345XJ58/P0s6TTr57cIaH6rsOdWvzCLDPiSbLWdZokzZkzR4888kiJc9qoUaM0cOCFnVWcJ59hGGXOjy6lXbt2qUWLFjpx4oS8Xq8iIiLUqlUrrVx5/muCC8hrGEaQz+ezTCCUr1K9nXDjRzOLB6SS5CrIU/r7b5T5M3XXfSqvzXbG46H5eWq64M0LHdFyXn/99eIBqVT0bqLp06ebmMj6VqxYIafTKbfbLUkqKChQTk6ONm3aZHIy68rPz9fChQuLG7vP55PT6dQ777xjcjJrmzhxYnHNpKLjc9KkSSYmsr7vVi+WqzBfPq9HkuQuyNPe7zfp6P7s8/7dTRfMPmNAKkk+I0h/WL3kvH+/WX766Sd98803ys/PlyR5PB7l5+dr0aJFJieztilTppQ4PvPy8jRx4kQTE1nf3LlzlZubW7zwdDqdmj9/vgoLrbN4t5q932Uo9/ABeVwFkiSP26VC5wnt/nq1qbkaLP/wzAGpJDmdUkbGpQ90mlmzZp3RP6dOnWpiIus7/ZyWm5uradOmmZjI+tLS0uR0OuVyuSQVrQn27t2rLVu2mJzMugrzcvXD2qVy5eepqaQoP/+fYFeh6i//76WOZmn+1gSvvvqqiYmsb8GCBcrPz5f393co5+XlacOGDcrJyTE5GSq7SjUkDbWXPM0G2YIVeUV8mT+THxMnyf/g3hlb9s9eDqpUqXLGbW4OB/vrlSUmJqb4ZHuS2+1WbCy3hJQmJCTkjOdZaGio4uLiTEpUOcTFxZ2x9QU1K1t4VLSCgkq+8OXzehVm93cZXjHOuKry+nnl2RcUpPyYK87795vF4XDI4/GUeMxms3FOK8fp9QkKClJ8/OV/3XA+4uLizrjjwl9/wP8Jd8TIe9rx6fN5FW7ybagFkaXcTux2SxboU1FRJc/5wcHBHJ/liI+PZ01QQTExMWe829DtdrMFVxlsIWEyfr+2PazS9/YrjGLLglPFxcWd8e5H1gRli42NPeOc5vV6z+gPQEVVqiFprxdmKTQiUmGRDoXZHYqplqQ//vV/y/yZXW06yHlFvDzBJfceLQy3a105P3s5GDFihJKSkuRwOBQdHa3IyEi99dZbZseytHbt2qlr166KjIyUw+GQ3W7X448/rgYNGpgdzbJsNptmzJihiIgIRUdHKyoqSg0bNtSAAQPMjmZpkyZNUnx8vBwOhxwOh2JiYnindzma/uku1WqSqtCIKIVFOhQSFqFOT4xSRPT5DzHX9xsmT1jJvU09tmAVRMVox81/Pu/fb5b4+HiNHDlSERERcjgcioqK0g033MBeV+WYOXOmoqOjFR0dLYfDofj4eE2YMMHsWJb2+OOPq379+oqKilJ0dLQiIiI0e/Zs9kEvQ7WrGyu1x0MKCbcXndMi7Gp0WzfVSbnJ1Fxr//q/Kgy3l3wwPFy68Ubp6qvNCXWKOXPmyG63Fx+fV111lf7xj3+YHcvSXnjhBdWsWbPEmmDOnDlmx7K09u3bq3PnziXWBE8++aTq1eMDgEtjCw5W9/99XSFhEcqJdGh1kE15pw3/CsPtWvsQx+upJk+erCpVqhSvCWJjY3mndzl69+6tVq1aKSoqSg6HQxEREXrllVfYMxjnrVLtSSpJxw7u089b0hUcFqE/tLpVIWHlb8xr/3W/Orw0UFevXqwgt1u/XVVPaU+P0a4bO13wfFbb30QquhU6LS1NeXl5atOmjWrUOPt99S4RS+0/dFJ6erp+/vlnXXPNNWrevLnZcc5gtb2uJGn37t3auHGjYmNj1a5dO9n8bHVhJivW7Pjx41qxYoW8Xq9uuukmValSxexIp7PUnqRS0XYOuzPW6MSv+1WtXhMl1LlwL2Bc9eVy/XHcIFXZ9b18Npt23tBRn/2/SRXaj1SyZi/47rvv9M033+jKK69U27ZtrbRfkyRrHp+HDh3SmjVrFBwcrFtuucWS77qyWt3cbrfS0tJ09OhRtWrVyoofEGapPUlP2vf9Jh36+UfFVr9KtZq0NjuOJKnpf2fqxjdeUNShHDm9XkU98oj08suS3V7+D18Ce/fuVXp6uux2u9q1a2epfeMl6x2bUtHtqCtWrFBeXp6uv/56Va9e3exIp7PcmsDn8yk9PV179uxRgwYNLLXX/klW25NUKvqQzb3fZSgmPEIPrlmqpovnKrggT7lVrtS6h/6uzB4PmfoJ91a8Tjt27JhWrlwpr9ertm3bWvGdpJbak1QqeufoqlWrdPDgQTVr1kz169c3O9Lp2JO0Eqp0Q9LzYXg8CvK45Qm9eBdRVjzhVgKWuyCqDKx48W111OycWG5IeikEuQqLPuH+HAf99IKK4/g8N9Stwiw5JLUsn0+2wgINaRMtL8+zCuHYPCesCc6BFYekZ/B6ZXMVFq3DLfAiLddp58RyQ9JKgCFpJRRQm0T5bDZ5LPbONgCA9XhDrPOptQBgGsOQJyxcLIkBnJegIHnO4g5QADAbm0QBAAAAAAAACGgMSQEAAAAAAAAENIakAAAAAAAAAAIaQ1IAAAAAAAAAAY0hKQAAAAAAAICAxpAUAAAAAAAAQEBjSAoAAAAAAAAgoDEkBQAAAAAAABDQGJICAAAAAAAACGgMSQEAAAAAAAAENIakAAAAAAAAAAIaQ1IAAAAAAAAAAY0hKQAAAAAAAICAxpAUAAAAAAAAQEBjSAoAAAAAAAAgoDEkBQAAAAAAABDQGJICAAAAAAAACGgMSQEAAAAAAAAENIakAAAAAAAAAAIaQ1IAAAAAAAAAAY0hKQAAAAAAAICAxpAUAAAAAAAAQEBjSAoAAAAAAAAgoDEkBQAAAAAAABDQGJICAAAAAAAACGgMSQEAAAAAAAAENIakAAAAAAAAAAIaQ1IAAAAAAAAAAc3w+Xylf9MwSv8mAAAAAAAAAL98Pp9hdgacvTKHpAAAAAAAAABwueN2ewAAAAAAAAABjSEpAAAAAAAAgIDGkBQAAAAAAABAQGNICgAAAAAAACCgMSQFAAAAAAAAENAYkgIAAAAAAAAIaP8futvzsuCUx/MAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for de in det: # iterate on the dataframes corresponding to each detector\n", + " de = de.set_index(np.arange(16)) # resetting the indexes from 0 to 15 \n", + " display_example = np.array(de['Cell']) \n", + " draw_chamber(d, display_example, de)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Conclusion" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our work provides an algorithm capable of identifying events in drift tube detectors: the graphical check validates the results obtained, since the points are resonably distributed in time and align through the layers, even without the usage of trigger information.\n", + "\n", + "On the other hand, there is room for improvement for what concerns the computational cost of the program: while a summary of our efforts on the topic is written below, further improvements could be achieved via the implementation of auxiliar code exploiting trigger information and the reduction of patterns under investigation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Appendix: code optimization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Particular attention was put into developing a sustainable code to deal with the large amount of data that was provided. In order to do so, we tried to exploit at our best the properties of the Pandas library and to avoid using useless loops, which are expecially computationally demanding. Moreover, we tried to use the power of Numba library to accelerate our script, but we faced some compatibility issues between Numba and Pandas. We gave a try to convert Pandas structures into Numpy ones so to be able to use Numba, but in the end this whole process would have required to rethink completely the approach to data analisys.
\n", + "Therefore, our work was centered on trying to redesign the code reducing the use of statements which could make it slower: the first program we wrote is reported below, while the one we set up is the one used in the previous part of this work. The performance is slightly better on a small dataset ($\\sim15\\%$), but becomes more and more relevant with the increasing size of the dataset.
\n", + "In the end, due to short time and permissions problems, we were not able to use the provided CloudVeneto GPUs: this as well would have given our code a significant boost. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "start_time = time.time()\n", + "\n", + "pd.options.mode.chained_assignment = None # default='warn'\n", + "\n", + "def Find_Next_1(i,data,ev_counter): # Finds the next hit after first layer\n", + " df = data.copy(deep = False)\n", + " t_start = df.at[i,\"Absolute\"]\n", + " cell0 = df.at[i,\"Cell\"]\n", + " cell1, cell2, cell3 = cell0-2, cell0-6, cell0-1 # Define cells to look at (cell1, cell2 belonging \n", + " # to layer 2, cell3 to layer3)\n", + " df2 = df[(df[\"Cell\"] == cell1) | (df[\"Cell\"] == cell2)] # Create subdataframe to analyse\n", + " df2[\"Absolute\"] = np.abs(df2[\"Absolute\"] - t_start) \n", + " if (df2.empty == False) and (df2[\"Absolute\"].min() < 400.): \n", + " i_next = df2[\"Absolute\"].idxmin() # Take the index of the closest click in time\n", + " data.at[i,\"Event\"] = ev_counter # Set the number of the event on the original dataset\n", + " data.at[i_next, \"Event\"] = ev_counter # both in the row of the first and second layer cell\n", + " return i_next # Return index to start again and corresponding cell\n", + " else: \n", + " df3 = df[(df[\"Cell\"] == cell3)] # Create subdataframe to analyse\n", + " df3[\"Absolute\"] = np.abs(df3[\"Absolute\"] - t_start)\n", + " if (df3.empty == False) and (df3[\"Absolute\"].min() < 400.):\n", + " i_next = df3[\"Absolute\"].idxmin() # Take the index of the closest click in time\n", + " data.at[i,\"Event\"] = ev_counter # Set the number of the event on the original dataset\n", + " data.at[i_next, \"Event\"] = ev_counter # both in the row of the first and second layer cell\n", + " return i_next\n", + " else: \n", + " return -1\n", + "\n", + "def Find_Next_2(i,cstart,data,ev_counter): # Finds the next hit after second layer\n", + " df = data.copy(deep = False)\n", + " t_start = df.at[i,\"Absolute\"]\n", + " cell0 = df.at[i,\"Cell\"]\n", + " if cstart - cell0 == 6: # Define cells to look at (cell1, cell2\n", + " cell1, cell2 = cell0 + 5, cell0 - 1 # belonging to layer 3, cell3 to layer4)\n", + " else:\n", + " cell1, cell2 = cell0 + 1, cell0 - 1 \n", + " df2 = df[(df[\"Cell\"] == cell1)]\n", + " df2[\"Absolute\"] = np.abs(df2[\"Absolute\"] - t_start) \n", + " if (df2.empty == False) and (df2[\"Absolute\"].min() < 400.): \n", + " i_next = df2[\"Absolute\"].idxmin() # Take the index of the closest click in time\n", + " data.at[i,\"Event\"] = ev_counter # Set the number of the event on the original dataset\n", + " data.at[i_next, \"Event\"] = ev_counter # both in the row of the first and second layer cell\n", + " return i_next # Return index to start again and corresponding cell\n", + " else: \n", + " df3 = df[(df[\"Cell\"] == cell2)] # Create subdataframe to analyse\n", + " df3[\"Absolute\"] = np.abs(df3[\"Absolute\"] - t_start)\n", + " if (df3.empty == False) and (df3[\"Absolute\"].min() < 400.):\n", + " i_next = df3[\"Absolute\"].idxmin() # Take the index of the closest click in time\n", + " data.at[i,\"Event\"] = ev_counter # Set the number of the event on the original dataset\n", + " data.at[i_next, \"Event\"] = ev_counter # both in the row of the first and second layer cell\n", + " return i_next\n", + " else: \n", + " return -1\n", + "\n", + "def Find_Next_3(i,cstart,data,ev_counter): # Finds the next hit after third layer\n", + " df = data.copy(deep = False)\n", + " t_start = df.at[i,\"Absolute\"]\n", + " cell0 = df.at[i,\"Cell\"]\n", + " if cstart - cell0 == -5: \n", + " cell1 = cell0 -6\n", + " df = df[(df[\"Cell\"] == cell1)]\n", + " if cstart - cell0 == -1: \n", + " cell1 = cell0 -2\n", + " df = df[(df[\"Cell\"] == cell1)]\n", + " else:\n", + " cell1, cell2 = cell0 -5, cell0 - 2 # Define cells to look at (cell1, cell2 belonging to layer 4)\n", + " df = df[(df[\"Cell\"] == cell1) | (df[\"Cell\"] == cell2)] \n", + " df[\"Absolute\"] = np.abs(df[\"Absolute\"] - t_start) \n", + " if df.empty == False and (df[\"Absolute\"].min() < 400.): \n", + " i_next = df[\"Absolute\"].idxmin() # Take the index of the closest click in time\n", + " data.at[i_next,\"Event\"] = ev_counter # Set the number of the event on the original dataset\n", + " return i_next # Return index to start again and corresponding cell\n", + " else: \n", + " return -1 \n", + "\n", + "\n", + "def Find_Next_from_2(i, data, ev_counter):\n", + " df = data.copy(deep=False)\n", + " t_start = df.at[i,\"Absolute\"]\n", + " cell0 = df.at[i, \"Cell\"]\n", + " cell1, cell2 = cell0 + 1, cell0 + 5\n", + " df = df[(df[\"Cell\"] == cell1) | (df[\"Cell\"] == cell2)]\n", + " df[\"Absolute\"] -= t_start\n", + " df = df[df[\"Absolute\"] > 0] # Find the only times that occur later than the hit on first layer \n", + " if df.empty == False and (df[\"Absolute\"].min() < 400.): \n", + " i_next = df[\"Absolute\"].idxmin() # Take the index of the closest click in time\n", + " data.at[i,\"Event\"] = ev_counter # Set the number of the event on the original dataset\n", + " data.at[i_next, \"Event\"] = ev_counter # both in the first layer cell row and in the second layer cell row\n", + " return i_next # Return index to start again\n", + " else:\n", + " return -1\n", + "\n", + "\n", + "def Is_Event(df, ev_counter): \n", + " layer1 = [4*i+4 for i in range(16)] # Divides cell numbers in layers\n", + " layer2 = [4*i+2 for i in range(16)]\n", + " layer3 = [4*i+3 for i in range(16)]\n", + " layer4 = [4*i+1 for i in range(16)]\n", + "\n", + " idx_lay1 = pd.Series(np.array(df.index[df[\"Layer\"] == 1]))\n", + " idx_lay2 = pd.Series(np.array(df.index[df[\"Layer\"] == 2]))\n", + " \n", + " if idx_lay1.empty == False:\n", + " for i in idx_lay1: # For each time a particle hits first the first layer:\n", + " ev_counter += 1 \n", + " i_cell = df.at[i,\"Cell\"] \n", + " j = Find_Next_1(i, df, ev_counter) # See if (and when) it hits the second layer\n", + " if j != -1:\n", + " j_cell = df.at[j,\"Cell\"]\n", + " if j_cell in layer2: # If so, look for the hit in the third...\n", + " k = Find_Next_2(j, i_cell, df, ev_counter)\n", + " if k != -1:\n", + " k_cell = df.at[k,\"Cell\"]\n", + " if k_cell in layer3:\n", + " t = Find_Next_3(k, j_cell, df, ev_counter)\n", + " if j_cell in layer3: # ...otherwise for the hit in the fourth\n", + " t = Find_Next_3(j, i_cell, df, ev_counter)\n", + " \n", + " if idx_lay2.empty == False: \n", + " for i in idx_lay2:\n", + " if df.at[i,\"Event\"] == 0:\n", + " ev_counter += 1\n", + " k = Find_Next_from_2(i, df, ev_counter)\n", + " if k != -1:\n", + " k_cell = df.at[k,\"Cell\"]\n", + " if any(df[\"Cell\"] == k_cell - 1):\n", + " df.at[(np.abs(df[\"Absolute\"]-df.at[k,\"Absolute\"])).idxmin(), \"Event\"] = ev_counter \n", + "\n", + " return ev_counter" + ] + } + ], + "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.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}