diff --git a/analyses/cms-open-data-ttbar/ttbar_analysis_pipeline.ipynb b/analyses/cms-open-data-ttbar/ttbar_analysis_pipeline.ipynb index f2ebc252..4c89efbb 100644 --- a/analyses/cms-open-data-ttbar/ttbar_analysis_pipeline.ipynb +++ b/analyses/cms-open-data-ttbar/ttbar_analysis_pipeline.ipynb @@ -1,5 +1,31 @@ { "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "f643dd5e", + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"error\")\n", + "\n", + "# ---\n", + "# jupyter:\n", + "# jupytext:\n", + "# formats: ipynb,py:percent\n", + "# text_representation:\n", + "# extension: .py\n", + "# format_name: percent\n", + "# format_version: '1.3'\n", + "# jupytext_version: 1.14.5\n", + "# kernelspec:\n", + "# display_name: Python 3 (ipykernel)\n", + "# language: python\n", + "# name: python3\n", + "# ---" + ] + }, { "cell_type": "markdown", "id": "c40fe12f", @@ -55,13 +81,13 @@ "import time\n", "\n", "import awkward as ak\n", - "import cabinetry\n", + "# import cabinetry\n", "from coffea import processor\n", - "from coffea.nanoevents import transforms\n", - "from coffea.nanoevents.methods import base, vector\n", - "from coffea.nanoevents.schemas.base import BaseSchema, zip_forms\n", - "from func_adl import ObjectStream\n", - "from func_adl_servicex import ServiceXSourceUpROOT\n", + "from coffea.nanoevents import NanoAODSchema\n", + "# from servicex import ServiceXDataset\n", + "# from func_adl import ObjectStream\n", + "# from func_adl_servicex import ServiceXSourceUpROOT\n", + "\n", "import hist\n", "import json\n", "import matplotlib.pyplot as plt\n", @@ -70,7 +96,7 @@ "\n", "import utils # contains code for bookkeeping and cosmetics, as well as some boilerplate\n", "\n", - "logging.getLogger(\"cabinetry\").setLevel(logging.INFO)" + "# logging.getLogger(\"cabinetry\").setLevel(logging.INFO)" ] }, { @@ -89,16 +115,17 @@ "\n", "| setting | number of files | total size |\n", "| --- | --- | --- |\n", - "| `1` | 9 | 16.3 GB |\n", - "| `5` | 45 | 81.7 GB |\n", - "| `10` | 86 | 157 GB |\n", - "| `50` | 357 | 678 GB |\n", - "| `100` | 590 | 1.09 TB |\n", - "| `500` | 1542 | 2.58 TB |\n", - "| `1000` | 2249 | 3.57 TB |\n", - "| `-1` | 2269 | 3.59 TB |\n", - "\n", - "The input files are all in the 1–2 GB range." + "| `1` | 12 | 25.1 GB |\n", + "| `2` | 24 | 46.5 GB |\n", + "| `5` | 52 | 110 GB |\n", + "| `10` | 88 | 205 GB |\n", + "| `20` | 149 | 364 GB |\n", + "| `50` | 264 | 636 GB |\n", + "| `100` | 404 | 965 GB |\n", + "| `200` | 604 | 1.40 TB |\n", + "| `-1` | 796 | 1.78 TB |\n", + "\n", + "The input files are all in the 1–3 GB range." ] }, { @@ -111,10 +138,10 @@ "### GLOBAL CONFIGURATION\n", "\n", "# input files per process, set to e.g. 10 (smaller number = faster)\n", - "N_FILES_MAX_PER_SAMPLE = 5\n", + "N_FILES_MAX_PER_SAMPLE = 1\n", "\n", "# enable Dask\n", - "USE_DASK = True\n", + "USE_DASK = False\n", "\n", "# enable ServiceX\n", "USE_SERVICEX = False\n", @@ -143,8 +170,8 @@ "DISABLE_PROCESSING = False\n", "\n", "# read additional branches (only with DISABLE_PROCESSING = True)\n", - "# acceptable values are 4, 15, 25, 50 (corresponding to % of file read), 4% corresponds to the standard branches used in the notebook\n", - "IO_FILE_PERCENT = 4" + "# acceptable values are 2.7, 4, 15, 25, 50 (corresponding to % of file read), 2.7% corresponds to the standard branches used in the notebook\n", + "IO_FILE_PERCENT = 2.7" ] }, { @@ -166,10 +193,15 @@ "execution_count": 3, "id": "ce9f9967", "metadata": { + "lines_to_next_cell": 2, "tags": [] }, "outputs": [], "source": [ + "import hist.dask\n", + "import dask_awkward as dak\n", + "\n", + "\n", "# functions creating systematic variations\n", "def flat_variation(ones):\n", " # 2.5% weight variations\n", @@ -178,15 +210,15 @@ "\n", "def btag_weight_variation(i_jet, jet_pt):\n", " # weight variation depending on i-th jet pT (7.5% as default value, multiplied by i-th jet pT / 50 GeV)\n", - " return 1 + np.array([0.075, -0.075]) * (ak.singletons(jet_pt[:, i_jet]) / 50).to_numpy()\n", + " return 1 + np.array([0.075, -0.075]) * (dak.singletons(jet_pt[:, i_jet]) / 50).to_numpy()\n", "\n", "\n", "def jet_pt_resolution(pt):\n", " # normal distribution with 5% variations, shape matches jets\n", - " counts = ak.num(pt)\n", - " pt_flat = ak.flatten(pt)\n", - " resolution_variation = np.random.normal(np.ones_like(pt_flat), 0.05)\n", - " return ak.unflatten(resolution_variation, counts)\n", + " counts = dak.num(pt)\n", + " pt_flat = dak.flatten(pt)\n", + " resolution_variation = np.random.normal(dak.ones_like(pt_flat), 0.05)\n", + " return dak.unflatten(resolution_variation, counts)\n", "\n", "\n", "class TtbarAnalysis(processor.ProcessorABC):\n", @@ -197,7 +229,7 @@ " name = \"observable\"\n", " label = \"observable [GeV]\"\n", " self.hist = (\n", - " hist.Hist.new.Reg(num_bins, bin_low, bin_high, name=name, label=label)\n", + " hist.dask.Hist.new.Reg(num_bins, bin_low, bin_high, name=name, label=label)\n", " .StrCat([\"4j1b\", \"4j2b\"], name=\"region\", label=\"Region\")\n", " .StrCat([], name=\"process\", label=\"Process\", growth=True)\n", " .StrCat([], name=\"variation\", label=\"Systematic variation\", growth=True)\n", @@ -207,25 +239,48 @@ " self.io_file_percent = io_file_percent\n", "\n", " def only_do_IO(self, events):\n", - " # standard AGC branches cover 4% of the data\n", - " branches_to_read = [\"jet_pt\", \"jet_eta\", \"jet_phi\", \"jet_btag\", \"jet_e\", \"muon_pt\", \"electron_pt\"]\n", - " if self.io_file_percent not in [4, 15, 25, 50]:\n", - " raise NotImplementedError(\"supported values for I/O percentage are 4, 15, 25, 50\")\n", - " if self.io_file_percent >= 15:\n", - " branches_to_read += [\"trigobj_e\"]\n", - " if self.io_file_percent >= 25:\n", - " branches_to_read += [\"trigobj_pt\"]\n", - " if self.io_file_percent >= 50:\n", - " branches_to_read += [\"trigobj_eta\", \"trigobj_phi\", \"jet_px\", \"jet_py\", \"jet_pz\", \"jet_ch\"]\n", + " # standard AGC branches cover 2.7% of the data\n", + " branches_to_read = []\n", + " if self.io_file_percent >= 2.7:\n", + " branches_to_read.extend([\"Jet_pt\", \"Jet_eta\", \"Jet_phi\", \"Jet_btagCSVV2\", \"Jet_mass\", \"Muon_pt\", \"Electron_pt\"])\n", + "\n", + " if self.io_file_percent >= 4:\n", + " branches_to_read.extend([\"Electron_phi\", \"Electron_eta\",\"Electron_mass\",\"Muon_phi\",\"Muon_eta\",\"Muon_mass\",\n", + " \"Photon_pt\",\"Photon_eta\",\"Photon_mass\",\"Jet_jetId\"])\n", + "\n", + " if self.io_file_percent>=15:\n", + " branches_to_read.extend([\"Jet_nConstituents\",\"Jet_electronIdx1\",\"Jet_electronIdx2\",\"Jet_muonIdx1\",\"Jet_muonIdx2\",\n", + " \"Jet_chHEF\",\"Jet_area\",\"Jet_puId\",\"Jet_qgl\",\"Jet_btagDeepB\",\"Jet_btagDeepCvB\",\n", + " \"Jet_btagDeepCvL\",\"Jet_btagDeepFlavB\",\"Jet_btagDeepFlavCvB\",\"Jet_btagDeepFlavCvL\",\n", + " \"Jet_btagDeepFlavQG\",\"Jet_chEmEF\",\"Jet_chFPV0EF\",\"Jet_muEF\",\"Jet_muonSubtrFactor\",\n", + " \"Jet_neEmEF\",\"Jet_neHEF\",\"Jet_puIdDisc\"])\n", + "\n", + " if self.io_file_percent>=25:\n", + " branches_to_read.extend([\"GenPart_pt\",\"GenPart_eta\",\"GenPart_phi\",\"GenPart_mass\",\"GenPart_genPartIdxMother\",\n", + " \"GenPart_pdgId\",\"GenPart_status\",\"GenPart_statusFlags\"])\n", + "\n", + " if self.io_file_percent==50:\n", + " branches_to_read.extend([\"Jet_rawFactor\",\"Jet_bRegCorr\",\"Jet_bRegRes\",\"Jet_cRegCorr\",\"Jet_cRegRes\",\"Jet_nElectrons\",\n", + " \"Jet_nMuons\",\"GenJet_pt\",\"GenJet_eta\",\"GenJet_phi\",\"GenJet_mass\",\"Tau_pt\",\"Tau_eta\",\"Tau_mass\",\n", + " \"Tau_phi\",\"Muon_dxy\",\"Muon_dxyErr\",\"Muon_dxybs\",\"Muon_dz\",\"Muon_dzErr\",\"Electron_dxy\",\n", + " \"Electron_dxyErr\",\"Electron_dz\",\"Electron_dzErr\",\"Electron_eInvMinusPInv\",\"Electron_energyErr\",\n", + " \"Electron_hoe\",\"Electron_ip3d\",\"Electron_jetPtRelv2\",\"Electron_jetRelIso\",\n", + " \"Electron_miniPFRelIso_all\",\"Electron_miniPFRelIso_chg\",\"Electron_mvaFall17V2Iso\",\n", + " \"Electron_mvaFall17V2noIso\",\"Electron_pfRelIso03_all\",\"Electron_pfRelIso03_chg\",\"Electron_r9\",\n", + " \"Electron_scEtOverPt\",\"Electron_sieie\",\"Electron_sip3d\",\"Electron_mvaTTH\",\"Electron_charge\",\n", + " \"Electron_cutBased\",\"Electron_jetIdx\",\"Electron_pdgId\",\"Electron_photonIdx\",\"Electron_tightCharge\"])\n", + "\n", + " if self.io_file_percent not in [2.7, 4, 15, 25, 50]:\n", + " raise NotImplementedError(\"supported values for I/O percentage are 2.7, 4, 15, 25, 50\")\n", "\n", " for branch in branches_to_read:\n", " if \"_\" in branch:\n", - " object_type, property_name = branch.split(\"_\")\n", - " if property_name == \"e\":\n", - " property_name = \"energy\"\n", - " ak.materialized(events[object_type][property_name])\n", + " split = branch.split(\"_\")\n", + " object_type = split[0]\n", + " property_name = '_'.join(split[1:])\n", + " dak.materialized(events[object_type][property_name])\n", " else:\n", - " ak.materialized(events[branch])\n", + " dak.materialized(events[branch])\n", " return {\"hist\": {}}\n", "\n", " def process(self, events):\n", @@ -249,16 +304,17 @@ "\n", " #### systematics\n", " # example of a simple flat weight variation, using the coffea nanoevents systematics feature\n", - " if process == \"wjets\":\n", - " events.add_systematic(\"scale_var\", \"UpDownSystematic\", \"weight\", flat_variation)\n", + " # if process == \"wjets\":\n", + " # events.add_systematic(\"scale_var\", \"UpDownSystematic\", \"weight\", flat_variation)\n", "\n", " # jet energy scale / resolution systematics\n", " # need to adjust schema to instead use coffea add_systematic feature, especially for ServiceX\n", " # cannot attach pT variations to events.jet, so attach to events directly\n", " # and subsequently scale pT by these scale factors\n", - " events[\"pt_nominal\"] = 1.0\n", - " events[\"pt_scale_up\"] = 1.03\n", - " events[\"pt_res_up\"] = jet_pt_resolution(events.jet.pt)\n", + " events[\"pt_nominal\"] = dak.ones_like(events.MET.pt)\n", + " events[\"pt_scale_up\"] = dak.ones_like(events.MET.pt)*1.03\n", + " events[\"pt_res_up\"] = dak.ones_like(events.MET.pt) #jet_pt_resolution(events.Jet.pt)\n", + "\n", "\n", " pt_variations = [\"pt_nominal\", \"pt_scale_up\", \"pt_res_up\"] if variation == \"nominal\" else [\"pt_nominal\"]\n", " for pt_var in pt_variations:\n", @@ -267,19 +323,19 @@ " # very very loosely based on https://arxiv.org/abs/2006.13076\n", "\n", " # pT > 25 GeV for leptons & jets\n", - " selected_electrons = events.electron[events.electron.pt > 25]\n", - " selected_muons = events.muon[events.muon.pt > 25]\n", - " jet_filter = events.jet.pt * events[pt_var] > 25 # pT > 25 GeV for jets (scaled by systematic variations)\n", - " selected_jets = events.jet[jet_filter]\n", + " selected_electrons = events.Electron[(events.Electron.pt>25)]\n", + " selected_muons = events.Muon[(events.Muon.pt >25)]\n", + " jet_filter = (events.Jet.pt * events[pt_var]) > 25\n", + " selected_jets = events.Jet[jet_filter]\n", "\n", " # single lepton requirement\n", - " event_filters = ((ak.count(selected_electrons.pt, axis=1) + ak.count(selected_muons.pt, axis=1)) == 1)\n", + " event_filters = ((dak.count(selected_electrons.pt, axis=1) + dak.count(selected_muons.pt, axis=1)) == 1)\n", " # at least four jets\n", - " pt_var_modifier = events[pt_var] if \"res\" not in pt_var else events[pt_var][jet_filter]\n", - " event_filters = event_filters & (ak.count(selected_jets.pt * pt_var_modifier, axis=1) >= 4)\n", + " pt_var_modifier = dak.ones_like(selected_jets.pt) # events[pt_var] if \"res\" not in pt_var else events[pt_var][jet_filter]\n", + " event_filters = event_filters & (dak.count(selected_jets.pt * pt_var_modifier, axis=1) >= 4)\n", " # at least one b-tagged jet (\"tag\" means score above threshold)\n", " B_TAG_THRESHOLD = 0.5\n", - " event_filters = event_filters & (ak.sum(selected_jets.btag >= B_TAG_THRESHOLD, axis=1) >= 1)\n", + " event_filters = event_filters & (dak.sum(selected_jets.btagCSVV2 >= B_TAG_THRESHOLD, axis=1) >= 1)\n", "\n", " # apply event filters\n", " selected_events = events[event_filters]\n", @@ -290,41 +346,41 @@ " for region in [\"4j1b\", \"4j2b\"]:\n", " # further filtering: 4j1b CR with single b-tag, 4j2b SR with two or more tags\n", " if region == \"4j1b\":\n", - " region_filter = ak.sum(selected_jets.btag >= B_TAG_THRESHOLD, axis=1) == 1\n", + " region_filter = dak.sum(selected_jets.btagCSVV2 >= B_TAG_THRESHOLD, axis=1) == 1\n", " selected_jets_region = selected_jets[region_filter]\n", " # use HT (scalar sum of jet pT) as observable\n", " pt_var_modifier = (\n", " events[event_filters][region_filter][pt_var]\n", - " if \"res\" not in pt_var\n", - " else events[pt_var][jet_filter][event_filters][region_filter]\n", + " # if \"res\" not in pt_var\n", + " # else events[pt_var][jet_filter][event_filters][region_filter]\n", " )\n", - " observable = ak.sum(selected_jets_region.pt * pt_var_modifier, axis=-1)\n", + " observable = dak.sum(selected_jets_region.pt * pt_var_modifier, axis=-1)\n", "\n", " elif region == \"4j2b\":\n", - " region_filter = ak.sum(selected_jets.btag > B_TAG_THRESHOLD, axis=1) >= 2\n", + " region_filter = dak.sum(selected_jets.btagCSVV2 > B_TAG_THRESHOLD, axis=1) >= 2\n", " selected_jets_region = selected_jets[region_filter]\n", "\n", " # reconstruct hadronic top as bjj system with largest pT\n", " # the jet energy scale / resolution effect is not propagated to this observable at the moment\n", - " trijet = ak.combinations(selected_jets_region, 3, fields=[\"j1\", \"j2\", \"j3\"]) # trijet candidates\n", + " trijet = dak.combinations(selected_jets_region, 3, fields=[\"j1\", \"j2\", \"j3\"]) # trijet candidates\n", " trijet[\"p4\"] = trijet.j1 + trijet.j2 + trijet.j3 # calculate four-momentum of tri-jet system\n", - " trijet[\"max_btag\"] = np.maximum(trijet.j1.btag, np.maximum(trijet.j2.btag, trijet.j3.btag))\n", + " trijet[\"max_btag\"] = np.maximum(trijet.j1.btagCSVV2, np.maximum(trijet.j2.btagCSVV2, trijet.j3.btagCSVV2))\n", " trijet = trijet[trijet.max_btag > B_TAG_THRESHOLD] # at least one-btag in trijet candidates\n", " # pick trijet candidate with largest pT and calculate mass of system\n", - " trijet_mass = trijet[\"p4\"][ak.argmax(trijet.p4.pt, axis=1, keepdims=True)].mass\n", - " observable = ak.flatten(trijet_mass)\n", + " trijet_mass = trijet[\"p4\"][dak.argmax(trijet.p4.pt, axis=1, keepdims=True)].mass\n", + " observable = dak.flatten(trijet_mass)\n", "\n", " ### histogram filling\n", " if pt_var == \"pt_nominal\":\n", " # nominal pT, but including 2-point systematics\n", " histogram.fill(\n", " observable=observable, region=region, process=process,\n", - " variation=variation, weight=xsec_weight\n", + " variation=variation, weight=dak.ones_like(observable)*xsec_weight\n", " )\n", "\n", " if variation == \"nominal\":\n", " # also fill weight-based variations for all nominal samples\n", - " for weight_name in events.systematics.fields:\n", + " for weight_name in []: # events.systematics.fields:\n", " for direction in [\"up\", \"down\"]:\n", " # extract the weight variations and apply all event & region filters\n", " weight_variation = events.systematics[weight_name][direction][\n", @@ -332,7 +388,7 @@ " # fill histograms\n", " histogram.fill(\n", " observable=observable, region=region, process=process,\n", - " variation=f\"{weight_name}_{direction}\", weight=xsec_weight*weight_variation\n", + " variation=f\"{weight_name}_{direction}\", weight=dak.ones_like(observable)*xsec_weight*weight_variation\n", " )\n", "\n", " # calculate additional systematics: b-tagging variations\n", @@ -340,19 +396,19 @@ " for i_dir, direction in enumerate([\"up\", \"down\"]):\n", " # create systematic variations that depend on object properties (here: jet pT)\n", " if len(observable):\n", - " weight_variation = btag_weight_variation(i_var, selected_jets_region.pt)[:, i_dir]\n", + " weight_variation = dak.ones_like(observable) #btag_weight_variation(i_var, selected_jets_region.pt)[:, i_dir]\n", " else:\n", " weight_variation = 1 # no events selected\n", " histogram.fill(\n", " observable=observable, region=region, process=process,\n", - " variation=f\"{weight_name}_{direction}\", weight=xsec_weight*weight_variation\n", + " variation=f\"{weight_name}_{direction}\", weight=dak.ones_like(observable)*xsec_weight*weight_variation\n", " )\n", "\n", " elif variation == \"nominal\":\n", " # pT variations for nominal samples\n", " histogram.fill(\n", " observable=observable, region=region, process=process,\n", - " variation=pt_var, weight=xsec_weight\n", + " variation=pt_var, weight=dak.ones_like(observable)*xsec_weight\n", " )\n", "\n", " output = {\"nevents\": {events.metadata[\"dataset\"]: len(events)}, \"hist\": histogram}\n", @@ -363,59 +419,6 @@ " return accumulator" ] }, - { - "cell_type": "markdown", - "id": "88b8466e-5010-4a7d-a4cb-b3960942dfbd", - "metadata": {}, - "source": [ - "### AGC `coffea` schema\n", - "\n", - "When using `coffea`, we can benefit from the schema functionality to group columns into convenient objects.\n", - "This schema is taken from [mat-adamec/agc_coffea](https://github.com/mat-adamec/agc_coffea)." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "790dc3c2-7311-4ad4-a177-4fd4a1553559", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "class AGCSchema(BaseSchema):\n", - " def __init__(self, base_form):\n", - " super().__init__(base_form)\n", - " self._form[\"contents\"] = self._build_collections(self._form[\"contents\"])\n", - "\n", - " def _build_collections(self, branch_forms):\n", - " names = set([k.split('_')[0] for k in branch_forms.keys() if not (k.startswith('number'))])\n", - " # Remove n(names) from consideration. It's safe to just remove names that start with n, as nothing else begins with n in our fields.\n", - " # Also remove GenPart, PV and MET because they deviate from the pattern of having a 'number' field.\n", - " names = [k for k in names if not (k.startswith('n') | k.startswith('met') | k.startswith('GenPart') | k.startswith('PV'))]\n", - " output = {}\n", - " for name in names:\n", - " offsets = transforms.counts2offsets_form(branch_forms['number' + name])\n", - " content = {k[len(name)+1:]: branch_forms[k] for k in branch_forms if (k.startswith(name + \"_\") & (k[len(name)+1:] != 'e'))}\n", - " # Add energy separately so its treated correctly by the p4 vector.\n", - " content['energy'] = branch_forms[name+'_e']\n", - " # Check for LorentzVector\n", - " output[name] = zip_forms(content, name, 'PtEtaPhiELorentzVector', offsets=offsets)\n", - "\n", - " # Handle GenPart, PV, MET. Note that all the nPV_*'s should be the same. We just use one.\n", - " #output['met'] = zip_forms({k[len('met')+1:]: branch_forms[k] for k in branch_forms if k.startswith('met_')}, 'met')\n", - " #output['GenPart'] = zip_forms({k[len('GenPart')+1:]: branch_forms[k] for k in branch_forms if k.startswith('GenPart_')}, 'GenPart', offsets=transforms.counts2offsets_form(branch_forms['numGenPart']))\n", - " #output['PV'] = zip_forms({k[len('PV')+1:]: branch_forms[k] for k in branch_forms if (k.startswith('PV_') & ('npvs' not in k))}, 'PV', offsets=transforms.counts2offsets_form(branch_forms['nPV_x']))\n", - " return output\n", - "\n", - " @property\n", - " def behavior(self):\n", - " behavior = {}\n", - " behavior.update(base.behavior)\n", - " behavior.update(vector.behavior)\n", - " return behavior" - ] - }, { "cell_type": "markdown", "id": "f586fab7-16cf-492b-9e00-bf8fb856bf87", @@ -431,6 +434,7 @@ "execution_count": 5, "id": "29341dd9", "metadata": { + "lines_to_next_cell": 2, "tags": [] }, "outputs": [ @@ -443,7 +447,7 @@ "example of information in fileset:\n", "{\n", " 'files': [https://xrootd-local.unl.edu:1094//store/user/AGC/datasets/merged/TT_TuneCUETP8M1_13TeV-powheg-pythia8/1.root, ...],\n", - " 'metadata': {'process': 'ttbar', 'variation': 'nominal', 'nevts': 2229374, 'xsec': 729.84}\n", + " 'metadata': {'process': 'ttbar', 'variation': 'nominal', 'nevts': 442122, 'xsec': 729.84}\n", "}\n" ] } @@ -456,6 +460,16 @@ "print(f\" 'metadata': {fileset['ttbar__nominal']['metadata']}\\n}}\")" ] }, + { + "cell_type": "code", + "execution_count": 6, + "id": "821ea6a0", + "metadata": {}, + "outputs": [], + "source": [ + "fileset = {\"ttbar__nominal\": fileset[\"ttbar__nominal\"]}" + ] + }, { "cell_type": "markdown", "id": "6164a27b-0bca-451c-a066-913df8db823e", @@ -468,43 +482,31 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "0b7583ea-a2eb-48b4-a511-26c1cdf65a32", - "metadata": {}, + "metadata": { + "lines_to_next_cell": 2 + }, "outputs": [], "source": [ - "def get_query(source: ObjectStream) -> ObjectStream:\n", - " \"\"\"Query for event / column selection: >=4j >=1b, ==1 lep with pT>25 GeV, return relevant columns\n", - " \"\"\"\n", - " return source.Where(lambda e:\n", - " # == 1 lep\n", - " e.electron_pt.Where(lambda pT: pT > 25).Count() + e.muon_pt.Where(lambda pT: pT > 25).Count()== 1\n", - " )\\\n", - " .Where(lambda e:\\\n", - " # >= 4 jets\n", - " e.jet_pt.Where(lambda pT: pT > 25).Count() >= 4\n", - " )\\\n", - " .Where(lambda e:\\\n", - " # >= 1 jet with pT > 25 GeV and b-tag >= 0.5\n", - " {\"pT\": e.jet_pt, \"btag\": e.jet_btag}.Zip().Where(lambda jet: jet.btag >= 0.5 and jet.pT > 25).Count() >= 1\n", - " )\\\n", - " .Select(lambda e:\\\n", - " # return columns\n", - " {\n", - " \"electron_e\": e.electron_e,\n", - " \"electron_pt\": e.electron_pt,\n", - " \"muon_e\": e.muon_e,\n", - " \"muon_pt\": e.muon_pt,\n", - " \"jet_e\": e.jet_e,\n", - " \"jet_pt\": e.jet_pt,\n", - " \"jet_eta\": e.jet_eta,\n", - " \"jet_phi\": e.jet_phi,\n", - " \"jet_btag\": e.jet_btag,\n", - " \"numbermuon\": e.numbermuon,\n", - " \"numberelectron\": e.numberelectron,\n", - " \"numberjet\": e.numberjet,\n", - " }\n", - " )" + "# def get_query(source: ObjectStream) -> ObjectStream:\n", + "# \"\"\"Query for event / column selection: >=4j >=1b, ==1 lep with pT>25 GeV, return relevant columns\n", + "# \"\"\"\n", + "# return source.Where(lambda e: e.Electron_pt.Where(lambda pt: pt > 25).Count()\n", + "# + e.Muon_pt.Where(lambda pt: pt > 25).Count() == 1)\\\n", + "# .Where(lambda e: e.Jet_pt.Where(lambda pt: pt > 25).Count() >= 4)\\\n", + "# .Where(lambda g: {\"pt\": g.Jet_pt,\n", + "# \"btagCSVV2\": g.Jet_btagCSVV2}.Zip().Where(lambda jet:\n", + "# jet.btagCSVV2 >= 0.5 \n", + "# and jet.pt > 25).Count() >= 1)\\\n", + "# .Select(lambda f: {\"Electron_pt\": f.Electron_pt,\n", + "# \"Muon_pt\": f.Muon_pt,\n", + "# \"Jet_mass\": f.Jet_mass,\n", + "# \"Jet_pt\": f.Jet_pt,\n", + "# \"Jet_eta\": f.Jet_eta,\n", + "# \"Jet_phi\": f.Jet_phi,\n", + "# \"Jet_btagCSVV2\": f.Jet_btagCSVV2,\n", + "# })" ] }, { @@ -519,53 +521,15 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "6cc3c8bf-7b6b-4d67-8326-804271549c70", "metadata": {}, - "outputs": [ - { - "data": { - "application/json": { - "ascii": false, - "bar_format": "{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}]", - "colour": null, - "elapsed": 0.0163571834564209, - "initial": 0, - "n": 0, - "ncols": null, - "nrows": null, - "postfix": null, - "prefix": "CMS ttbar", - "rate": null, - "total": 9000000000, - "unit": "file", - "unit_divisor": 1000, - "unit_scale": false - }, - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "CMS ttbar: 0%| | 0/9000000000.0 [00:00]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ServiceX data delivery took 0.16 seconds\n" - ] - } - ], + "outputs": [], "source": [ "if USE_SERVICEX:\n", + "\n", " # dummy dataset on which to generate the query\n", - " dummy_ds = ServiceXSourceUpROOT(\"cernopendata://dummy\", \"events\", backend_name=\"uproot\")\n", + " dummy_ds = ServiceXSourceUpROOT(\"cernopendata://dummy\", \"Events\", backend_name=\"uproot\")\n", "\n", " # tell low-level infrastructure not to contact ServiceX yet, only to\n", " # return the qastle string it would have sent\n", @@ -574,16 +538,22 @@ " # create the query\n", " query = get_query(dummy_ds).value()\n", "\n", - " # now we query the files using a wrapper around ServiceXDataset to transform all processes at once\n", + " # now we query the files and create a fileset dictionary containing the\n", + " # URLs pointing to the queried files\n", + "\n", " t0 = time.time()\n", - " ds = utils.ServiceXDatasetGroup(fileset, backend_name=\"uproot\", ignore_cache=SERVICEX_IGNORE_CACHE)\n", - " files_per_process = ds.get_data_rootfiles_uri(query, as_signed_url=True, title=\"CMS ttbar\")\n", + " for process in fileset.keys():\n", + " ds = ServiceXDataset(fileset[process]['files'],\n", + " backend_name=\"uproot\",\n", + " ignore_cache=SERVICEX_IGNORE_CACHE)\n", + " files = ds.get_data_rootfiles_uri(query,\n", + " as_signed_url=True,\n", + " title=process)\n", "\n", - " print(f\"ServiceX data delivery took {time.time() - t0:.2f} seconds\")\n", "\n", - " # update fileset to point to ServiceX-transformed files\n", - " for process in fileset.keys():\n", - " fileset[process][\"files\"] = [f.url for f in files_per_process[process]]" + " fileset[process][\"files\"] = [f.url for f in files]\n", + "\n", + " print(f\"ServiceX data delivery took {time.time() - t0:.2f} seconds\")" ] }, { @@ -598,521 +568,139 @@ "When `USE_SERVICEX` is false, the input files need to be processed during this step as well." ] }, - { - "cell_type": "code", - "execution_count": 8, - "id": "78fce979", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[########################################] | 100% Completed | 27.5s\n", - "execution took 27.60 seconds\n" - ] - } - ], - "source": [ - "if USE_DASK:\n", - " executor = processor.DaskExecutor(client=utils.get_client(AF))\n", - "else:\n", - " executor = processor.FuturesExecutor(workers=NUM_CORES)\n", - " \n", - "run = processor.Runner(executor=executor, schema=AGCSchema, savemetrics=True, metadata_cache={}, chunksize=CHUNKSIZE)\n", - "\n", - "if USE_SERVICEX:\n", - " treename = \"servicex\"\n", - " \n", - "else:\n", - " treename = \"events\"\n", - " \n", - "filemeta = run.preprocess(fileset, treename=treename) # pre-processing\n", - "\n", - "t0 = time.monotonic()\n", - "all_histograms, metrics = run(fileset, treename, processor_instance=TtbarAnalysis(DISABLE_PROCESSING, IO_FILE_PERCENT)) # processing\n", - "exec_time = time.monotonic() - t0\n", - "\n", - "all_histograms = all_histograms[\"hist\"]\n", - "\n", - "print(f\"\\nexecution took {exec_time:.2f} seconds\")" - ] - }, { "cell_type": "code", "execution_count": 9, - "id": "55fb8ec1-6eb9-41b8-8275-e341a17b5fb2", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "metrics saved as metrics/coffea_casa-20230222-183154.json\n", - "event rate per worker (pure processtime): 50.63 kHz\n", - "amount of data read: 4.08 MB\n" - ] - } - ], - "source": [ - "# track metrics\n", - "dataset_source = \"/data\" if fileset[\"ttbar__nominal\"][\"files\"][0].startswith(\"/data\") else \"https://xrootd-local.unl.edu:1094\" # TODO: xcache support\n", - "metrics.update({\n", - " \"walltime\": exec_time, \n", - " \"num_workers\": NUM_CORES, \n", - " \"af\": AF_NAME, \n", - " \"dataset_source\": dataset_source, \n", - " \"use_dask\": USE_DASK, \n", - " \"use_servicex\": USE_SERVICEX, \n", - " \"systematics\": SYSTEMATICS, \n", - " \"n_files_max_per_sample\": N_FILES_MAX_PER_SAMPLE,\n", - " \"cores_per_worker\": CORES_PER_WORKER, \n", - " \"chunksize\": CHUNKSIZE, \n", - " \"disable_processing\": DISABLE_PROCESSING, \n", - " \"io_file_percent\": IO_FILE_PERCENT\n", - "})\n", - "\n", - "# save metrics to disk\n", - "if not os.path.exists(\"metrics\"):\n", - " os.makedirs(\"metrics\")\n", - "timestamp = time.strftime('%Y%m%d-%H%M%S')\n", - "metric_file_name = f\"metrics/{AF_NAME}-{timestamp}.json\"\n", - "with open(metric_file_name, \"w\") as f:\n", - " f.write(json.dumps(metrics))\n", - "\n", - "print(f\"metrics saved as {metric_file_name}\")\n", - "#print(f\"event rate per worker (full execution time divided by NUM_CORES={NUM_CORES}): {metrics['entries'] / NUM_CORES / exec_time / 1_000:.2f} kHz\")\n", - "print(f\"event rate per worker (pure processtime): {metrics['entries'] / metrics['processtime'] / 1_000:.2f} kHz\")\n", - "print(f\"amount of data read: {metrics['bytesread']/1000**2:.2f} MB\") # likely buggy: https://github.com/CoffeaTeam/coffea/issues/717" - ] - }, - { - "cell_type": "markdown", - "id": "be8f321a-940a-4e25-86f0-e5889331ad86", - "metadata": {}, - "source": [ - "### Inspecting the produced histograms\n", - "\n", - "Let's have a look at the data we obtained.\n", - "We built histograms in two phase space regions, for multiple physics processes and systematic variations." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "9f17abd8-74ed-40db-9ea8-73341c8bf627", + "id": "78fce979", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "260293cadcec473ea03ff17a02ea7dbd", + "version_major": 2, + "version_minor": 0 + }, "text/plain": [ - "
" + "Output()" ] }, "metadata": {}, "output_type": "display_data" - } - ], - "source": [ - "utils.set_style()\n", - "\n", - "all_histograms[120j::hist.rebin(2), \"4j1b\", :, \"nominal\"].stack(\"process\")[::-1].plot(stack=True, histtype=\"fill\", linewidth=1, edgecolor=\"grey\")\n", - "plt.legend(frameon=False)\n", - "plt.title(\">= 4 jets, 1 b-tag\")\n", - "plt.xlabel(\"HT [GeV]\");" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "318654e9-444c-401b-8957-4477d4c103f1", - "metadata": {}, - "outputs": [ + }, { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
      },
      "metadata": {},
      "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "all_histograms[:, \"4j2b\", :, \"nominal\"].stack(\"process\")[::-1].plot(stack=True, histtype=\"fill\", linewidth=1,edgecolor=\"grey\")\n",
-    "plt.legend(frameon=False)\n",
-    "plt.title(\">= 4 jets, >= 2 b-tags\")\n",
-    "plt.xlabel(\"$m_{bjj}$ [Gev]\");"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c4f90eb6-b561-43ca-a4d8-5c7f30e0cba7",
-   "metadata": {},
-   "source": [
-    "Our top reconstruction approach ($bjj$ system with largest $p_T$) has worked!\n",
-    "\n",
-    "Let's also have a look at some systematic variations:\n",
-    "- b-tagging, which we implemented as jet-kinematic dependent event weights,\n",
-    "- jet energy variations, which vary jet kinematics, resulting in acceptance effects and observable changes.\n",
-    "\n",
-    "We are making of [UHI](https://uhi.readthedocs.io/) here to re-bin."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "7843e5c0-e247-4abf-b406-263c92f797b6",
-   "metadata": {},
-   "outputs": [
+    },
     {
      "data": {
-      "image/png": "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",
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
       "text/plain": [
-       "
"
+       "\n"
       ]
      },
      "metadata": {},
      "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# b-tagging variations\n",
-    "all_histograms[120j::hist.rebin(2), \"4j1b\", \"ttbar\", \"nominal\"].plot(label=\"nominal\", linewidth=2)\n",
-    "all_histograms[120j::hist.rebin(2), \"4j1b\", \"ttbar\", \"btag_var_0_up\"].plot(label=\"NP 1\", linewidth=2)\n",
-    "all_histograms[120j::hist.rebin(2), \"4j1b\", \"ttbar\", \"btag_var_1_up\"].plot(label=\"NP 2\", linewidth=2)\n",
-    "all_histograms[120j::hist.rebin(2), \"4j1b\", \"ttbar\", \"btag_var_2_up\"].plot(label=\"NP 3\", linewidth=2)\n",
-    "all_histograms[120j::hist.rebin(2), \"4j1b\", \"ttbar\", \"btag_var_3_up\"].plot(label=\"NP 4\", linewidth=2)\n",
-    "plt.legend(frameon=False)\n",
-    "plt.xlabel(\"HT [GeV]\")\n",
-    "plt.title(\"b-tagging variations\");"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "87773be6-cabe-48a9-a9ba-7d2e33fb1b01",
-   "metadata": {},
-   "outputs": [
+    },
     {
      "data": {
-      "image/png": "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",
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d3184be8042949ee83adaeb1b7ba3417",
+       "version_major": 2,
+       "version_minor": 0
+      },
       "text/plain": [
-       "
"
+       "Output()"
       ]
      },
      "metadata": {},
      "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# jet energy scale variations\n",
-    "all_histograms[:, \"4j2b\", \"ttbar\", \"nominal\"].plot(label=\"nominal\", linewidth=2)\n",
-    "all_histograms[:, \"4j2b\", \"ttbar\", \"pt_scale_up\"].plot(label=\"scale up\", linewidth=2)\n",
-    "all_histograms[:, \"4j2b\", \"ttbar\", \"pt_res_up\"].plot(label=\"resolution up\", linewidth=2)\n",
-    "plt.legend(frameon=False)\n",
-    "plt.xlabel(\"$m_{bjj}$ [Gev]\")\n",
-    "plt.title(\"Jet energy variations\");"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7d2bb804",
-   "metadata": {},
-   "source": [
-    "### Save histograms to disk\n",
-    "\n",
-    "We'll save everything to disk for subsequent usage.\n",
-    "This also builds pseudo-data by combining events from the various simulation setups we have processed."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "804ef793",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "utils.save_histograms(all_histograms, fileset, \"histograms.root\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d731de6a-7131-4ed8-b348-4468ffa67cf0",
-   "metadata": {},
-   "source": [
-    "### Statistical inference\n",
-    "\n",
-    "A statistical model has been defined in `config.yml`, ready to be used with our output.\n",
-    "We will use `cabinetry` to combine all histograms into a `pyhf` workspace and fit the resulting statistical model to the pseudodata we built."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "486ad228",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/opt/conda/lib/python3.8/site-packages/requests/__init__.py:102: RequestsDependencyWarning: urllib3 (1.26.7) or chardet (5.0.0)/charset_normalizer (2.0.9) doesn't match a supported version!\n",
-      "  warnings.warn(\"urllib3 ({}) or chardet ({})/charset_normalizer ({}) doesn't match a supported \"\n"
-     ]
-    }
-   ],
-   "source": [
-    "config = cabinetry.configuration.load(\"cabinetry_config.yml\")\n",
-    "cabinetry.templates.collect(config)\n",
-    "cabinetry.templates.postprocess(config)  # optional post-processing (e.g. smoothing)\n",
-    "ws = cabinetry.workspace.build(config)\n",
-    "cabinetry.workspace.save(ws, \"workspace.json\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "8c259c20-ddcc-4178-8a3e-699bd7ca2f5a",
-   "metadata": {},
-   "source": [
-    "We can inspect the workspace with `pyhf`, or use `pyhf` to perform inference."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "id": "03559e2c-b8f3-4660-b23c-b7ab30545fd1",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "/opt/conda/lib/python3.8/site-packages/requests/__init__.py:102: RequestsDependencyWarning: urllib3 (1.26.7) or chardet (5.0.0)/charset_normalizer (2.0.9) doesn't match a supported version!\n",
-      "  warnings.warn(\"urllib3 ({}) or chardet ({})/charset_normalizer ({}) doesn't match a supported \"\n",
-      "                  Summary       \n",
-      "            ------------------  \n",
-      "               channels  2\n",
-      "                samples  5\n",
-      "             parameters  14\n",
-      "              modifiers  14\n",
-      "\n",
-      "               channels  nbins\n",
-      "             ----------  -----\n",
-      "                4j1b CR   11  \n",
-      "                4j2b SR   11  \n",
-      "\n",
-      "                samples\n",
-      "             ----------\n",
-      "                 W+jets\n",
-      "  single top, s-channel\n",
-      "  single top, t-channel\n",
-      "                     tW\n",
-      "                  ttbar\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "!pyhf inspect workspace.json | head -n 20"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "eb0b6564-6cb0-48d6-b57d-36b992da506b",
-   "metadata": {},
-   "source": [
-    "Let's try out what we built: the next cell will perform a maximum likelihood fit of our statistical model to the pseudodata we built."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "ef0b4da0-79e2-47a1-8da3-3e2c3bf7947b",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "W MnPosDef Matrix forced pos-def by adding to diagonal 0.00937983\n"
-     ]
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmMAAAGCCAYAAACsOMTHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAACLwUlEQVR4nOzdeVxU1fvA8c8MDCgCgoCioqnjxqKIhrggKFkuhZpbipVLuUa4YqalmdtXXEFTMs3csBBz37I009xK+YaaJpplkLlCsm8zvz/8MV9H9kUG5Hm/Xr68yznnPncGhmfOOfdehVar1SKEEEIIIQxCaegAhBBCCCEqM0nGhBBCCCEMSJIxIYQQQggDkmRMCCGEEMKAJBkTQgghhDAgScaEEEIIIQxIkjEhhBBCCAMyNnQAQjzrHjx4wPHjx3FwcMDU1NTQ4QghhChlaWlpxMTE0KlTJ2rUqFHk+pKMCfGUHT16lKlTpxo6DCGEEE9ZUFAQ/fr1K3I9ScaEeMpq1qwJwPz583F2di50vXfeeYdPPvnkqZUvizrJycnExXWmbt2sIh3jWTH590b8k25i6DDKlCZNw9URVwFo+nlTlKaVbzaMvUk6Sxr9bugwDCI21ghr6+8xMzMrdJ2y+Ox62se4dOkS06dP133eF5UkY0I8ZdlDkw0bNsTFxaXQ9apUqfJUy5dFnYSEBO7ezaBRo8wiHeNZYaZQYpxWuT5mtZla6nxYBwBVExUKY4WBIyp7ZqaZuDinGzoMgzAzM8bOzhELC4tC1ymLz66nfYzk5GSAYk9FqVyfEkJUIK+//vpTLV+WdUTloTBWUKNn0efMiMqrLD6HyvtnXeXrPxaignjjjTeeavmyrCOEEHkpi8+h8v5ZJ8mYEE+ZSqXS+78yMTExwcrK2tBhiDKkzdKSdCmJpEtJaLO0hg5HlDErK2tMTCrXPEko+ee8DFMK8ZRV5mTM1NQUU1Nr4K6hQxFlRJOu4bc3fwPA9YQrRlWNDByRKEs1algDle8WPpKMCSGEKDcUKDCpbaJbFkIUTJIxIYQQpUZZVYnL3qJdtSZEZVeu5oxFRESgVquJiooqUr3o6GiCg4OJiYl5SpGJpyU4OBi1Wl2suvm974GBgXh5eZU0PCEqBW2WloSfE3hw8AEJPyfIXC8hytgz0TN27do1QkJC8PDwwMHBwdDhiDKS3/vu7+/PsGHDDBOYEBVI3JE4YhbFkHEnQ7dNVVOFQ6AD1j5y8YUQZeGZSMYqupSUFKpWrWqw42dkZKBQKDA2fnZ+HJ577jlDhyBEuRd3JI4bgTdybM+4k/Fo+yKKnJBp0jTceP9Rmw0XNKyUd+AXoqjK/W9JVFQUo0aNonXr1jg6OuLr68u+fft0+yMiIvD39wdgyJAhqNVq1Go1ERER+bZ748YNJkyYgLu7O46Ojrz00kts2rRJr8zp06dRq9Xs3r2bxYsX0759e1xdXXnjjTf4/fecj7r48ccfef3113F1dcXZ2ZkBAwbw448/6pXJHpa7ePEi77zzDm5ubnTp0gV49KDR+fPn4+HhgbOzM4MGDeLChQt4eXkRGBgIQExMDE2bNmX16tU5jn/27FnUajX79+/P87yzz2nHjh3Mnz+fDh064OjoyJ9//lnoc7h//z7Tp0+nY8eOODo64u7unmu5bdu28fLLL+Po6Ejr1q0ZM2YM165dyzO2bGq1muDg4BzbH38dCnrfcxumTEtLY9GiRXh7e9O8eXM6dOjArFmzePjwYY7jvP322xw7doxevXrh5OTEiy++yLZt2wqMXYjyJCslK89/mYmZxATlP7UjZlEMmYmZ+bbzJK1Gy7/H/uXfY/+i1chwpxCFUa67Qk6dOsWIESNwdXVlzpw5WFhYsHfvXgICAkhJSaF///506dKFKVOmsHjxYmbPnq179l/9+vXzbDc6OpoBAwZQp04dpk+fjp2dHT/88AMff/wxcXFxBAQE6JVfsmQJbdq0Yf78+SQmJhIUFMTIkSP55ptvMDJ6dNn2zp07mTJlCl27diUoKAiVSsXWrVsZPnw469evp2PHjnptjhs3jldeeQU/Pz/dYxTee+899u3bx6hRo2jfvj3R0dGMHTuWxMREXT0HBwdeeOEFwsLCGDVqlO74AJs2baJWrVq89NJLBb62ixcvxs3NjTlz5qBUKrGxsSn0OUyePJlLly4xefJkGjZsyMOHD7l06RJxcXG69levXs3ixYvx9fVlypQpxMfHExISQv/+/dmxYwcNGzYsMMb8FPV912q1jB49mlOnTjFmzBjc3d25cuUKwcHBREZGsm3bNr3HWFy+fJkFCxYwevRobG1tCQ8PZ9q0aTz33HO0bdu2WDEnJyeTkJCgWzcxMSn2ozOEKIxfPH8pUf2MOxlEeec/h7f1udZ660pjJfVn1NctC/EsSktLIz39f4+8yv47XlzlOhmbNWsWTZo0YfPmzbohNC8vL+Li4liyZAl9+/bFxsaGBg0aANC4cWPc3NwKbHfevHlUq1aNr776Svf8LE9PT9LT0wkNDWXo0KFUr15dV75x48YsXbpUt25kZMS7775LVFQUbm5upKSkMGfOHHx8fAgNDdWV69y5M7169WLJkiU5krG+ffsyYcIE3Xp0dDR79uxh9OjRut4fT09PbG1t9coBDB06lCFDhvDdd9/pEq/bt2/zzTff4O/vX6jhxvr167Ny5UrdelHO4fz58wwcOJBBgwbpyr344ou65YcPH7Jy5Uo6d+7M8uXLdds9PDx44YUXCAkJYdmyZQXGmJ+ivu/Hjx/n+PHjvPfee4waNQp49PrWrl2bgIAAduzYoXc+cXFxbNu2jTp1Hj1jr23btpw8eZLdu3cXOxkbPHiw3npAQADjx48vVltClFcKlQLbvraGDkOIpyo0NJSQkJBSa6/cJmN//PEH169f5/333wcgM/N/Dxru3LkzR44c4ffff6dx48ZFajctLY1Tp07h5+dH1apVc7S7adMmIiMj6dy5s277Cy+8oNdG8+bNAYiNjcXNzY3z588THx9P37599dqDR8njmjVrSE5O1nuKfffu3fXKnT17FoCePXvqbe/RowdTpkzR29auXTscHR3ZvHmzLhkLCwtDoVDoJRT56datm956Uc6hZcuWbN++HSsrKzp27IiLi4veje7Onz9Pamoq/fr102unTp06tG/fnpMnTxYqxtJ06tQpgBwx9ezZk2nTpnHy5Em9187JyUmXiMGjm5c2bNiQ2NjYYsewdetWHB0ddeuV8S7Vomy5nnDNc1/i+USuB1wvsA11iBrz1ualGZYQFd6YMWMYMWKEbv3y5cs5vnAXRblNxu7duwfAggULWLBgQa5lHh8WK6y4uDgyMzPZuHEjGzduLFS71tb6E1iz/4impqbqxfrOO+/kedz4+Hi9ZMzOzi7XY9ra6n+jNDY2xsrKKkd7Q4cO5f333+f333+nXr16fPXVV3Tv3j1Hu3mpWbOm3npRziEkJIRPPvmE8PBwli1bRrVq1XjxxReZNm0adnZ2xMfH53oMgFq1auWYW1YW4uPjMTY2xsbGRm+7QqHA1tZWF3O23F5zExMT0tLSih2DmZmZridWiLKQ393vLdtZoqqp0ruK8kmqWios21miMCr8zVu1Gi2pNx59NlZpWAWFUm78Kp49j54u8r9pJo//fS+OcpuM1ahRA4CxY8fmOQeqUaNGRW63evXqGBkZ0adPnzyfyF6vXr0itZmdrM2aNYtWrVrlWubJJEuh0P+Aym7j3r172Nvb67ZnZmbmSBQAevXqRVBQEJs2bcLNzY27d+8W6QnzeR2/MOdQo0YNPvzwQz788EP+/vtvvv32WxYtWsT9+/f54osvdInMnTt3crRx+/btHMntk0xMTPTG4rPl9joUlpWVFZmZmdy/f18vIdNqtdy7d4+WLVsWu20hKiKFkQKHQIdcr6Z8VAAcpjgUKRGDR1dTXh54GZDHIQlRWOU2GWvUqBENGjTg8uXLOYbpnvRkT1V+qlatSrt27fj1119p3rx5qQwVtWnTBktLS65du8abb75ZrDbc3d0B2LdvHy4u/7t79YEDB3IMG8KjrPy1115j06ZNnD9/HicnJ55//vninQDFP4c6derw5ptvcvLkSc6dOwdA69atqVKlCrt27dIbdr116xanTp2iR48e+bbp4ODAlStX9LadPHmSpKQkvW1Fed87dOjAmjVr2LVrl17X8sGDB0lOTqZDhw4FtiHEs8baxxoWkfM+Y7VUOEwp/n3GjK3K7Z8WIcqlcvkbk91rM3fuXEaMGMGwYcPo27cv9vb2xMfHc/36dS5duqSbgN60aVMAvvzyS8zNzTExMaFevXp59sB8+OGHvPbaawwaNAg/Pz8cHBxISkrizz//5LvvvmPLli1FirdatWrMmjWLwMBA4uPj6dGjBzY2Njx48IDLly/z4MED5syZk28bTZs2xdfXl3Xr1mFkZET79u25evUq69atw8LCAqUy51VJr7/+Op999hkXL17Mcyi3tM8hISGBIUOG4Ovri1qtplq1akRFRfHDDz/o5qFZWlri7+/P4sWLmTx5Mr6+vrqrKU1NTXn33XfzjaVPnz4sW7aMZcuW0bZtW65du8amTZtyDPEV5X339PSkU6dOBAUFkZiYSJs2bXRXUzo7O9OnT58SvX5CVFTWPtZYeVuRGJlIxr0MVLYqzN3Mi9wjls2oqhEtv5OeZiGKolwlY9k9HNk9Hu3bt2fHjh188sknzJ07l4cPH2JlZUXjxo31elzq1avHBx98wIYNG/Dz8yMrK4uFCxfSv3//XI/TpEkTdu/ezcqVK1m2bBn379/HwsKCBg0a6E3cL4o+ffpQp04d1qxZwwcffEBSUhI2NjY4OjrmmDSel4ULF1KzZk3Cw8P5/PPPcXJyYsWKFQwfPhxLS8sc5e3t7WnTpg2//fYbvXr1KlbcRT0HExMTXF1d2blzJzExMWRmZlKnTh1Gjx6tu0oRHg0v29jYsGHDBvbv34+pqSkeHh5MmTKlwNtajBw5ksTERLZv387atWtxdXVlxYoVjB49Wq9cUd53hULBp59+SnBwMBEREaxatQpra2v69OnDlClT5BYTolJTGCmweF7mMwphKAqtVltu7sr38ccf665mNDeXq3cAzp07x8CBA1m2bFmOhOvevXt4eXnx5ptvMm3aNANFKApy8eJFevfuza5du/SGoCuPZsBVQwdhEK9ecuJmWhVDhyHKWH3TVHY4/2roMAykKfCboYMocyX9nC8XPWMXLlzgwoULRERE8MILL1TaROzEiRNERkbi4uKCqakpV65cITQ0lAYNGujdiuLWrVv89ddffPbZZyiVSnkGoxCi3NCkafjz40dP9Hhu5nPyOCQhCqFcJGP+/v4kJCTwwgsvMHPmTEOHYzDm5uYcP36c9evXk5SUhLW1Nd7e3gQGBuoNo4WHh7NixQocHBxYunSp3tWXQghhSFqNlriDj27VU/+DvJ+EIoT4n3KRjB07dszQIZQLrVq1Ijw8vMBy48ePlzu3CyHKJaWxEofJDrplIUTBykUyJoQQ4tmgUCmo6Zfzhs9CiLzJ1xYhhBBCCAOSnjEhhBClRqvRkv7PoydomNibyOOQhCgEScaEEEKUGk2ahku+lwB5HJIQhSXJmBBCiFKlrCIzYIQoCknGhBBClBqjqka0+rGVocMQokKRry9CCCGEEAYkyZgQQgghhAHJMKUQQohSo0nX8NfCvwCo9149lCbynV+IgshviRBCiFKjzdJyf+d97u+8jzZLa+hwhKgQpGdMCCFEqVEYK6g9rrZuWQhRMEnGhBBClBqlSkntt2obOgwhKhQZpiyCiIgI1Go1UVFRRaoXHR1NcHAwMTExTykyURJqtZrg4GBDhyFEpaDN0pLwcwIPDj4g4ecEGcoUAukZKxPXrl0jJCQEDw8PHBwcDB2OEEI8NVqtlsz4TACMrYxRKP43VBl3JI6YRTFk3MnQbVPVVOEQ6IC1j3WZxypEeSE9Y6JAKSkphg5BCFFBaFI1XOh6gQtdL6BJ1ei2xx2J40bgDb1EDCDjTgY3Am8QdySurEMVotyQZKyEoqKiGDVqFK1bt8bR0RFfX1/27dun2x8REYG/vz8AQ4YMQa1Wo1ariYiIyLfdGzduMGHCBNzd3XF0dOSll15i06ZNemVOnz6NWq1m9+7dLF68mPbt2+Pq6sobb7zB77//nqPNH3/8kddffx1XV1ecnZ0ZMGAAP/74o16Z4OBg1Go1Fy9e5J133sHNzY0uXboAkJaWxvz58/Hw8MDZ2ZlBgwZx4cIFvLy8CAwMBCAmJoamTZuyevXqHMc/e/YsarWa/fv353neGo2GlStX0rVrV5ycnGjVqhU9e/Zk/fr1euWuX7/O+PHjadu2LY6Ojnh6ejJ58mTS0tIAuH//PjNnzqRbt260aNECd3d3hgwZwk8//ZTv657t7t27zJgxg44dO9K8eXO8vb0JCQkhMzOzUPWFEJCVkkVWShaZiZnEBOU/TSNmUQyZiZlkpWSVUXRClB8yTFkCp06dYsSIEbi6ujJnzhwsLCzYu3cvAQEBpKSk0L9/f7p06cKUKVNYvHgxs2fPxtnZGYD69evn2W50dDQDBgygTp06TJ8+HTs7O3744Qc+/vhj4uLiCAgI0Cu/ZMkS2rRpw/z580lMTCQoKIiRI0fyzTffYGT06CG9O3fuZMqUKXTt2pWgoCBUKhVbt25l+PDhrF+/no4dO+q1OW7cOF555RX8/PxITk4G4L333mPfvn2MGjWK9u3bEx0dzdixY0lMTNTVc3Bw4IUXXiAsLIxRo0bpjg+wadMmatWqxUsvvZTnua9Zs4aQkBDeeecd3N3dyczM5Pr16yQkJOjKXL58mddeew1ra2smTJhAgwYNuHv3Lt9++y0ZGRmYmpry77//AvDuu+9iZ2dHcnIy33zzDX5+fmzatIl27drlGcPdu3d59dVXUSqV+Pv7U79+fSIjI/nkk0+IiYkhKCgoz7r5SU5O1jsPExMTTE1Ni9WWEOWVUVUjWp9rDcD5NucLXS/jTgZR3o/m42bXF6K8SktLIz09Xbee/XeyuCQZK4FZs2bRpEkTNm/ejLHxo5fSy8uLuLg4lixZQt++fbGxsaFBgwYANG7cGDc3twLbnTdvHtWqVeOrr77CwsICAE9PT9LT0wkNDWXo0KFUr15dV75x48YsXbpUt25kZMS7775LVFQUbm5upKSkMGfOHHx8fAgNDdWV69y5M7169WLJkiU5krG+ffsyYcIE3Xp0dDR79uxh9OjRul4wT09PbG1t9coBDB06lCFDhvDdd9/pEq/bt2/zzTff4O/vr3utcnPu3DmaNWvG+PHjddu8vLxyvD5GRkZ8/fXX2NjY6Lb37t1bt9yoUSM+/vhj3XpWVhadOnUiJiaGDRs25JuMBQcH8/DhQw4ePEidOnUA6NixI1WqVGHBggWMHDmSJk2a5Fk/L4MHD9ZbDwgI0DtPIYQQFUNoaCghISGl1p4MUxbTH3/8wfXr1+nVqxcAmZmZun+dO3fmzp07uQ4VFiQtLY1Tp07x0ksvUbVq1RztpqWlERkZqVfnhRde0Ftv3rw5ALGxsQCcP3+e+Ph4+vbtq9eeRqPBy8uLqKioHFl99+7d9dbPnj0LQM+ePfW29+jRI0dy1a5dOxwdHdm8ebNuW1hYGAqFgkGDBuV7/i1btuTy5cvMnDmTH374Qa8nCR7NXzt79iw9e/bUS8RyExYWRq9evXB0dKRp06Y0a9aMkydPcv369XzrHT16lHbt2lGzZk2918vb21vvtSiqrVu38t///lf3b8yYMcVqR4iKwvWEK64nXFGHqAtVXh2ixvWE61OOSoiSGzNmjN7n+datW0vUnvSMFdO9e/cAWLBgAQsWLMi1TFxc0SekxsXFkZmZycaNG9m4cWOh2rW21r8KycTEBIDU1FS9WN955508jxsfH4+ZmZlu3c7OLtdj2tra6m03NjbGysoqR3tDhw7l/fff5/fff6devXp89dVXdO/ePUe7Txo7dixmZmbs2rWLsLAwjIyMcHd3Z+rUqbRs2ZJ///2XrKws7O3t821n3bp1zJ8/Hz8/PyZOnIi1tTVKpZJly5YVmIzdu3eP7777jmbNmuW6/8GDB/nWz4uZmZmup1OIZ5UmXUNsyKMvgnUD6qI0UWLZzhJVTVWOyfuPU9VSYdnOEoWR3ChWlH+mpqZ600we//tZHJKMFVONGjWAR8lDXnOgGjVqVOR2q1evjpGREX369OH111/PtUy9evWK1GZ2sjZr1ixatWqVa5knk6zHL0d/vI179+7pJUKZmZnEx8fnaK9Xr14EBQWxadMm3NzcuHv3bp7n8zhjY2Peeust3nrrLR4+fMiPP/7I4sWLGT58OCdOnMDKygojIyP++eeffNvZtWsXHh4ezJkzR297UlJSgTFYW1vTvHlzJk2alOv+WrVqFdiGEJWVNkvL3a13AajzzqNhfoWRAodAB24E3si9kgIcpjhIIiYqLUnGiqlRo0Y0aNCAy5cvM2XKlHzLPtlTlZ+qVavSrl07fv31V5o3b66rWxJt2rTB0tKSa9eu8eabbxarDXd3dwD27duHi4uLbvuBAwdyvcLQ1NSU1157jU2bNnH+/HmcnJx4/vnni3RMS0tLevTowT///MPcuXOJiYmhSZMmtG3blgMHDjB58mRdUpybJ1+7K1euEBkZSe3a+d8dvEuXLhw7doznnntOb26eEKJgCmMFtUbU0i1ns/axhkXkvM9YLRUOU+Q+Y6Jyk2SsGLJ7jebOncuIESMYNmwYffv2xd7envj4eK5fv86lS5dYuXIlAE2bNgXgyy+/xNzcHBMTE+rVq5djeDHbhx9+yGuvvcagQYPw8/PDwcGBpKQk/vzzT7777ju2bNlSpHirVavGrFmzCAwMJD4+nh49emBjY8ODBw+4fPkyDx48yNGD9KSmTZvi6+vLunXrMDIyon379ly9epV169ZhYWGBUplz+uHrr7/OZ599xsWLF/Mcyn3SyJEjadq0KS1atKBGjRrExsbyxRdfULduXd2FEDNmzOC1116jX79+jB49mueee043tDh37lzMzc3x8fFh5cqVLF++nLZt23Ljxg1WrFiBg4MDWVn5Xzo/ceJEfvzxRwYMGMDQoUNp2LAhaWlpxMbG8v333zNnzpwCEzohKiulSkndd+rmus/axxorbysSIxPJuJeBylaFuZu59IiJSk+SsSLI7tnK7nFp3749O3bs4JNPPmHu3Lk8fPgQKysrGjdurDfRvV69enzwwQds2LABPz8/srKyWLhwIf3798/1OE2aNGH37t2sXLmSZcuWcf/+fSwsLGjQoAGdO3cuVux9+vShTp06rFmzhg8++ICkpCRsbGxwdHSkX79+hWpj4cKF1KxZk/DwcD7//HOcnJxYsWIFw4cPx9LSMkd5e3t72rRpw2+//aa70KEg7dq14+DBg4SHh5OYmIitrS2enp74+/ujUqkAcHR05OuvvyY4OJjFixeTlJSEra0t7du315UZN24cKSkpbNu2jTVr1tC4cWPmzJnDN998w5kzZ/KNoWbNmuzcuZOVK1fy2Wef8c8//1CtWjUcHBzw8vKS3jIhSkBhpMDieZk7KcTjFFqtVh4MVkgff/wxmzZtIjIyEnNzc0OHUy6cO3eOgQMHsmzZshwJ17179/Dy8uLNN99k2rRpBorQ8C5evEjv3r3ZtWuX3hBv5dEMuGroIAzi1UtO3EyrYugwypRWq9XdeV9ZRZlj/mllUN80lR3Ovxo6DANpCvxm6CDKXEk/56VnrBAuXLjAhQsXiIiI4IUXXqi0idiJEyeIjIzExcUFU1NTrly5QmhoKA0aNKBbt266crdu3eKvv/7is88+Q6lUMmzYMMMFLYQoU5pUDb94/gI8urWFUVWjAmoIISQZKwR/f38SEhJ44YUXmDlzpqHDMRhzc3OOHz/O+vXrSUpKwtraGm9vbwIDA/Uu8Q0PD9fNz1q6dGmBt6EQQgghKjNJxgrh2LFjhg6hXGjVqhXh4eEFlhs/frzcWV6ISkpZRam7cauyitxXXIjCkGRMCCFEqVEoFDI0KUQRydcWIYQQQggDkp4xIYQQpUaToeHWmlsA1B5VG6VKvvMLURD5LRFCCFFqtJlabn9+m9uf30abKXdOEqIwpGdMCCFEqVEYKbAbbKdbFkIUTJIxIYQQpUZpoqTelHqGDkOICkWGKYUQQgghDEiSMSGEEEIIA5JkTAghRKnJSsnifJvznG9znqyULEOHI0SFIMmYEEIIIYQByQR+IYQQpUZZRUmLb1voloUQBSv0b8qBAwdQq9Xs3bs3x76XX34ZtVrNDz/8kGNfly5d6NWrV8miBNRqNcHBwUWul5KSQnBwMKdPny5xDIZy+vRp1Gp1hT2Hp/HeRUREoFariYmJKY0QhRClRKFQoLJWobJWoVDIrS2EKIxCJ2MeHh4oFIocfxjj4+P57bffMDMzy7Hv1q1b3Lx5k3bt2pU40IiICAYOHFjkeikpKYSEhHDmzJkSxyCK52m8d126dCEiIgI7O7vSCFEIkQ9tlpaEnxN4cPABCT8noM2Sm7kKUZoKPUxZo0YNmjZtmuMP45kzZzA2NmbAgAE5krHs9fySsdOnTzNkyBCOHTuGg4NDnuXc3NwKG6ooB7RaLWlpaVSpUuWpvHc2NjbY2NiUertCCH1xR+KIWRRDxp0M3TZVTRUOgQ5Y+1jnKK/J0HB7420Aar1ZSx6HJEQhFOm3pF27dvz+++/cuXNHt+3MmTO0aNGCzp07c/HiRRITE/X2GRkZ4e7uXuJAcxvqunv3LjNmzKBjx440b94cb29vQkJCyMzMBCAmJkZ37JCQENRqNWq1msDAQADu37/P9OnT6dixI46Ojri7uzNgwAB+/PHHfGMpbL1jx47x+uuv4+rqirOzMy+99BKrV6/W7Y+KiiIgIAAvLy+cnJzw8vJi/PjxxMbGFuo1iYqKYtSoUbRu3RpHR0d8fX3Zt29fvnUyMjJwd3dn8uTJOfY9fPgQJycn5s2bB0BaWhrz58/nlVdewdXVldatW9O/f38OHz6co65areajjz4iLCyMl156CUdHR77++mvdvsffu/v37zNz5ky6detGixYtcHd3Z8iQIfz000+6MgW9d3kNU27bto2XX34ZR0dHWrduzZgxY7h27ZpemcDAQFq0aMEff/zBiBEjaNGiBR07dmT+/PmkpaXpld2yZQsvv/wyLVq0oGXLlrz44ossXrw439dYiGdF3JE4bgTe0EvEADLuZHAj8AZxR+Jy1NFmarm16ha3Vt2SxyEJUUhFmsDfrl07NmzYwOnTp3XzwE6fPo2Pjw9t2rRBoVDw008/0aVLF90+Z2dnLCwsSj3wu3fv8uqrr6JUKvH396d+/fpERkbyySefEBMTQ1BQEHZ2dqxfv57hw4czcOBA3VBZjRo1AJg8eTKXLl1i8uTJNGzYkIcPH3Lp0iXi4nJ+wDyuMPXCw8OZPn06bdu2Zc6cOdjY2PDHH39w9epVXZnY2FgaNWrEK6+8gpWVFXfu3CEsLIw+ffpw6NAhXZy5OXXqFCNGjMDV1ZU5c+ZgYWHB3r17CQgIICUlhf79++daT6VS0adPH8LCwvjoo4/03ps9e/aQlpamq5uenk58fDxvv/02tWrVIiMjgx9//JFx48axcOFC+vbtq9f24cOH+emnn/D398fOzi7Pnqt///0XgHfffRc7OzuSk5P55ptv8PPzY9OmTbRr167A9y43q1evZvHixfj6+jJlyhTi4+MJCQmhf//+7Nixg4YNG+rKZmZmMnr0aAYMGMBbb73FTz/9xMqVK7GwsODdd9/VvR4zZ87kzTff5P3330ehUPDnn3/mSO6EKA3l7TYQ2iwtMUH5z8mMWRSDRVsLvcceadI11PCtoVsuS0ZVjcr0eEKUliIlYx4eHiiVSs6cOUOvXr2Ii4vj6tWrTJs2jWrVquHs7Mzp06fp0qULf//9N3/99Rc9evTQayMrKwutVqu3nv1/do8WgFKpRKnMu+MuODiYhw8fcvDgQerUqQNAx44dqVKlCgsWLGDkyJE0adIEFxcXAOzt7XMMl50/f56BAwcyaNAg3bYXX3yxwNehoHpJSUnMmzePNm3asGXLFt0k1o4dO+q106NHD73XJysrCx8fHzw8PNi9ezfDhg3LM4ZZs2bRpEkTNm/ejLHxo7fRy8uLuLg4lixZQt++ffN8/fr378/nn3/Ovn379M5h+/btuLi40KxZMwAsLCwICgrSi69Dhw48fPiQL774IkcylpSUxP79+6levXqecQM0atSIjz/+WK/dTp06ERMTw4YNG2jXrh2mpqb5vndPevjwIStXrqRz584sX75ct93Dw4MXXniBkJAQli1bptuenp7O+PHj6dmzJ/Dovblw4QK7d+/WJWPnzp3D0tKSWbNm6eo9+R4WRXJyMgkJCbp1ExMTTE1Ni92eeLb84vmLoUMosow7GUR5R+W5/8GeB2UYDbQ+17pMjycqr7S0NNLT03XrycnJJWqvSMlY9erVcXR01M0bO3v2LEZGRrRp0waAtm3bcurUKSDv+WJvvPFGrhOyfXx89Nb79u3LokWL8ozl6NGjtGvXjpo1a+olcd7e3ixYsICzZ8/SpEmTfM+nZcuWbN++HSsrKzp27IiLiwsqlSrfOoWpd/78eRITExkyZEi+VxMlJSWxcuVKDh48SGxsrC4xBbh+/Xqe9f744w+uX7/O+++/D6B3/p07d+bIkSP8/vvvNG7cONf6zZo1w8XFhYiICF0ydu3aNX755Rdmz56tV3b//v2sX7+eK1eu6P2w5ZZEtG/fvsBELFtYWBhffvkl0dHRej/QarW6UPWfdP78eVJTU+nXr5/e9jp16tC+fXtOnjypt12hUPDCCy/obWvevLnu5xfA1dWVTZs2MX78eF555RXatGmTb89cQQYPHqy3HhAQwPjx44vdnhBCCMMIDQ0lJCSk1Nor8n3G2rVrx7p167h9+zanTp3CxcWFatWqAY96IdatW0dCQgKnT5/G2NiY559/Xq/+3Llz9eaVXbx4kQ8//JA1a9boXRlX0B+9e/fu8d133+l6cZ704EHB38hCQkL45JNPCA8PZ9myZVSrVo0XX3yRadOm5XuVXkH1so9du3btfI8/ceJETp48ib+/Py1atNANGb711lukpqbmWe/evXsALFiwgAULFuRapqCh1gEDBjBr1iyuX7+OWq0mIiICExMTfH19dWUOHTrEu+++S8+ePRk5ciR2dnYYGRkRFhbGtm3bcrRZs2bNfI+Zbd26dcyfPx8/Pz8mTpyItbU1SqWSZcuW5ZuE5ic+Pj7PGGrVqpVjPl/VqlVzJJQmJiZ6c8ZeffVVsrKy+PLLL3nnnXfQaDS0bNmSSZMm4enpWeQYt27diqOjo97xhMjmesLV0CHoSTyfyPWAgn8f1SFqzFubl0FEQpQfY8aMYcSIEbr1y5cv5/jCXRTFTsbOnDnDmTNn6Ny5s25fduJ19uxZ3cT+7EQtW6NGjfTWs3tbmjVrlu/VlE+ytramefPmTJo0Kdf9tWrVKrCNGjVq8OGHH/Lhhx/y999/8+2337Jo0SLu37/PF198Uex62YnkrVu38mwjISGBI0eOEBAQwJgxY3Tb09LSdHOq8js+wNixY3nppZdyLfPk6/wkX19f5s2bx/bt25k8eTI7d+7kxRdf1OvZ2rlzJ/Xq1SMkJESvhy+v16aw9xTatWsXHh4ezJkzR297UlJSoernxsrKCkDv4pJst2/fxto651VfhdG/f3/69+9PcnIyZ8+eJTg4mJEjR/Ltt99St27dIrVlZmb2VOZPimdDeZvvZNnOElVNVY7J+49T1VJh2c5Sb85YVkoWF7peAKDFty3K3XkJURpMTU31vtCbmZmVqL0iJ2Pu7u4YGRlx4MABoqOjee+993T7LCwsdFfRxcTE6PWylLYuXbpw7NgxnnvuuXyHxrJ7H/LraYJHw1lvvvkmJ0+e5Ny5c4WOI7d6rVu3xsLCgq1bt+Lr65tnkqLVanP0joSHh+sNV+amUaNGNGjQgMuXLzNlypRCx/q46tWr8+KLL7Jjxw7c3Ny4e/cuAwYM0CujUChQqfRv3Hj37l2+/fbbYh3zcU+e95UrV4iMjNTrTSzsewePXvMqVaqwa9cu3TwweJQQnzp1KsfcxaIyMzOjc+fOZGRkMGbMGK5evVrkZEyIikRhpMAh0IEbgTfyKAAOUxz0ErFsmtSynbgvREVX5GTMwsICZ2dnDh8+jFKp1M0Xy+bh4cH69euBR3OInpaJEyfy448/MmDAAIYOHUrDhg1JS0sjNjaW77//njlz5lC7dm3Mzc2pW7cu3377LR06dKB69erUqFGD6tWrM2TIEHx9fVGr1VSrVo2oqCh++OEHunXrludxExISCqxXrVo1pk+fzvvvv88bb7zBa6+9hq2tLX/++SdXrlzRXcXYtm1bPvvsM6ytrXFwcODMmTNs27YNS0vLAs9/7ty5jBgxgmHDhtG3b1/s7e2Jj4/n+vXrXLp0iZUrVxbYxoABA9i3bx8fffQR9vb2OSan+/j4cOjQIWbOnEn37t25desWK1euxM7OrkS9WD4+PqxcuZLly5fTtm1bbty4wYoVK3BwcNBLRPN673LrQbW0tMTf35/FixczefJkfH19dVdTmpqa6iblF8X7779PlSpVaNOmDTVr1uTu3buEhoZiYWFBy5Yti33+QlQU1j7WsIic9xmrpcJhSu73GVOaKnHe46xbFkIUrFjPpmzXrh1RUVE4OTnlGHZp27Ytn3/+OSYmJrRuXbpXtjzeQ1OzZk127tzJypUr+eyzz/jnn3+oVq0aDg4OeHl56fWWLViwgIULFzJq1CjS09Pp27cvc+fOxdXVlZ07dxITE0NmZiZ16tRh9OjRjBo1Ks8YTExMClVv4MCB1KxZkzVr1jB9+nS0Wi0ODg68+uqrujLLli1jzpw5LFy4kKysLFq3bs2GDRt4++23C3wt2rdvz44dO/jkk0+YO3cuDx8+xMrKisaNG+v1DOWnY8eO1K5dm1u3bjFu3LgcV1/279+f+/fv6+aI1a9fnzFjxvDPP/+UaOLiuHHjSElJYdu2baxZs4bGjRszZ84cvvnmmxwXd+T23uV1YcfYsWOxsbFhw4YN7N+/H1NTUzw8PJgyZYrebS0Ky93dne3bt7N//34ePnyItbU1bdq0YfHixXLDWVFpWPtYY+VtRWJkIhn3MlDZqjB3M8+1RwxAoVRgWkeuEhaiKBTax+8zUU4lJCTQqlUrZs2axZtvvmnocIQokosXL9K7d2927dqlu11H5dIMuFpgqWfRq5ecuJlWxdBhiDJW3zSVHc6/GjoMA2kK/GboIMpcST/ni9UzVpYiIyN1d5WXRyIJIUT5ps3QcnfbXQDsBtihUMnDwoUoSLlPxiZOnEhWVhbTp0+nRYsWhg5HCCFEPjSZGmKWPLpzv82rNhip5GpKIQpS7pOx77//3tAhCCGEKCSFUoF1d2vdshCiYOU+GRNCCFFxKE2VNJxX9AtmhKjM5LpjIYQQQggDkmRMCCGEEMKAJBkTQghRarJSsoh6IYqoF6LISsn/aSJCiEdkzpgQQohSlRmfaegQhKhQJBkTQghRapSmShzDHXXLQoiCSTImhBCi1CiUCqqqqxo6DCEqFPnaIoQQQghhQNIzJoQQotRoM7Tc33MfABtfG3kckhCFIMmYEEKIUqPJ1HBz3k0ArHtYy+OQhCgEScaEEEKUGoVSQXXv6rplIUTBJBkTQghRapSmStRL1YYOQ4gKRSbwP+OCg4NRq9U8ePCg2G3s3r2b9evXl2JURadWq1Gr1YSGhubYFxERgVqtJioqSrct+7yz/zVv3hxvb28+/vhjHj58WODx1q9fz9ixY/H29katVuPn51eq5yOEEEJkk2RMFKg8JGPZQkNDiY+PL3T59evXExERwdq1a3nxxRfZuHEjI0aMQKvV5lsvLCyM2NhY2rdvT40aNUoYtRDlizZLS8LPCTw4+ICEnxPQZuX/+yCEeLpkmFJUGB07duTMmTOsWrWK6dOnF6qOi4uLLpny9PQkLi6OnTt3cu7cOZ5//vk86x06dAil8tF3le7du5c8eCHKibgjccQsiiHjToZum6qmCodAB6x9rEvcviZFw68DfgXAaZsTyqrynV+IgshvSSVx69Ytxo4di6urK66urkyaNIn79+8XWM/Pz4+jR48SGxurN+yXLSQkhL59+9K6dWtcXV3p1asX4eHhOXqe0tLSmD9/Ph4eHjg7OzNo0CAuXLiAl5cXgYGBhTqHRo0aMWDAADZt2kRsbGzRXoD/5+bmBsDff/+db7nsREyIZ0nckThuBN7QS8QAMu5kcCPwBnFH4kp8DC1a0m+lk34rHS3S4yZEYUjPWCUxduxYevbsiZ+fH9HR0Sxbtoxr166xfft2VCpVnvVmz57NjBkzuHnzJqtXr86xPyYmhsGDB1OnTh0AIiMjmT17Nrdv3+bdd9/VlXvvvffYt28fo0aNon379kRHRzN27FgSExOLdB7jx49n586dLF26lCVLlhSpLsCff/4JIEOPotLRZmmJWRSTb5mYxTFYeVuhMCr+VZBKEyXNNjbTLQshCibJWCXRrVs3pk2bBkCnTp2wtbVl4sSJ7N+/n969e+dZr0mTJlhaWmJiYqLrVXpcUFCQblmj0eDh4YFWq2XDhg34+/ujUCiIjo5mz549jB49WtcL5unpia2tLRMmTCjSedjZ2TF8+HBCQ0MZOXIkzZs3z7e8RqMhMzOT5ORkjh49SlhYGLVr18bd3b1Ixy0NycnJJCQk6NZNTEwwNTUt8zhE5ZQYmZijR+xJGbczSIxMxOJ5i2IfR2GkoJpztWLXF6IiSEtLIz09XbeenJxcovYkGaskevXqpbfes2dPAgMDOX36NL1790aj0aDRaHT7FQoFRkYF36zx5MmTrF69mqioqBy9XPfv38fW1pazZ8/qjvm4Hj16MGXKlCKfy6hRo/jyyy9ZuHBhgRcWeHh46K23adOGefPmGSQJGjx4sN56QEAA48ePL/M4ROWUcS//RKyo5YSozEJDQwkJCSm19iQZqyTs7Oz01o2NjbGysiIu7tEckRUrVuj9YNWtW5cffvgh3zZ/+eUXhg0bhoeHB/Pnz8fe3h6VSsXhw4dZtWoVqampALpj2Nra5hpDUVlYWDBu3Djmzp3LqVOn8i27ceNGLCwsUKlU2NvbY21d8gnKxbV161YcHR116yYmJgaLRVQ+Ktu8pyMUp1xetJla4r559Dtv/ZI1CmO58at49owZM4YRI0bo1i9fvpzjC3dRSDJWSdy9exd7e3vdemZmJvHx8brkZNCgQXTp0kW3vzA9R3v37sXY2Ji1a9fqlT98+LBeuexj3Lt3L9cYimPIkCFs2LCBoKAghgwZkmc5R0fHcjM/zMzMDAuL4g//CFES5m7mqGqq8h2qVNVSYe5mXqLjaDI0/PHhHwBU71IdI2N5HJJ49piamur93TMzMytRe5KMVRK7d++mRYsWuvX9+/eTmZmpG8arVasWtWrVyrWuiYmJrpfrcQqFAmNjY70rD1NTU9m5c6deuez5Wfv27cPFxUW3/cCBA2RmZhbrfExMTJg0aRITJ040aG+XEBWFwkiBQ6ADNwJv5FEAHKY4lGjyPjz6XLDwsNAtCyEKJslYJXHo0CGMjIzw9PTUXU3p6OiYYx5Xbpo1a8ahQ4fYsmULLi4uKBQKWrZsSefOnVm3bh0TJ05k0KBBxMXFsXbt2hzDb02bNsXX15d169ZhZGRE+/btuXr1KuvWrcPCwqLYt5Hw9fVl7dq1HDt2rFj18xMVFaW7fUb2XLgDBw4A0LJlS+rWrVvqxxTiabP2sYZF5LzPWC0VDlNK5z5jyipKmqxqUuJ2hKhMJBmrJFatWkVISAhhYWEoFAp8fHz44IMPCjVvadiwYURHR7N48WISEhLQarVcv36dDh06sHDhQj799FNGjhyJvb09r732GjY2NrorN7MtXLiQmjVrEh4ezueff46TkxMrVqxg+PDhWFpaFuucFAoFU6dOZejQocWqn59Nmzbx9ddf623z9/cHHp1L//79S/2YQpQFax9rrLytHl1deS8Dle2jocmS9ogJIYpPoS3ouTBCPCXnzp1j4MCBLFu2LMfVns+Sixcv0rt3b3bt2qU3TFt5NAOuGjoIg3j1khM306oYOgxRxuqbprLD+VdDh2EgTYHfDB1EmSvp57z0jIkyceLECSIjI3FxccHU1JQrV64QGhpKgwYN6Natm6HDE0KUEk2KhitvXgGg+cbm8jgkIQpBkjFRJszNzTl+/Djr168nKSkJa2trvL29CQwMlBufCvEM0aIl9fdU3bIQomCSjIky0apVK8LDww0dhhDiKVOaKGnyaRPdshCiYJKMCSGEKDUKI0WJHqckRGUkX1uEEEIIIQxIesaEEEKUGm2mln+P/wtA9U7V5XFIQhSCJGNCCCFKjSZDw+9TfgfA9YSrPA5JiEKQZEwIIUSpUSgUVHOtplsWQhRMkjEhhBClRllFSbPPmxk6DCEqFJnAL4QQQghhQJKMCSGEEEIYkCRjQgghSo0mVcOVN65w5Y0raFI1hg5HiApB5owJIYQoNVqtluRfk3XLQoiCSTImhBCi1ChVStTL1bplIUTBJBkTQghRahTGCqp3qm7oMISoUORryzMuODgYtVrNgwcPit3G7t27Wb9+fSlGVXRqtRq1Wk1oaGiOfREREajVaqKionTbss87+1/z5s3x9vbm448/5uHDh/ke68aNG8yfP59evXrRqlUrWrduzYABAzhw4ECpn5cQzwJtlpaEnxN4cPABCT8noM2S4UkhikJ6xkSBdu/ezdWrVxk+fLihQyE0NJRBgwZhZWVVqPLr16/HwsKCpKQkvv/+e7744guioqLYtm1bnjekPH78ON9//z19+vShZcuWZGZmsm/fPvz9/ZkwYQLvvvtuKZ6REBVb3JE4YhbFkHEnQ7fNyMoIuwF21B5ZG4WR3PhViIJIMiYqjI4dO3LmzBlWrVrF9OnTC1XHxcWFGjVqAODp6UlcXBw7d+7k3LlzPP/887nWeeWVV3jjjTf0krXOnTsTFxfHp59+yqhRozA1NS35CQlRwcUdieNG4I0c27Pis/jns38wbWCKTXcbA0QmRMUiw5SVxK1btxg7diyurq64uroyadIk7t+/X2A9Pz8/jh49SmxsrN6wX7aQkBD69u1L69atcXV1pVevXoSHh+e4iiotLY358+fj4eGBs7MzgwYN4sKFC3h5eREYGFioc2jUqBEDBgxg06ZNxMbGFu0F+H9ubm4A/P3333mWqVGjRq69Zq6urqSkpPDvv/8W69hCPEsyEzOJCYrJt8zfy/+WIUshCkF6xiqJsWPH0rNnT/z8/IiOjmbZsmVcu3aN7du3o1Kp8qw3e/ZsZsyYwc2bN1m9enWO/TExMQwePJg6deoAEBkZyezZs7l9+7becN57773Hvn37GDVqFO3btyc6OpqxY8eSmJhYpPMYP348O3fuZOnSpSxZsqRIdQH+/PNPAF1vWVGcOnWKGjVqYGNTvG/6ycnJJCQk6NZNTEykh01UWFHeUQWWybibQWJkIhbPW5RBREKUnbS0NNLT03XrycnJJWpPkrFKolu3bkybNg2ATp06YWtry8SJE9m/fz+9e/fOs16TJk2wtLTExMRE16v0uKCgIN2yRqPBw8MDrVbLhg0b8Pf3R6FQEB0dzZ49exg9erSuF8zT0xNbW1smTJhQpPOws7Nj+PDhhIaGMnLkSJo3b55veY1GQ2ZmJsnJyRw9epSwsDBq166Nu7t7kY771VdfcebMGT788EOMjIyKVDfb4MGD9dYDAgIYP358sdoSoqLIuJdRcCEhKpjQ0FBCQkJKrT1JxiqJXr166a337NmTwMBATp8+Te/evdFoNGg0/7tbtkKhKFTScfLkSVavXk1UVFSOXq779+9ja2vL2bNndcd8XI8ePZgyZUqRz2XUqFF8+eWXLFy4sMCrPD08PPTW27Rpw7x584rUI/X999/z0Ucf0aNHD4YOHVrkeLNt3boVR0dH3bqJiUmx2xLC0NQhaq4HXC+wnMo27553ISqqMWPGMGLECN365cuXc3zhLgpJxioJOzs7vXVjY2OsrKyIi4sDYMWKFXpZft26dfnhhx/ybfOXX35h2LBheHh4MH/+fOzt7VGpVBw+fJhVq1aRmpoKoDuGra1trjEUlYWFBePGjWPu3LmcOnUq37IbN27EwsIClUqFvb091tbWRTrWDz/8wLhx4+jYsSNLly7N8wrMwjAzM8PCQoZrxLPBsp0lqpoqvason6SqqcLczbwMoxKibJiamup9qTczMytRe5KMVRJ3797F3t5et56ZmUl8fLwuORk0aBBdunTR7S9Mz9HevXsxNjZm7dq1euUPHz6sVy77GPfu3cs1huIYMmQIGzZsICgoiCFDhuRZztHRsVjzw+BRIjZmzBjatm3LJ598Ij1ZQjxGYaTAIdAh16sps9UZX0dubSFEIUgyVkns3r2bFi1a6Nb3799PZmambhivVq1a1KpVK9e6JiYmul6uxykUCoyNjVEq/3dRbmpqKjt37tQrlz0/a9++fbi4uOi2HzhwgMzMzGKdj4mJCZMmTWLixIlF7u0qjOPHjzNmzBief/55Pv30U5loL0QurH2sYRE57zNW3QgbXxtqdC3eFyEhKhtJxiqJQ4cOYWRkhKenp+5qSkdHxxzzuHLTrFkzDh06xJYtW3BxcUGhUNCyZUs6d+7MunXrmDhxIoMGDSIuLo61a9fm6EFq2rQpvr6+rFu3DiMjI9q3b8/Vq1dZt24dFhYWeslcUfj6+rJ27VqOHTtWrPp5+fnnnxkzZgx2dnaMHTuWX3/9VW9/48aNZbhRiP9n7WONlbcViZGJZNzLQGX7aGhSesSEKDxJxiqJVatWERISQlhYGAqFAh8fHz744INCDb0NGzaM6OhoFi9eTEJCAlqtluvXr9OhQwcWLlzIp59+ysiRI7G3t+e1117DxsZGd+VmtoULF1KzZk3Cw8P5/PPPcXJyYsWKFQwfPhxLS8tinZNCoWDq1KklmlSfmx9//JHU1FRiYmJ4/fXXc+zfsmUL7dq1K9VjClGRKYwUcvsKIUpAoX3y7pxClJFz584xcOBAli1bluNqz2fJxYsX6d27N7t27dIbpq08mgFXDR2EQbx6yYmbaVUMHUaZ0mZpSbqQBEC1FtUqZQ9ZfdNUdjj/WnDBZ1JT4DdDB1HmSvo5Lz1jokycOHGCyMhIXFxcMDU15cqVK4SGhtKgQQO6detm6PCEEKVEk67h6luPkm/XE64YVS3effmEqEwkGRNlwtzcnOPHj7N+/XqSkpKwtrbG29ubwMBAmRwvxDNEgQLTeqa6ZSFEwSQZE2WiVatWhIeHGzoMIcRTpqyqxHmns6HDEKJCkQeFCyGEEEIYkCRjQgghhBAGJMmYEEKIUqNJ03At4BrXAq6hSdMUXEEIIXPGhBBClB6tRsvDHx/qloUQBZNkTAghRKlRGit5btZzumUhRMEkGRNCCFFqFCoFNr1sDB2GEBWKfG0RQgghhDAg6RkTQghRarRZWlKupQBQtXHVSvk4JCGKSpIxIYQQpUaTruGK3xVAHockRGFJMiaEEKLUKFCgslPploUQBZNkTAghRKlRVlXS4mALQ4chRIUiE/iFEEIIIQxIkrFnXHBwMGq1mgcPHhS7jd27d7N+/fpSjKro1Go1arWa0NDQHPsiIiJQq9VERUXptmWfd/a/5s2b4+3tzccff8zDhw/zPVZycjIBAQF07dqVli1b4uLiQvfu3Vm5ciXJycmlfm5CVFTaLC0JPyfw4OADEn5OQJslN3kVojhkmFIUaPfu3Vy9epXhw4cbOhRCQ0MZNGgQVlZWhSq/fv16LCwsSEpK4vvvv+eLL74gKiqKbdu2oVDkPp8lMzMTrVbLiBEjqFevHkqlkrNnz7Jy5UrOnDnDpk2bSvGMhKiY4o7EEbMohow7Gbptqpoq6k6oS/x38QA0mNMApal85xeiIJKMiQqjY8eOnDlzhlWrVjF9+vRC1XFxcaFGjRoAeHp6EhcXx86dOzl37hzPP/98rnUsLS1ZsWJFjmOnp6ezZs0abt68Sf369Ut2MkJUYHFH4rgReCPH9ow7Gfwx/Q/duna29JQJURjylaWSuHXrFmPHjsXV1RVXV1cmTZrE/fv3C6zn5+fH0aNHiY2N1Rv2yxYSEkLfvn1p3bo1rq6u9OrVi/DwcLRa/Q/htLQ05s+fj4eHB87OzgwaNIgLFy7g5eVFYGBgoc6hUaNGDBgwgE2bNhEbG1u0F+D/ubm5AfD3338XuW52UmdsLN9hROWTlZJFVkoWmYmZxATF5FvWyNyIOuProM2UZEyIwpC/KpXE2LFj6dmzJ35+fkRHR7Ns2TKuXbvG9u3bUalUedabPXs2M2bM4ObNm6xevTrH/piYGAYPHkydOnUAiIyMZPbs2dy+fZt3331XV+69995j3759jBo1ivbt2xMdHc3YsWNJTEws0nmMHz+enTt3snTpUpYsWVKkugB//vkn8L/EKj9arZasrCxSUlI4f/4869atw9fXV3euRZWcnExCQoJu3cTEBFNT02K1JURZ+8Xzl0KXzUrM4u/gv/k7+G9an2v9FKMSwjDS0tJIT0/XrZd0PrEkY5VEt27dmDZtGgCdOnXC1taWiRMnsn//fnr37p1nvSZNmmBpaYmJiYmuV+lxQUFBumWNRoOHhwdarZYNGzbg7++PQqEgOjqaPXv2MHr0aF0vmKenJ7a2tkyYMKFI52FnZ8fw4cMJDQ1l5MiRNG/ePN/yGo2GzMxMkpOTOXr0KGFhYdSuXRt3d/cCj7V37169+Pr378+8efOKFO/jBg8erLceEBDA+PHji92eEEIIwwgNDSUkJKTU2pNkrJLo1auX3nrPnj0JDAzk9OnT9O7dG41Gg0aj0e1XKBQYGRV85+yTJ0+yevVqoqKicvRy3b9/H1tbW86ePas75uN69OjBlClTinwuo0aN4ssvv2ThwoUFXuXp4eGht96mTRvmzZtXqB4pLy8vduzYQVJSEpGRkXz66afEx8ezevVqlMqij/Bv3boVR0dH3bqJiUmR2xDCUFxPuAKQeD6R6wHXCyxf78N6WL9o/bTDEsIgxowZw4gRI3Trly9fzvGFuygkGask7Ozs9NaNjY2xsrIiLi4OgBUrVuhl+XXr1uWHH37It81ffvmFYcOG4eHhwfz587G3t0elUnH48GFWrVpFamoqgO4Ytra2ucZQVBYWFowbN465c+dy6tSpfMtu3LgRCwsLVCoV9vb2WFsX/o9D9erVadmyJQDt27enfv36jB8/nsOHD9OtW7cix21mZoaFhUWR6wlRHmQ/1siynSWqmiq9qyhz89ecv6jRreDpAEJURKampnpf6s3MzErUniRjlcTdu3ext7fXrWdmZhIfH69LTgYNGkSXLl10+wvTc7R3716MjY1Zu3atXvnDhw/rlcs+xr1793KNoTiGDBnChg0bCAoKYsiQIXmWc3R0LNT8sMJwdX3UM/DHH3+USntCVEQKIwUOgQ65Xk2ZTVlFicJYHoUkRGFJMlZJ7N69mxYt/veIkv3795OZmakbxqtVqxa1atXKta6JiYmul+txCoUCY2NjvSG71NRUdu7cqVcue37Wvn37cHFx0W0/cOAAmZmZxTofExMTJk2axMSJE4vU21USp0+fBuC5554rk+MJUV5Z+1jDInLeZ6yWCocpDo/2CyEKTZKxSuLQoUMYGRnh6empu5rS0dExxzyu3DRr1oxDhw6xZcsWXFxcUCgUtGzZks6dO7Nu3TomTpzIoEGDiIuLY+3atTnmQjVt2hRfX1/WrVuHkZER7du35+rVq6xbtw4LC4tizb8C8PX1Ze3atRw7dqxY9fMSFhbGzz//jKenJ7Vr1yYlJYWffvqJjRs30rp1a7p27VqqxxOiIrL2scbK24rEyEQy7mWgslVh7maOwkh6xIQoKknGKolVq1YREhJCWFgYCoUCHx8fPvjgg0JNIh82bBjR0dEsXryYhIQEtFot169fp0OHDixcuJBPP/2UkSNHYm9vz2uvvYaNjY3uys1sCxcupGbNmoSHh/P555/j5OTEihUrGD58OJaWlsU6J4VCwdSpUxk6dGix6uelWbNmHD16lMWLFxMXF4eRkRENGjRg7NixvPXWW3KfMSH+n8JIgcXzMg9SiJJSaJ+8O6cQZeTcuXMMHDiQZcuW5bja81ly8eJFevfuza5du/SGaSuPZsBVQwdhEK9ecuJmWhVDh1GmNOkabs67CUD9GfVRmlS+e4vXN01lh/Ovhg7DQJoCvxk6iDJX0s95+YovysSJEyeIjIzExcUFU1NTrly5QmhoKA0aNCjWlYlCiPJJm6Xlwd4HANSbVs/A0QhRMUgyJsqEubk5x48fZ/369SQlJWFtbY23tzeBgYFyF3ohniEKYwV1x9fVLQshCibJmCgTrVq1Ijw83NBhCCGeMqVKSa03c78yWwiRu8o3mC+EEEIIUY5Iz5gQQohSo9Voybj36N5jKlsVCqUMVQpREEnGhBBClBpNmoaLPS4Cj55nmf0YJSFE3iQZE0IIUbok/xKiSCQZE0IIUWqMqhrR+mxrQ4chRIUiE/iFEEIIIQxIkjEhhBBCCAOSYUohhBClRpOuIWZpDAAOkxwq5eOQhCgq+S0RQghRarRZWu5tu8e9bffQZsmjj4UoDOkZE0IIUWoUxgrsR9nrloUQBZNkTAghRKlRqpTUGV3H0GEIUaHIMKUQQgghhAFJMvaMCw4ORq1W8+DBg2K3sXv3btavX1+KURWdWq1GrVYTGhqaY19ERARqtZqoqCjdtuzzzv7XvHlzvL29+fjjj3n48GGRjh0dHY2jo2OOYwghctJqtWQmZJKZkIlW+2jOmDZLS8LPCTw4+ICEnxNkLpkQT5BhSlGg3bt3c/XqVYYPH27oUAgNDWXQoEFYWVkVqvz69euxsLAgKSmJ77//ni+++IKoqCi2bduGQlHwfJasrCymTZuGtbU1t2/fLmH0Qjz7NKkaojo/+tLiesKVh6ceErMohow7GboyqpoqHAIdsPaxNlSYQpQr0jMmKoyOHTuSkpLCqlWrCl3HxcUFNzc3PD09+eCDD+jduzeRkZGcO3euUPU///xz/vnnH0aNGlXcsIWotOKPxXMj8IZeIgaQcSeDG4E3iDsSZ6DIhChfJBmrJG7dusXYsWNxdXXF1dWVSZMmcf/+/QLr+fn5cfToUWJjY/WG/bKFhITQt29fWrdujaurK7169SI8PFw3PJEtLS2N+fPn4+HhgbOzM4MGDeLChQt4eXkRGBhYqHNo1KgRAwYMYNOmTcTGxhbtBfh/bm5uAPz9998Flr1x4wbLly9n9uzZmJubF+t4QlQGWSlZun9arZaW37ekxXct+Ht5/r9nMYtiyEzM1KsvRGUkw5SVxNixY+nZsyd+fn5ER0ezbNkyrl27xvbt21GpVHnWmz17NjNmzODmzZusXr06x/6YmBgGDx5MnTqPrp6KjIxk9uzZ3L59m3fffVdX7r333mPfvn2MGjWK9u3bEx0dzdixY0lMTCzSeYwfP56dO3eydOlSlixZUqS6AH/++ScANWrUyLecVqtl+vTp+Pj40LVrVyIiIop8rCclJyeTkJCgWzcxMcHU1LTE7QphaL94/lKsehl3Mojy1p+H2fqcPNdSlH9paWmkp6fr1pOTk0vUniRjlUS3bt2YNm0aAJ06dcLW1paJEyeyf/9+evfunWe9Jk2aYGlpiYmJia5X6XFBQUG6ZY1Gg4eHB1qtlg0bNuDv749CoSA6Opo9e/YwevRoXS+Yp6cntra2TJgwoUjnYWdnx/DhwwkNDWXkyJE0b9483/IajYbMzEySk5M5evQoYWFh1K5dG3d393zrbdq0id9++40VK1YUKb78DB48WG89ICCA8ePHl1r7QgghykZoaCghISGl1p4kY5VEr1699NZ79uxJYGAgp0+fpnfv3mg0GjQajW6/QqHAyMiowHZPnjzJ6tWriYqKytHLdf/+fWxtbTl79qzumI/r0aMHU6ZMKfK5jBo1ii+//JKFCxcWeJWnh4eH3nqbNm2YN29evj1SsbGxLF68mA8++ABbW9six5eXrVu34ujoqFs3MTEptbaFMCTXE666ZU2Ghn/W/EP67XT+PfJvgXXVIWrMW8s0AFGxjBkzhhEjRujWL1++nOMLd1FIMlZJ2NnZ6a0bGxtjZWVFXNyjCbQrVqzQy/Lr1q3LDz/8kG+bv/zyC8OGDcPDw4P58+djb2+PSqXi8OHDrFq1itTUVADdMZ5MbLJjKCoLCwvGjRvH3LlzOXXqVL5lN27ciIWFBSqVCnt7e6ytC756a9asWTRt2pTu3bvrboORfS7ZQ40WFhZFjtvMzKxY9YQo74yq6n9xu7v1LgAqOxUZdzNyq/Jofy0Vlu0sURjJnfpFxWJqaqr3pd7MzKxE7UkyVkncvXsXe3t73XpmZibx8fG65GTQoEF06dJFt78wc5n27t2LsbExa9eu1St/+PBhvXLZx7h3716uMRTHkCFD2LBhA0FBQQwZMiTPco6OjgXOD3vS1atXiY2NzXVYdsiQIVhYWPDf//63qCELUSkojBXUfKMmAGZOZvzx/h95FASHKQ6SiAmBJGOVxu7du2nRooVuff/+/WRmZuqG8WrVqkWtWrVyrWtiYqLrGXqcQqHA2NgYpfJ/F+Wmpqayc+dOvXLZ87P27duHi4uLbvuBAwfIzMws1vmYmJgwadIkJk6cWKjerqIIDg4mLS1Nb9sPP/zAp59+ypw5c2jatGmpHk+IZ4lSpcRhgoNuXWGsyHmfsVoqHKbIfcaEyCbJWCVx6NAhjIyM8PT01F1N6ejomGMeV26aNWvGoUOH2LJlCy4uLigUClq2bEnnzp1Zt24dEydOZNCgQcTFxbF27docc6GaNm2Kr68v69atw8jIiPbt23P16lXWrVuHhYWFXjJXFL6+vqxdu5Zjx44Vq35ecusRi4mJAR7dt6xly5alejwhnmXWPtZYeVuRGJlIxr0MVLYqzN3MpUdMiMdIMlZJrFq1ipCQEMLCwlAoFPj4+PDBBx8UahL5sGHDiI6OZvHixSQkJKDVarl+/TodOnRg4cKFfPrpp4wcORJ7e3tee+01bGxsdFduZlu4cCE1a9YkPDyczz//HCcnJ1asWMHw4cOxtLQs1jkpFAqmTp3K0KFDi1VfCFH6tFotZHd4Gz/6PVUYKbB4XuZLCpEXhfbJu3MKUUbOnTvHwIEDWbZsWY6rPZ8lFy9epHfv3uzatUtvmLbyaAZcNXQQBvHqJSduplUxdBhlKislS3ffMdcTrjkm91cG9U1T2eH8q6HDMJCmwG+GDqLMlfRzXnrGRJk4ceIEkZGRuLi4YGpqypUrVwgNDaVBgwZ069bN0OEJIYQQBiPJmCgT5ubmHD9+nPXr15OUlIS1tTXe3t4EBgbKXeiFeIYoqyhp+X1L3bIQomCSjIky0apVK8LDww0dhhDiKVMoFBhbyJ8WIYpCvrYIIYQQQhiQfH0RQghRajQZGv75/B8A7EfYo1TJd34hCiLJmBBCiFKjzdTyz5pHyVitN2uBysABCVEBSDImhBCi1CiMFNgOsNUtCyEKJsmYEEKIUqM0UVJ/Wn1DhyFEhSKD+UIIIYQQBiTJmBBCCCGEAUkyJoQQotRkpWRxvu15zrc9T1ZKlqHDEaJCkDljQgghSpfkYEIUiSRjQgghSo3SVInLARfdshCiYJKMCSGEKDUKpQKTmiaGDkOICkW+tpRzERERqNVq1Go1p0+fzrFfq9XSpUsX1Go1fn5+evuy6+X2LzAwsKxOoUCnT5/O8/wKEh0dTXBwMDExMTn2BQYG4uXlVRohCiGEEE+N9IxVEObm5mzbto127drpbT9z5gw3b97E3Nw813o9evTgrbfeyrG9Ro0aTyXO4nB2diYiIoLGjRsXue61a9cICQnBw8MDBwcHvX3+/v4MGzaslKIUQhSGJkPD3a13AbAbbFeuHoekzdKSGJlIxr0MVLYqzN3M5ca0olyQZKyC6NmzJ7t37+ajjz7CwsJCt33btm24ubmRmJiYaz1bW1vc3NzKKswiycjIQKFQYGFh8VRifO6550q9TSFE/rSZWmKDYwEe3Ym/nDwOKe5IHDGLYsi4k6HbpqqpwiHQAWsfawNGJoQMU1YYvr6+AOzZs0e3LSEhgYMHDzJgwIBSPdbly5dRq9WEh4fn2Pf999+jVqv59ttvAfjjjz+YOnUqPj4+ODs706FDB0aOHMlvv/2mVy97KHLHjh3Mnz+fDh064OjoyJ9//pnrMGVUVBQBAQF4eXnh5OSEl5cX48ePJzY2VlcmIiICf39/AIYMGaIbgo2IiAByH6ZMS0tj0aJFeHt707x5czp06MCsWbN4+PChXjkvLy/efvttjh07Rq9evXBycuLFF19k27ZtJXhlhXj2KYwU1HilBjVeqVFuep3ijsRxI/CGXiIGkHEngxuBN4g7EmegyIR4RHrGKghzc3O6d+9ORESEbm7Ynj17UCqVvPzyy6xfvz7XelqtlszMzBzbjYyMUChy/6B0dHTUDR0OHDhQb9/27duxsbGhc+fOANy5cwcrKyumTp1KjRo1iI+P5+uvv6Zv377s2bOHRo0a6dVfvHgxbm5uzJkzB6VSiY2NDXfv3s0RQ2xsLI0aNeKVV17BysqKO3fuEBYWRp8+fTh06BA1atSgS5cuTJkyhcWLFzN79mycnZ0BqF8/90exaLVaRo8ezalTpxgzZgzu7u5cuXKF4OBgIiMj2bZtG6amprryly9fZsGCBYwePRpbW1vCw8OZNm0azz33HG3bts31GEJUdkoTJQ1mNzB0GDraLC0xi3LOKX1czOIYrLytyk3yKCofScYqkAEDBjBkyBCuXr1K06ZN2bZtGz169MhzvhjA5s2b2bx5c47tS5YsoU+fPnnW69evHx9//DE3btygYcOGAPz77798++23vPHGGxgbP/rRadu2rV5ikpWVRZcuXejevTtbt25lxowZeu3Wr1+flStXFniuPXr0oEePHnrt+vj44OHhwe7duxk2bBg2NjY0aNAAgMaNGxc41Hn8+HGOHz/Oe++9x6hRowDw9PSkdu3aBAQEsGPHDgYNGqQrHxcXx7Zt26hTp47uXE+ePMnu3buLlYwlJyeTkJCgWzcxMdFL/oQQpS8xMjFHj9iTMm5nkBiZiMXzFvmWEyJbWloa6enpuvXk5OQStSfJWAXi4eFB/fr1iYiIoF+/fkRFRTF9+vR86/Ts2ZORI0fm2J5X71G23r1785///Ift27czZcoU4FFPXHp6Ov3799eVy8zMZM2aNezatYs///yTjIz/fehdu3YtR7vdunXL97jZkpKSWLlyJQcPHiQ2NpasrP/dRfL69euFauNJp06dAh4lmo/r2bMn06ZN4+TJk3rJmJOTky4RAzA1NaVhw4Z6Q6VFMXjwYL31gIAAxo8fX6y2hBCFk3Ev/0SsqOWEAAgNDSUkJKTU2pNkrAJRKBT079+fDRs2kJaWRsOGDXF3d8+3jo2NDS1btizysaysrOjatSs7duxg4sSJGBkZsX37dlxdXWnatKmu3Lx589i8eTOjR4+mbdu2VK9eHYVCwfTp00lLS8vRbs2aNQt1/IkTJ3Ly5En8/f1p0aKF7qKFt956i9TU1CKfD0B8fDzGxsbY2NjobVcoFNja2hIfH6+33crKKkcbJiYmuZ5XYWzduhVHR0e9toR41mSlZHGx+0UAXA66YFTVyKDxqGwLdwVBYcsJATBmzBhGjBihW798+XKOL9xFIclYBdOvXz+WL19OWFgYkydPfurH2r9/PydOnKBOnTpERUUxZ84cvTK7du3i1Vdf1fWeZYuLi8PS0jJHm3nNU3tcQkICR44cISAggDFjxui2p6Wl8e+//xbzbB4lV5mZmdy/f18vIdNqtdy7d69YSWtRmJmZ6V0JK8SzKiux/DwPydzNHFVNVb5Dlapaj25zIURhmZqa6k0zMTMzK1F7cjVlBWNvb8/IkSPx8fGhb9++T/VYnTp1wt7enoiICCIiIjA1NdVd1ZlNoVDk6OE5evQo//zzT4mOrdVqc7QbHh6uN1wJ/+tdKkxvWYcOHYBHCeTjDh48SHJysm6/EKL4lKZKnHY44bTDqVw8DklhpMAh0CGfAuAwxUEm7wuDkp6xCmjq1KmFLnvv3j0iIyNzbDc3N6dJkyb51jUyMuLVV19l3bp1mJub061btxw9O126dGH79u2o1WqaNWvGxYsX+eyzz7C3ty90jE+ysLCgbdu2fPbZZ1hbW+Pg4MCZM2fYtm1bjt627CHTL7/8EnNzc0xMTKhXrx7W1jnvG+Tp6UmnTp0ICgoiMTGRNm3a6K6mdHZ2zveCBiFE4SiUCqrUr2LoMPRY+1jDInLeZ6yWCocpcp8xYXiSjD3jDhw4wIEDB3Jsb9OmTa73EXtSv379WL16NQ8ePNCbuJ9t5syZqFQqVq9eTXJyMs7OzqxevZqlS5eWKO5ly5YxZ84cFi5cSFZWFq1bt2bDhg28/fbbeuXq1avHBx98wIYNG/Dz8yMrK4uFCxfmGqtCoeDTTz8lODiYiIgIVq1ahbW1NX369GHKlClyZaMQzzBrH2usvK3kDvyiXFJotVqtoYMQ4ll28eJFevfuza5du3BxcTF0OAbQDLhq6CAM4tVLTtxMK1+9RE+bNkPLvR33ALB91RaFqvIlO/VNU9nh/KuhwzCQpsBvBZZ61pT0c156xoQQQpQaTaaGvxb+BUAN3xoYqQx7NaUQFYEkY0IIIUqNQqnA6gUr3bIQomCSjAkhhCg1SlMljYIaFVxQCKFj+OuOhRBCCCEqMUnGhBBCCCEMSJIxIYQQpUaTouFC9wtc6H4BTYrG0OEIUSHInDEhhBClRouWjLsZumUhRMEkGRNCCFFqlCZKmoc11y0LIQomyZgQQohSozBSYNasZA9NFqKyka8tQgghhBAGJD1jQgghSo02Q8uDAw8AqNGjRqV8HJIQRSXJmBBCiFKjydTw5+w/AbB60UoehyREIUgyJoQQotQolAosO1rqloUQBZNkTAghRKlRmippHNLY0GEIUaHIBH4hhBBCCAOSZKyCiYiIQK1W6/41bdqUjh07MnXqVP755x+9steuXWPy5Ml07twZR0dHnn/+eXr16sVHH31EQkKCgc4gp+xziomJKXLdc+fOERwczMOHD3Ps8/Pzw8/PrzRCFEIIIZ4aGaasoBYuXIharSY1NZWffvqJ1atXc/bsWfbv34+ZmRmXLl1i4MCBqNVq/P39cXBwIC4ujsuXL7N3717efvttLCwsDH0aAHTp0oWIiAjs7OyKXPf8+fOEhITQr18/LC0t9fbNnj27tEIUQhSSJkXD5cGXAXDc6oiyaul+59dmaUmMTCTjXgYqWxXmbuYojGRumqjYJBmroJo2bUrLli0BaN++PVlZWaxcuZLDhw/Tu3dv1q9fj1KpJCwsDHNzc129Hj16MGnSJLRawz+mJDU1FVNTU2xsbLCxsSn19ps0aVLqbQoh8qdFS9pfabrl0hR3JI6YRTFk3MnQbVPVVOEQ6IC1j3WpHkuIsiTDlM+IVq1aARAbGwtAfHw85ubmVKtWLdfyCkXe3yS/+eYb1Go1P/74Y459W7ZsQa1Wc+XKFQCioqIICAjAy8sLJycnvLy8GD9+vC6ObNlDkcePH+e9997D3d0dZ2dn0tPTcx2mPHHiBKNHj6Zjx444OjrSpUsXZsyYwYMHD3RlgoOD+c9//gOAt7e3buj29OnTQO7DlPHx8cycOZMOHTrQvHlzOnfuzOLFi0lLS9Mrp1ar+eijj9ixYwcvvfQSzs7OvPzyyxw5ciTP100I8egRSE3XNaXpuqal+jikuCNx3Ai8oZeIAWTcyeBG4A3ijsSV2rGEKGvSM/aM+PPPR/f1qVGjBgBubm4cPXqUiRMnMnjwYFxdXalSpUqh2vLx8cHGxobt27fTsWNHvX3bt2/H2dmZ5s0fPXsuNjaWRo0a8corr2BlZcWdO3cICwujT58+HDp0SBdPtmnTpukSoJSUFIyNc/8RvHnzJm5ubgwcOBALCwtiYmL4/PPPee2119i/fz8qlYqBAwcSHx/Pxo0bWbVqFTVr1gSgcePcr+RKS0tjyJAh3Lx5k/Hjx9O8eXN++uknQkNDuXz5MuvWrdMrf/ToUaKiopgwYQJmZmasWbOGsWPHcvjwYerXr1+o11KIykZhpMC8lXnBBYtAm6UlZlH+c0pjFsdg5W0lQ5aiQpJkrILSaDRkZmaSlpbG2bNn+eSTTzA3N6dr164AvP3221y4cIE9e/awZ88ejIyMaN68Od7e3gwbNizfYUFjY2P69OnDli1bSEhI0M0tu3btGr/88guzZs3Sle3Rowc9evTQrWdlZeHj44OHhwe7d+9m2LBhem23b9+eefPmFXh+j/doabVaWrduTbt27ejUqRPHjh2ja9eu1K5dmzp16gDg7OyMg4NDvm1u376dK1eusGLFCnr27AmAp6cnZmZmBAUFceLECTw9PXXlU1NT2bhxo26Y18XFhfbt27N//37GjBlT4Dk8KTk5We/CCRMTE0xNTYvcjhCVTWJkYo4esSdl3M4gMTIRi+fLx1xY8WxLS0sjPT1dt56cnFyi9iQZq6D69eunt96sWTM+/vhjbG1tATA1NSU0NJRr165x/PhxLly4wJkzZ1i1ahVbt24lPDycRo0a5dl+//79WbduHXv37mXw4MHAo6FGExMTevXqpSuXlJTEypUrOXjwILGxsWRlZen2Xb9+PUe73bt3L9T53bt3j+XLl3P06FHu3LmDRqPRazc76SyKU6dOYWZmppc8wqPXMigoiJMnT+olY+3atdObb2dra4uNjU2OIdjCyn4dswUEBDB+/PhitSVEeaXN1BJ/NB4Aqy5WKIxL3lOVcS//RKyo5YQoqdDQUEJCQkqtPUnGKqjFixejVqsxNjbG1tZWN0T3pMaNG+uG7bRaLevXr2fevHksW7aMFStW5Nl+9gUC27dvZ/DgwWRlZbFr1y66du2KlZWVrtzEiRM5efIk/v7+tGjRQteL9tZbb5Gampqj3bzifJxGo2HYsGHcvn0bf39/mjVrhpmZGRqNhn79+uXabmHEx8dja2ubY76cra0txsbGxMXpzzmxts45IdjExKTYx9+6dSuOjo56bQnxrNFkaLgx7QYAridcMTIu+eOQVLaqUi0nREmNGTOGESNG6NYvX76c4wt3UUgyVkGp1Wrd1ZSFpVAoGDFiBCtWrODq1asFlu/fvz8zZ87k2rVr/PXXX9y5c4f+/fvr9ickJHDkyBECAgL0hu3S0tL4999/ixTb465evcrly5cJCgrS6wH8448/it0mgJWVFb/88gtarVYvIbt37x6ZmZk55reVNjMzs3JzOxEhnhaFQoF5G3PdcmkwdzNHVVOV71Clqtaj21wIURZMTU31ppmYmZmVqD25mvIZdefOnVy33759m8TExEL1UPn6+mJqasr27dvZvn079vb2dOrUSa+MVqvN0cMTHh6uN1xZVNkf4E+2u3Xr1hxls8sUpreqQ4cOJCUl8c033+ht37Fjh26/EKJklFWUNF3TlKZrmqKsUjp/YhRGChwC85kTqgCHKQ4yeV9UWNIz9oyaMWMGDx8+pHv37jRt2hSlUsnvv//O559/jlKpZPTo0QW2YWlpyUsvvcT27dtJSEjgrbfeQqn834erhYUFbdu25bPPPsPa2hoHBwfOnDnDtm3bctyAtSgaNWpE/fr1WbRoEVqtFisrK44cOcKJEydylG3WrBkAX3zxBX379sXY2JhGjRrpzfXK1rdvXzZv3szUqVOJjY2lWbNm/Pzzz6xevZrOnTvnuHJUCFF+WPtYwyJy3meslgqHKXKfMVGxSTL2jHrzzTfZt28fX331Ff/88w8pKSnUqFEDNzc3Fi9ejJubW6Ha6d+/P3v27AFyXjQAsGzZMubMmcPChQvJysqidevWbNiwgbfffrvYsatUKj777DPmzJnDhx9+iJGRER07dmTjxo05eubatWvH2LFj+frrr/nqq6/QaDRs2bKFdu3a5WjX1NSULVu2sGTJEj777DMePHhArVq1ePvtt3n33XeLHa8QomxY+1hj5W0ld+AXzxyFtjzcil2IZ9jFixfp3bs3u3btwsXFxdDhGEAzoOA5is+iVy85cTOtcPf3e1ZoUjX8Nvw3AJqtb1ZqQ5UVSX3TVHY4/2roMAykKfCboYMocyX9nJeeMSGEEKVGq9WScjVFtyyEKJgkY0IIIUqN0kRJ408a65aFEAWTZEwIIUSpURgpsGxX/At4hKiM5GuLEEIIIYQBSc+YEEKIUqPN1PLw1EMALNtblsrjkIR41kkyJoQQotRoMjRcn/DoubSl9TgkIZ51kowJIYQoNQqFAjMnM92yEKJgkowJIYQoNcoqSppvam7oMISoUGQCvxBCCCGEAUkyJoQQQghhQJKMCSGEKDWaVA2/jfiN30b8hiZVY+hwhKgQZM6YEEKIUqPVakn6JUm3LIQomCRjQgghSo1SpaTR4ka6ZSFEwSQZE0IIUWoUxgqsulgZOgwhKhT52iKEEEIIYUAGTcbOnTtHcHAwDx8+zLFv8+bNRERE5Nh++vRp1Go1Bw4cKIsQyw21Wk1wcLChwygWPz8//Pz8ilU3r5+DmJgY1Gp1rvuEEIajzdKS8HMCCT8noM0qeM5YdvkHBx8Uuo4QzxqDDlOeP3+ekJAQ+vXrh6Wlpd6+zZs3U6NGDfr372+g6ERpmT17drHr5vVzYGdnR0REBPXr1y9peEKIUqRJ1xA9Ohr4/8chVc37cUhxR+KIWRRDxp0M3TZVTRUOgQ5Y+1g/9ViFKC9kzlgeUlNTMTU1lcd5lEBKSgpVq1alSZMmpd62qakpbm5upd6uEKJkFCio0qiKbjkvcUfiuBF4I8f2jDsZj7YvQhIyUWkYbJgyODiY//znPwB4e3ujVqtRq9WcPn0aLy8voqOjOXPmjG67l5eXXv20tDTmzZuHh4cHTk5ODB48mEuXLumViYqKIiAgAC8vL5ycnPDy8mL8+PHExsbqlYuIiECtVnP8+HHee+893N3dcXZ2Jj09PdfYNRoNK1eupGvXrjg5OdGqVSt69uzJ+vXr9cpdv36d8ePH07ZtWxwdHfH09GTy5MmkpaUBcP/+fWbOnEm3bt1o0aIF7u7uDBkyhJ9++qlQr+Hdu3eZMWMGHTt2pHnz5nh7exMSEkJmZma+9UaPHk2nTp3QaHLeA6hv37706tVLt75p0yYGDRqEu7s7Li4u9OjRg08//ZSMjAy9en5+fnTv3p2zZ8/Sv39/nJ2dee+993T7nhymDAkJoW/fvrRu3RpXV1d69epFeHi43qXw+f0c5DVM+fPPP/P666/TsmVLnJ2d6d+/P0ePHtUrk/1+nzp1ig8//JDnn3+eNm3aMHbsWG7fvq1X9uTJk/j5+dGmTRucnJzw9PRk3LhxpKSk5PsaC1FZadHSbGMzmm1shhYtWSlZOf5lJmYSExSTbzsxi2LITMzMtf7j/4R4FhisZ2zgwIHEx8ezceNGVq1aRc2aNQFo3Lgxq1evxt/fHwsLC90Ql4mJiV79xYsX4+zszIIFC0hISCA4OBg/Pz/27NmjG7qKjY2lUaNGvPLKK1hZWXHnzh3CwsLo06cPhw4dokaNGnptTps2jc6dO7N48WJSUlIwNs795VmzZg0hISG88847uLu7k5mZyfXr10lISNCVuXz5Mq+99hrW1tZMmDCBBg0acPfuXb799lsyMjIwNTXl33//BeDdd9/Fzs6O5ORkvvnmG/z8/Ni0aRPt2rXL8/W7e/cur776KkqlEn9/f+rXr09kZCSffPIJMTExBAUF5Vl3wIABjB49mlOnTtGxY0fd9uvXr/PLL78wc+ZM3babN2/Sq1cvHBwcUKlUXLlyhVWrVvH777+zcOHCHDFNmjSJUaNGMWXKFJTKvHP9mJgYBg8eTJ06dQCIjIxk9uzZ3L59m3fffRegUD8Hjztz5gxDhw6lWbNmLFiwABMTE7Zs2cLIkSNZvnw5r7zyil756dOn07lzZ5YtW8atW7f4z3/+w6RJk9iyZYsuxrfffht3d3f+85//YGlpye3btzl27BgZGRlUrVo1z1hyk5ycrPczYmJigqmpaZHaEKK8+8Xzl1JpJ+NOBlHeUQWWa32udakcT4iiSEtL0+uwSU5OLlF7BkvGateurftD7OzsjIODg26fs7MzpqammJub5zkUVaNGDUJDQ3XDiM8//zwvvPACq1evZsGCBQD06NGDHj166OpkZWXh4+ODh4cHu3fvZtiwYXpttm/fnnnz5hUY+7lz52jWrBnjx4/XbXuy527evHkYGRnx9ddfY2Njo9veu3dv3XKjRo34+OOP9eLr1KkTMTExbNiwId9kLPvCh4MHD+pex44dO1KlShUWLFjAyJEj8xwe7Ny5M7a2tkREROglYxEREZiYmOj1jM2YMUO3rNFocHd3x8rKivfee4/p06dTvXp13f74+HhWrFhBhw4d8ow72+PJokajwcPDA61Wy4YNG/D390ehUBTq5+BxixYtwtLSkrCwMKpVqwaAj48Pr7zyCgsWLODll1/WG3b28vJi1qxZevEvXLiQu3fvYmdnx8WLF0lLS2PatGk4Ojrqyj3++hTF4MGD9dYDAgL0foaEEEJUDKGhoYSEhJRaexV2zlivXr30/rDWrVuX1q1bc/r0ad22pKQkVq5cycGDB4mNjSUr639d2tevX8/RZvfu3Qt17JYtW3L06FFmzpxJ165dcXNzw8LCQrc/JSWFs2fPMmDAAL1ELDdhYWF8+eWXREdH62XZarU633pHjx6lXbt21KxZU29Y0tvbmwULFnD27Nk8kzFjY2N69+7N5s2bSUhIwMLCgqysLHbu3EnXrl2xtv7fPI1Lly4RHBzMuXPniI+P12vnxo0btGrVSrdevXr1QiVi8Gj4b/Xq1URFRZGYmKi37/79+9ja2haqnWzJycn897//ZciQIbpEDMDIyIg+ffoQFBTE77//rve6vvDCC3ptNG/eHHjUo2pnZ4ejoyMmJibMmDGDIUOG4O7uXqILBrZu3aqX1OXXyydERdXiuxbceO/RXLCGCxuiNM3ZQ554PpHrATk/g5+kDlFj3tq81GMUoqTGjBnDiBEjdOuXL1/O8YW7KCpsMmZnZ5djm62tLZcvX9atT5w4kZMnT+Lv70+LFi10CdNbb71FampqjvrZQ6UFGTt2LGZmZuzatYuwsDCMjIxwd3dn6tSptGzZkn///ZesrCzs7e3zbWfdunXMnz8fPz8/Jk6ciLW1NUqlkmXLluWaLD7u3r17fPfddzRr1izX/Q8ePMi3/oABA1i3bh179uzBz8+PH374gTt37tCvXz9dmb///ptBgwbRsGFDPvzwQxwcHDAxMSEqKopZs2bleA0L+/r98ssvDBs2DA8PD+bPn4+9vT0qlYrDhw+zatWqXN+bgvz7779otdpcfy5q1aoFQFxcnN52KysrvfXs5Cj7+M899xwbN25kzZo1fPTRRyQnJ1O/fn3efPNNhg8fXuQYzczM9JJ2IZ5FSlMliT8n6pZzu5rSsp0lqpoqvason6SqpcKynSUKI7mISpQ/pqametNMzMzMStRehU3G7t69m2PbvXv3dH9gExISOHLkCAEBAYwZM0ZXJi0tTTdXq7iMjY156623eOutt3j48CE//vgjixcvZvjw4Zw4cQIrKyuMjIz4559/8m1n165deHh4MGfOHL3tSUlJBcZgbW1N8+bNmTRpUq77sxOQvDRp0gRXV1e2b9+On58f27dvp1atWnTq1ElX5ptvviE5OZnVq1dTt25d3fbHE97i2Lt3L8bGxqxdu1bvh/nw4cPFbrN69eoolcpcfy6yJ+U/OUewMNzd3XF3dycrK4sLFy6wceNG5s6di62tLb6+vsWOV4hnlVKlpMGcBrrl3CiMFDgEOuR6NeWjAuAwxUESMVFpGPSmr0/2RDy5L78ekj179uhdeRcbG8v58+f15llptdocQ0Hh4eF6w5UlZWlpSY8ePXj99deJj48nJiaGKlWq0LZtWw4cOFBgD9WT8V25coXIyMgCj9ulSxeuXr3Kc889R8uWLXP8KygZA+jfvz///e9/+fnnn/nuu+/o27cvRkb/+xabPQz8eIxarZavvvqqwLbzo1AoMDY21pvgn5qays6dO3OULejnIJuZmRmurq4cOnRIr7xGo2HXrl3Y29vTsGHDYsdsZGREq1atdBcSPHnlrhDiEYWxgho9a1CjZw0UxnknU9Y+1jRc1BBVTZXedlUtFQ2DGsptLUSlYtCesewhti+++IK+fftibGxMo0aNMDc3p1mzZuzdu5e9e/dSv359TE1N9Ybk7t+/z5gxYxg0aBAJCQksX74cU1NTXS+YhYUFbdu25bPPPsPa2hoHBwfOnDnDtm3bctxgtqhGjhxJ06ZNadGiBTVq1CA2NpYvvviCunXr0qBBA+DRxPfXXnuNfv36MXr0aJ577jnd0OLcuXMxNzfHx8eHlStXsnz5ctq2bcuNGzdYsWIFDg4OBSaMEydO5Mcff2TAgAEMHTqUhg0bkpaWRmxsLN9//z1z5syhdu3a+bbh6+vLvHnzGD9+POnp6XpDlACenp6YmJgwfvx4Ro0aRVpaGmFhYSXuWezcuTPr1q1j4sSJDBo0iLi4ONauXZvrHKqCfg4eFxgYyNChQxkyZAhvv/02KpWKzZs3c/XqVZYvX17ke8aFhYVx6tQpOnfuTJ06dUhLS9PdSuPxCx+EEMVj7WONlbcViZGJZNzLQGWrwtzNXHrERKVj0GSsXbt2jB07lq+//pqvvvoKjUbDli1baNeuHRMmTNDdRysxMZG6devyww8/6OpOmTKFqKgopk6dSmJiIq6urgQHB/Pcc8/pyixbtow5c+awcOFCsrKyaN26NRs2bODtt98ucdwHDx4kPDycxMREbG1t8fT0xN/fH5Xq0bc8R0dHvv76a4KDg1m8eDFJSUnY2trSvn17XZns+1Vt27aNNWvW0LhxY+bMmcM333zDmTNn8o2hZs2a7Ny5k5UrV/LZZ5/xzz//UK1aNRwcHPDy8tK7yjEvFhYWvPTSS+zevZs2bdrk6DlSq9V88sknLF26lHHjxmFtbY2vry8jRozQm7hYVB06dGDhwoV8+umnjBw5Ent7e1577TVsbGyYNm2aXtmCfg4e5+HhwebNm1m+fDlTp05Fo9Hg6OjImjVr8PHxKXKcjo6OHD9+nODgYO7evUu1atVo2rQpa9as0RvOFUL8jzZLS/KVR5f5mzU3KzCxUhgpsHhe5lKKyk2hfXysTwhR6i5evEjv3r3ZtWsXLi4uhg7HAJoBVw0dhEG8esmJm2lVDB1GmcpKydLda6ygxyE9q+qbprLD+VdDh2EgTYHfDB1EmSvp53yFncAvhBCi/FGgwKS2iW5ZCFEwScaEEEKUGmVVJS57K2MPsBDFZ9CrKYUQQgghKjtJxoQQQgghDEiSMSGEEKVGk6bh+qTrXJ90HU2axtDhCFEhyJwxIYQQpUar0fLvsX91y0KIgkkyJoQQotQojZXUn1FftyyEKJgkY0IIIUqNQqXAtq+tocMQokKRry1CCCGEEAYkPWNCCCFKjVajJfVGKgBVGlZBoZQbvwpREEnGhBBClBpNmobLAy8DlfdxSEIUlSRjQgghSpWxlfxpEaIo5DdGCCFEqTGqakTL71oaOgwhKhSZwC+EEEIIYUCSjAkhhBBCGJAkY8+oiIgI1Go1UVFRhg6FwMBAvLy8DB0GwcHBqNVqvW2bN28mIiLCQBEJUX5os7Qk/JzAg4MPSPg5AW1W8e6er0nTcGPGDW7MuCGPQxKikGTOmHjq/P39GTZsmKHDYODAgTmSws2bN1OjRg369+9voKiEMLy4I3HELIoh406GbpuqpgqHQAesfayL1JZWoyXuYBwA9T+oX6pxCvGskmRMPHXPPfecoUMAoHbt2tSuXdvQYQhRrsQdieNG4I0c2zPuZDzavogiJWRKYyUOkx10y0KIgslvSiWV19BhbkN5arWajz76iIiICLp27YqTkxO9e/cmMjISrVbLmjVr8Pb2pkWLFgwZMoQ//vijwGNlt7ljxw5eeuklnJ2defnllzly5EiOmH7++Wdef/11WrZsibOzM/379+fo0aN6ZVJSUpg/fz7e3t44OjrSunVrevfuze7du/M8Ny8vL6Kjozlz5gxqtRq1Wo2XlxdJSUm0atWKGTNm5IglJiaGJk2asGbNmrxfXCHKUFZKVrH/ZSZmEhMUk2/7MYtiyEzMLHSbmkwNNq/aYPOqDZpMGaYUojCkZ0wUypEjR7h06RKBgYEoFAqCgoJ4++236du3Lzdv3uSjjz4iISGBefPm8c4777B3714UivzvvH306FGioqKYMGECZmZmrFmzhrFjx3L48GHq1380vHHmzBmGDh1Ks2bNWLBgASYmJmzZsoWRI0eyfPlyXnnlFQDmzZvHzp07mTRpEk5OTqSkpHD16lXi4+PzPP7q1avx9/fHwsKC2bNnA2BiYkK1atUYMGAAX375JdOmTcPCwkJXZ/PmzahUKgYMGFDk1zA5OZmEhATduomJCaampkVuR4jH/eL5y1NtP+NOBlHexZ972vpc61KMRojyIS0tjfT0dN16cnJyidqTZEwUSnp6Ohs2bMDMzAwAhULBmDFjOH36NLt379YlXvfv32fu3LlcvXqVZs2a5dtmamoqGzduxNzcHAAXFxfat2/P/v37GTNmDACLFi3C0tKSsLAwqlWrBoCPjw+vvPIKCxYs4OWXX0ahUHDu3Dk8PT0ZMWKErv0uXbrke3xnZ2dMTU0xNzfHzc1Nb98bb7zBF198QUREBMOHDwce/fJFRETg6+uLtXXR5tEADB48WG89ICCA8ePHF7kdIYQQhhUaGkpISEiptSfJmCiUdu3a6RIxgMaNGwPg7e2t1wOWvT02NrbAZKxdu3a6RAzA1tYWGxsbYmNjgUffNP773/8yZMgQXSIGYGRkRJ8+fQgKCuL3339HrVbj6urKrl27CAoKwsvLi1atWlGlSpVin2/9+vXx8fFh8+bNDBs2DIVCwe7du4mLi+ONN94oVptbt27F0dFRt25iYlLs+ITI5nrCtdh1E88ncj3geoHl1CFqzFubF1gOHg2bXnzxIgAuh12KHZsQ5dmYMWP0vvxfvnw5xxfuopBkTBSKlZWV3rpKpQKgevXquW5PS0srsM3cepdMTExITX30kOF///0XrVaLnZ1djnK1atUCIC7u0VVbM2fOxN7enn379vHpp59iampKp06dmDZtGg0bNiwwltwMHTqUN954gxMnTtCpUyc2bdqEm5sbLi7F+wNjZmamN+QpRGkoybMfLdtZoqqp0ruK8kmqWios21miMCr8A7+VVZQljk2I8szU1FRvmsnjnRXFIRP4KylTU1O98e5s2clNeVC9enWUSiV3797Nse/27dsA1KhRA3j0izBhwgQOHz7MmTNn+Pjjj/nvf//LqFGjin38Dh060LRpUzZt2sS5c+e4dOlSsXvFhCiPFEYKHAId8ikADlMcipSIGVU1otWPrWj1YytJxoQoJEnGKikHBwfu37/PvXv3dNvS09P54YcfDBiVPjMzM1xdXTl06JCutwxAo9Gwa9cu7O3tc+31srW1pX///vj6+vL777+TkpKS5zEe74nLzdChQzl69CiLFy/G1taWHj16lOykhChnrH2sabioIaqaKr3tqloqGgY1LPJ9xoQQRSfDlM+4U6dO6eZgPc7Hx4fly5cTEBDAyJEjdRP0NZrydSl6YGAgQ4cOZciQIbz99tuoVCo2b97M1atXWb58uW6+Wt++fenSpQvNmzenevXqXLt2jZ07d+Lm5kbVqlXzbL9Zs2bs3buXvXv3Ur9+fUxNTfXmuvXp04fFixdz9uxZ3nnnHZnnJZ5J1j7WWHlbkRiZSMa9DFS2KszdzIvUIyaEKD5Jxp5xQUFBuW4/duwYoaGhLFmyBH9/f2rWrMmIESN48OBBqV4hUlIeHh5s3ryZ5cuXM3XqVDQaDY6OjqxZswYfHx9dufbt2/Pdd9+xfv16UlJSsLe359VXX2XcuHH5tj9hwgTu3r3LjBkzSExMpG7dunq9g1WqVMHHx4ddu3bh5+f31M5TCENTGCmweL7kcxo16Rr+WvgXAPXeq4fSRAZghCiIQqvVFu8BZEJUAunp6Xh7e/P888+zYsWKYrVx8eJFevfuza5du4o9+b9iawZcNXQQBvHqJSduphX/qt6KKCslS3fvM9cTrpVy3lh901R2OP9q6DAMpCnwm6GDKHMl/ZyXnjEhcnH//n1u3LhBREQE9+7dY/To0YYOSYgKQWGsoPa42rplIUTBJBkTIhdHjx7lvffeo2bNmsyePbtEPVoZGRl6/1cmaWlpJCXF8f8XvYpKQKlSUvsteQZsZfXgQRzVqqVVuqeLlPRzXpIxIXLRv39/+vfvXyptVeZkLD09nfh4ScaEqCzi4+NQqdIlGSsimVkpRDm1adOmp1q+LOuIykOr1ZIRl0FGXAYyJVkURll8DpX3zzpJxoQopzZv3vxUy5dlHVF5aFI1XOh6gQtdL6BJLV+3yhHlU1l8DpX3zzoZphTiKct+NNSNGzeK9MiM1NRULl68+NTKl0Wd5ORk4uJUJCdXzu99yb9ryEzPNHQYZUqTptHdjy/rjyy0ppWvdyzZRMNFbeW8J2FsrBH37l1+qp91xanztI9x48YNoHCPAsyN3NpCiKds+/btTJ061dBhCCGEeMqCgoLo169fketJMibEU/bgwQOOHz+Og4NDpZvUKoQQlUFaWhoxMTF06tRJ98zkopBkTAghhBDCgCrnRA4hhBBCiHJCkjEhhBBCCAOSZEwIIYQQwoAkGRNCCCGEMCBJxoQQQgghDEiSMSGEEEIIA5JkTAghhBDCgCQZE0IIIYQwIEnGhBBCCCEMSB4ULkQZ+/XXX1myZAm//fYbDx48oEqVKjRq1IjXX3+dPn36GDq8p+rkyZPs2rWL8+fPc+vWLSwtLWnRogX+/v60aNHC0OE9VYmJiaxcuZLLly/z66+/8uDBAwICAhg/fryhQys1SUlJLF26lP379xMfH49arWb06NH4+voaOrSnrjK8v7mpzL/TpflZLsmYEGXs4cOH1K5dG19fX2rVqkVKSgq7du1i8uTJxMTE4O/vb+gQn5qwsDDi4uIYNmwYjRs35sGDB6xbt47+/fuzfv16OnToYOgQn5r4+Hi+/PJLHB0d6dq1K+Hh4YYOqdSNGzeOqKgoAgMDadiwIbt372bChAlotVp69epl6PCeqsrw/uamMv9Ol+ZnuTybUohyol+/fty+fZsTJ04YOpSn5t69e9ja2uptS0pKwsfHh6ZNm7Jp0yYDRfb0ZX/UKhQKHjx4gLu7+zPVc3L06FHefvttli1bppd4DR06lOjoaI4fP46RkZEBI3y6nvX3Ny+V+Xc6L8X5LJc5Y0KUE9bW1hgbP9ud1U9+aANUq1aNxo0bc+vWLQNEVHYUCgUKhcLQYTw133zzDdWqVaNnz55627P/MP33v/81TGBl5Fl/f/NSmX+n81Kcz3JJxoQwEI1GQ2ZmJvfv32fz5s0cP36cUaNGGTqsMpeQkMClS5do0qSJoUMRJRAdHY1arc7xR6h58+YAXL161RBhCQOobL/TpfFZ/mx/DReiHJs5cyZbt24FwMTEhJkzZ+Ln52fgqMrerFmzSElJYdy4cYYORZRAXFwc9erVy7HdysoKeDSnSlQOle13ujQ+yyUZE6IETp8+zZAhQwpVds+ePTg5OenWx40bx8CBA7l//z5Hjhzho48+Ijk5mZEjRz6tcEtVSc4929KlS9m1axezZs2qUFdelca5P4vyG6arjEN4lVFF/Z0uidL4LJdkTIgSaNSoEfPnzy9U2Tp16uRYz97WpUsXABYvXkzfvn2xsbEp3UCfgpKcO0BISAiffPIJkydP5s033yzt8J6qkp77s8ja2jrX3q/sbdWrVy/bgESZq8i/0yVRGp/lkowJUQI1a9bktddeK5W2XF1dCQsL46+//qoQyVhJzj0kJITg4GDGjx9fIYcySvN9f1Y0bdqUvXv3kpmZqTdv7LffftPtF8+uiv47XZqK81kuE/iFKCdOnTqFUqnMdd7Ns2TFihUEBwfzzjvvEBAQYOhwRCl56aWXSEpK4uDBg3rbv/76a2rVqkWrVq0ME5h46uR3Wl9xPsulZ0yIMjZ9+nTMzc1xdXXF1taWuLg49u/fz759+xg5cmSF6BUrrrVr17J8+XK8vLzo0qULkZGRevvd3NwMFFnZ+P7770lJSSEpKQmAa9euceDAAQA6d+5M1apVDRleiXTu3BlPT09mzpxJYmIizz33HHv27OGHH35g6dKlz/Q9xrI9y+9vXirz73RpfpbLTV+FKGMRERFERERw/fp1Hj58iJmZGY6OjgwcOPCZfxySn58fZ86cyXP/9evXyzCasufl5UVsbGyu+44dO4aDg0MZR1S6kpKSWLJkCfv37+fff/+lUaNGjBkzplI8Dgme/fc3N5X5d7o0P8slGRNCCCGEMCCZMyaEEEIIYUCSjAkhhBBCGJAkY0IIIYQQBiTJmBBCCCGEAUkyJoQQQghhQJKMCSGEEEIYkCRjQgghhBAGJMmYEEIIIYQBSTImhBAV1Oeff87nn39u6DCEECUkz6YUQohyKDU1lejoaFq0aJHr/rCwMBYtWgRA1apVGTx4cFmG99RER0dTt25dzMzMDB2KEGVGesaEEKKc0Wq1fPTRR9SuXTvX/Tdv3uQ///kPM2fOZObMmSxYsIC//vqrjKN8OurWrcuSJUvQaDSGDkWIMiPPphRCiHJm7dq1WFlZ0b9//xz7NBoNfn5+uqQFYOrUqfz1119s2bIFpbLif8c+duwYP//8M5MnTzZ0KEKUCUnGhBCiHPn7778ZOXIke/fuRaFQGDocgxkyZAj/+c9/qFevnqFDEeKpq/hfoYQQ4hmyYsUKunfvXqkTMYBevXqxdOlSQ4chRJmQnjEhhCgn7t+/j6enJ4cPH8bBwcHQ4RhUYmIiHh4e7Nmzh0aNGhk6HCGeKukZE0KIcuLAgQNYW1tX+kQMwNzcnCZNmrBjxw5DhyLEUyfJmBBClBNHjx7FycmpwHIpKSmEhITw4osv4ujoiKenJ0uXLiUzM7MMoiy7eJycnDh69GgpRVl45e31Fc8+ScaEEKKcOH/+PM2bN8+3zJ07d3j11Vf55JNPaN68OcOGDaNatWp88sknzJkzp4wiLZt4nJyc+O2330hISMizzL1792jSpAmzZ8/Odf8nn3yCWq1GrVbz+++/F3jM8vb6ispBkjEhhCgH7ty5w8OHD7G1tc2zTHp6OiNHjiQmJobNmzezYsUK3nvvPb7++mvq1KnD1q1buX//fpnF/LTjsbGxQaPRcOPGjTzLHD58GI1Gw0svvZRjn1arZdu2bVhaWgLw1VdfGfR8hMiLJGNCCFEO/P3338CjuVJ5Wbt2LRcvXiQwMBB3d3fd9mrVqvHiiy+SlZXFzz///NRjLat4LCwsALh161aeZb755husra1p27Ztjn3Hjx/nr7/+4q233qJJkyZ8/fXXpKenG+x8hMiLJGNCCFEOJCUlAf9LQJ6UmprKZ599hp2dXa6PPrKysgLg7t27Ty3Gso4nOzFNTEzMdX9CQgKnT5/Gx8cHIyOjHPu/+uorFAoFr776Kn379uXBgwccPnw417bK2+srKhdJxoQQohzInhyuUqly3f/NN9/w8OFDevXqhYmJSY792T0+edUvbWURT3bdvCbOHz16lPT0dLp165Zj37179/juu+/w8PCgbt269OnTh/9r735CotriOIB/ryONkwQ1/mlIHDdOlAsXZjJSU6gkpYXNhUAENwOuRJlF7koxoRa1cRWo2GYGHBFXovgvZtQkXAiVhFK4ECbGf0hIRuo4LWTuY965yns6zb3vzfez85w7Z35zNn6559xzDQYD+vr6VMfS2/xScuGLwomIdCAtLQ3A0XeBok8Vrq6uorOzU+ifnZ0FAFy8ePEPVZj4eqJzYTKZVPvHxsZw9uxZ3Lx5U+gbGBjA3t4enE4nACA7Oxs3btzA9PQ0VlZWYLVaE/57iI7CMEZEpANmsxnA0WEsuldpaGjo2HHy8/PjW9gRElFPdC4yMjKEvl+/fmFqagq3b9+G0WiM6YtEIvD5fDCZTLh3757SLssypqam0N/fj8ePH8d8Rm/zS8mFYYyISAesViskSVI9xmFnZwffvn3D5cuXMTIyIvRvb2/j2rVryMrKOvbA2Fu3biEYDP7jmmRZxsuXL+Naj8fjQXd3N9bW1mCz2fD06dOYzfJ/HwcA8vLyhL7p6Wn8+PFD9SnK2dlZrKys4OHDh0hPT1faKysrce7cOQwMDMDtdiM1NfXUv4coHhjGiIh0wGg0Ij8/X/UYh9XVVQBHL5EFAgGEw2GUl5cf+x1Wq1W4i3Sc7Oxs1faT1jM0NISOjg60t7ejuLgYXq8XLpcLo6OjuHTpkjDO8vIyzGazagAaGxvDmTNnUFZWJvRF94XJshzTbjQaUVVVBZ/Ph8nJSWWvWbzml+ikGMaIiHTCbrdjfn5eaI9uHlfbWA4Ag4ODAIBHjx4dO77H4zllhaerp7e3F7Iso7a2FgDQ1taGQCAAr9eLlpYWYZzPnz/DbrcL7eFwGG/fvoXdbheePt3c3MTExAQsFgtKS0uFz8qyDJ/Ph76+PiWMxWt+iU6KT1MSEelEVVUVvnz5IpyFlZWVBUD9WIX5+XkEAgGUlZWhsLAwIXWepJ7d3V0sLCzA4XDEXO9wOFQDKHAYxu7fvy+0z83NYWtrS3WJMnqWmNPpREqK+C+uuLgYeXl5mJmZUZZs9Ta/lHwYxoiIdOL69euw2Wzw+/0x7WazGTabDQsLC1hcXFTag8Eg3G43zp8/j2fPniWszpPUs7W1hXA4LLxhIDMzUzUEffjwAZIkqS5Djo6OIiUlBXfu3BH6+vv7AUB5ilKN0+nEwcGBcq3e5peSD5cpiYh0QpIktLS0wOPxCHd9Ghsb4Xa7UV9fj5qaGuzs7GB4eBiSJKG3t1d1z9WfdNJ6JEmK+TsSiQhtwOHRFA0NDapLh+Pj4ygqKhKC3fv377G8vAyTyYSenp4ja9/Y2FC+o7m5GQaDQXfzS8mFYYyISEccDgfevHmDYDCInJwcpf3BgwfY29tDV1cXvF4vzGYzqqur0dTUBIvFkvA6/209Fy5cgMFgEO6CbW5uCqHq+/fvWFpaQltbmzDOx48fEQqF4HK5hL7ouyd//vyp3PU6TigUgt/vR0VFhe7ml5KLFIlEIloXQUREfwmFQujs7MSLFy+0LiWuZFnGlStX8Pz5c6WtoqICd+/ejdnA39raitraWhQUFAhjvHr1Cq9fv4bf70dubm5C6ib607hnjIhIZywWC+rq6vDu3TutS4krl8uFwcFB+Hw+fP36FR0dHVhbW0NdXZ1yzadPn1BaWqoaxIDDIy2uXr3KIEb/K7wzRkSkU+FwWPUF2P9lHo8HXV1dWF9fh81mw5MnT1BSUqL07+/vK4exEiULhjEiIiIiDXGZkoiIiEhDDGNEREREGmIYIyIiItIQwxgRERGRhhjGiIiIiDTEMEZERESkIYYxIiIiIg0xjBERERFpiGGMiIiISEMMY0REREQaYhgjIiIi0tBvcxIykHEfPM0AAAAASUVORK5CYII=",
-      "text/plain": [
-       "
"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "model, data = cabinetry.model_utils.model_and_data(ws)\n",
-    "fit_results = cabinetry.fit.fit(model, data)\n",
-    "\n",
-    "cabinetry.visualize.pulls(\n",
-    "    fit_results, exclude=\"ttbar_norm\", close_figure=True, save_figure=False\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5587b7a0-ee69-427f-b624-000ccc26ba97",
-   "metadata": {},
-   "source": [
-    "For this pseudodata, what is the resulting ttbar cross-section divided by the Standard Model prediction?"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "id": "280d3998-b3e1-4f0d-b44c-3e7fa84558eb",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "fit result for ttbar_norm: 1.025 +/- 0.014\n"
-     ]
-    }
-   ],
-   "source": [
-    "poi_index = model.config.poi_index\n",
-    "print(f\"\\nfit result for ttbar_norm: {fit_results.bestfit[poi_index]:.3f} +/- {fit_results.uncertainty[poi_index]:.3f}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "81e02bbc-f28b-4115-b8b2-c3a43cb1ccee",
-   "metadata": {},
-   "source": [
-    "Let's also visualize the model before and after the fit, in both the regions we are using.\n",
-    "The binning here corresponds to the binning used for the fit."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "8cf47522-414f-41f0-b3c2-2fed390469ce",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "
"
-      ]
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
      },
-     "execution_count": 19,
      "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "model_prediction = cabinetry.model_utils.prediction(model)\n",
-    "figs = cabinetry.visualize.data_mc(model_prediction, data, close_figure=True)\n",
-    "figs[0][\"figure\"]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "926c416a-e8b7-40b3-8471-9de91d217744",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "
"
-      ]
-     },
-     "execution_count": 20,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "figs[1][\"figure\"]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7d98fed4-5816-4318-8e2a-5a7c520ec294",
-   "metadata": {},
-   "source": [
-    "We can see very good post-fit agreement."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "id": "5bcce96d-32f3-4cb1-9dd0-81ebe63275ed",
-   "metadata": {},
-   "outputs": [
+     "output_type": "display_data"
+    },
     {
      "data": {
-      "image/png": "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",
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
       "text/plain": [
-       "
"
+       "\n"
       ]
      },
-     "execution_count": 21,
      "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "model_prediction_postfit = cabinetry.model_utils.prediction(model, fit_results=fit_results)\n",
-    "figs = cabinetry.visualize.data_mc(model_prediction_postfit, data, close_figure=True)\n",
-    "figs[0][\"figure\"]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "id": "3522f45b-d8b8-4bc8-8ee7-91e6a849b06d",
-   "metadata": {},
-   "outputs": [
+     "output_type": "display_data"
+    },
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "
"
-      ]
-     },
-     "execution_count": 22,
-     "metadata": {},
-     "output_type": "execute_result"
+     "ename": "TypeError",
+     "evalue": "AGCSchema.__init__() takes 2 positional arguments but 3 were given",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[9], line 18\u001b[0m\n\u001b[1;32m     15\u001b[0m filemeta \u001b[38;5;241m=\u001b[39m run\u001b[38;5;241m.\u001b[39mpreprocess(fileset, treename\u001b[38;5;241m=\u001b[39mtreename)  \u001b[38;5;66;03m# pre-processing\u001b[39;00m\n\u001b[1;32m     17\u001b[0m t0 \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mmonotonic()\n\u001b[0;32m---> 18\u001b[0m all_histograms, metrics \u001b[38;5;241m=\u001b[39m \u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfileset\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtreename\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprocessor_instance\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mTtbarAnalysis\u001b[49m\u001b[43m(\u001b[49m\u001b[43mDISABLE_PROCESSING\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mIO_FILE_PERCENT\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# processing\u001b[39;00m\n\u001b[1;32m     19\u001b[0m exec_time \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mmonotonic() \u001b[38;5;241m-\u001b[39m t0\n\u001b[1;32m     21\u001b[0m all_histograms \u001b[38;5;241m=\u001b[39m all_histograms[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhist\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n",
+      "File \u001b[0;32m~/mambaforge/envs/coffea_2023/lib/python3.10/site-packages/coffea/processor/executor.py:1768\u001b[0m, in \u001b[0;36mRunner.__call__\u001b[0;34m(self, fileset, treename, processor_instance)\u001b[0m\n\u001b[1;32m   1747\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\n\u001b[1;32m   1748\u001b[0m     \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m   1749\u001b[0m     fileset: Dict,\n\u001b[1;32m   1750\u001b[0m     treename: \u001b[38;5;28mstr\u001b[39m,\n\u001b[1;32m   1751\u001b[0m     processor_instance: ProcessorABC,\n\u001b[1;32m   1752\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Accumulatable:\n\u001b[1;32m   1753\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"Run the processor_instance on a given fileset\u001b[39;00m\n\u001b[1;32m   1754\u001b[0m \n\u001b[1;32m   1755\u001b[0m \u001b[38;5;124;03m    Parameters\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m   1765\u001b[0m \u001b[38;5;124;03m            An instance of a class deriving from ProcessorABC\u001b[39;00m\n\u001b[1;32m   1766\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[0;32m-> 1768\u001b[0m     wrapped_out \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfileset\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprocessor_instance\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtreename\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1769\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39muse_dataframes:\n\u001b[1;32m   1770\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m wrapped_out  \u001b[38;5;66;03m# not wrapped anymore\u001b[39;00m\n",
+      "File \u001b[0;32m~/mambaforge/envs/coffea_2023/lib/python3.10/site-packages/coffea/processor/executor.py:1927\u001b[0m, in \u001b[0;36mRunner.run\u001b[0;34m(self, fileset, processor_instance, treename)\u001b[0m\n\u001b[1;32m   1922\u001b[0m closure \u001b[38;5;241m=\u001b[39m partial(\n\u001b[1;32m   1923\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mautomatic_retries, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mretries, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mskipbadfiles, closure\n\u001b[1;32m   1924\u001b[0m )\n\u001b[1;32m   1926\u001b[0m executor \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mexecutor\u001b[38;5;241m.\u001b[39mcopy(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mexe_args)\n\u001b[0;32m-> 1927\u001b[0m wrapped_out, e \u001b[38;5;241m=\u001b[39m \u001b[43mexecutor\u001b[49m\u001b[43m(\u001b[49m\u001b[43mchunks\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mclosure\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m   1928\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m wrapped_out \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m   1929\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m   1930\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNo chunks returned results, verify ``processor`` instance structure.\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;130;01m\\\u001b[39;00m\n\u001b[1;32m   1931\u001b[0m \u001b[38;5;124m        if you used skipbadfiles=True, it is possible all your files are bad.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m   1932\u001b[0m     )\n",
+      "File \u001b[0;32m~/mambaforge/envs/coffea_2023/lib/python3.10/site-packages/coffea/processor/executor.py:671\u001b[0m, in \u001b[0;36mIterativeExecutor.__call__\u001b[0;34m(self, items, function, accumulator)\u001b[0m\n\u001b[1;32m    666\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m rich_bar() \u001b[38;5;28;01mas\u001b[39;00m progress:\n\u001b[1;32m    667\u001b[0m     p_id \u001b[38;5;241m=\u001b[39m progress\u001b[38;5;241m.\u001b[39madd_task(\n\u001b[1;32m    668\u001b[0m         \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdesc, total\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mlen\u001b[39m(items), unit\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39munit, disable\u001b[38;5;241m=\u001b[39m\u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstatus\n\u001b[1;32m    669\u001b[0m     )\n\u001b[1;32m    670\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m (\n\u001b[0;32m--> 671\u001b[0m         \u001b[43maccumulate\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    672\u001b[0m \u001b[43m            \u001b[49m\u001b[43mprogress\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrack\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    673\u001b[0m \u001b[43m                \u001b[49m\u001b[38;5;28;43mmap\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mfunction\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43mc\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mc\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mitems\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    674\u001b[0m \u001b[43m                \u001b[49m\u001b[43mtotal\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mitems\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    675\u001b[0m \u001b[43m                \u001b[49m\u001b[43mtask_id\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mp_id\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    676\u001b[0m \u001b[43m            \u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    677\u001b[0m \u001b[43m            \u001b[49m\u001b[43maccumulator\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    678\u001b[0m \u001b[43m        \u001b[49m\u001b[43m)\u001b[49m,\n\u001b[1;32m    679\u001b[0m         \u001b[38;5;241m0\u001b[39m,\n\u001b[1;32m    680\u001b[0m     )\n",
+      "File \u001b[0;32m~/mambaforge/envs/coffea_2023/lib/python3.10/site-packages/coffea/processor/accumulator.py:109\u001b[0m, in \u001b[0;36maccumulate\u001b[0;34m(items, accum)\u001b[0m\n\u001b[1;32m    107\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m    108\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m accum \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 109\u001b[0m         accum \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mnext\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mgen\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    110\u001b[0m         \u001b[38;5;66;03m# we want to produce a new object so that the input is not mutated\u001b[39;00m\n\u001b[1;32m    111\u001b[0m         accum \u001b[38;5;241m=\u001b[39m add(accum, \u001b[38;5;28mnext\u001b[39m(gen))\n",
+      "File \u001b[0;32m~/mambaforge/envs/coffea_2023/lib/python3.10/site-packages/coffea/processor/accumulator.py:106\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m    103\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21maccumulate\u001b[39m(\n\u001b[1;32m    104\u001b[0m     items: Iterable[Optional[Accumulatable]], accum: Optional[Accumulatable] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m    105\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Optional[Accumulatable]:\n\u001b[0;32m--> 106\u001b[0m     gen \u001b[38;5;241m=\u001b[39m (x \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m items \u001b[38;5;28;01mif\u001b[39;00m x \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[1;32m    107\u001b[0m     \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m    108\u001b[0m         \u001b[38;5;28;01mif\u001b[39;00m accum \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n",
+      "File \u001b[0;32m~/mambaforge/envs/coffea_2023/lib/python3.10/site-packages/rich/progress.py:1216\u001b[0m, in \u001b[0;36mProgress.track\u001b[0;34m(self, sequence, total, task_id, description, update_period)\u001b[0m\n\u001b[1;32m   1214\u001b[0m advance \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39madvance\n\u001b[1;32m   1215\u001b[0m refresh \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrefresh\n\u001b[0;32m-> 1216\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m value \u001b[38;5;129;01min\u001b[39;00m sequence:\n\u001b[1;32m   1217\u001b[0m     \u001b[38;5;28;01myield\u001b[39;00m value\n\u001b[1;32m   1218\u001b[0m     advance(task_id, \u001b[38;5;241m1\u001b[39m)\n",
+      "File \u001b[0;32m~/mambaforge/envs/coffea_2023/lib/python3.10/site-packages/coffea/processor/executor.py:1368\u001b[0m, in \u001b[0;36mRunner.automatic_retries\u001b[0;34m(retries, skipbadfiles, func, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1362\u001b[0m         \u001b[38;5;28;01mbreak\u001b[39;00m\n\u001b[1;32m   1363\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[1;32m   1364\u001b[0m         \u001b[38;5;129;01mnot\u001b[39;00m skipbadfiles\n\u001b[1;32m   1365\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28many\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAuth failed\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mstr\u001b[39m(c) \u001b[38;5;28;01mfor\u001b[39;00m c \u001b[38;5;129;01min\u001b[39;00m chain)\n\u001b[1;32m   1366\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m retries \u001b[38;5;241m==\u001b[39m retry_count\n\u001b[1;32m   1367\u001b[0m     ):\n\u001b[0;32m-> 1368\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m e\n\u001b[1;32m   1369\u001b[0m     warnings\u001b[38;5;241m.\u001b[39mwarn(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAttempt \u001b[39m\u001b[38;5;132;01m%d\u001b[39;00m\u001b[38;5;124m of \u001b[39m\u001b[38;5;132;01m%d\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m (retry_count \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m, retries \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m))\n\u001b[1;32m   1370\u001b[0m retry_count \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n",
+      "File \u001b[0;32m~/mambaforge/envs/coffea_2023/lib/python3.10/site-packages/coffea/processor/executor.py:1337\u001b[0m, in \u001b[0;36mRunner.automatic_retries\u001b[0;34m(retries, skipbadfiles, func, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1335\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m retry_count \u001b[38;5;241m<\u001b[39m\u001b[38;5;241m=\u001b[39m retries:\n\u001b[1;32m   1336\u001b[0m     \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1337\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1338\u001b[0m     \u001b[38;5;66;03m# catch xrootd errors and optionally skip\u001b[39;00m\n\u001b[1;32m   1339\u001b[0m     \u001b[38;5;66;03m# or retry to read the file\u001b[39;00m\n\u001b[1;32m   1340\u001b[0m     \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n",
+      "File \u001b[0;32m~/mambaforge/envs/coffea_2023/lib/python3.10/site-packages/coffea/processor/executor.py:1683\u001b[0m, in \u001b[0;36mRunner._work_function\u001b[0;34m(format, xrootdtimeout, mmap, schema, cache_function, use_dataframes, savemetrics, item, processor_instance)\u001b[0m\n\u001b[1;32m   1673\u001b[0m     materialized \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m   1674\u001b[0m     factory \u001b[38;5;241m=\u001b[39m NanoEventsFactory\u001b[38;5;241m.\u001b[39mfrom_root(\n\u001b[1;32m   1675\u001b[0m         file\u001b[38;5;241m=\u001b[39mfile,\n\u001b[1;32m   1676\u001b[0m         treepath\u001b[38;5;241m=\u001b[39mitem\u001b[38;5;241m.\u001b[39mtreename,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m   1681\u001b[0m         permit_dask\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m   1682\u001b[0m     )\n\u001b[0;32m-> 1683\u001b[0m     events \u001b[38;5;241m=\u001b[39m \u001b[43mfactory\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mevents\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m[item\u001b[38;5;241m.\u001b[39mentrystart : item\u001b[38;5;241m.\u001b[39mentrystop]\n\u001b[1;32m   1684\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mformat\u001b[39m \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mparquet\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m   1685\u001b[0m     skyhook_options \u001b[38;5;241m=\u001b[39m {}\n",
+      "File \u001b[0;32m~/mambaforge/envs/coffea_2023/lib/python3.10/site-packages/coffea/nanoevents/factory.py:682\u001b[0m, in \u001b[0;36mNanoEventsFactory.events\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    680\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Build events\"\"\"\u001b[39;00m\n\u001b[1;32m    681\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_is_dask:\n\u001b[0;32m--> 682\u001b[0m     events \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_mapping\u001b[49m\u001b[43m(\u001b[49m\u001b[43mform_mapping\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_schema\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    683\u001b[0m     events\u001b[38;5;241m.\u001b[39mbehavior[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m__original_array__\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m weakref\u001b[38;5;241m.\u001b[39mref(events)\n\u001b[1;32m    684\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m events\n",
+      "File \u001b[0;32m~/mambaforge/envs/coffea_2023/lib/python3.10/site-packages/uproot/_dask.py:206\u001b[0m, in \u001b[0;36mdask\u001b[0;34m(files, filter_name, filter_typename, filter_branch, recursive, full_paths, step_size, library, ak_add_doc, custom_classes, allow_missing, open_files, form_mapping, **options)\u001b[0m\n\u001b[1;32m    191\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m _get_dak_array(\n\u001b[1;32m    192\u001b[0m             files,\n\u001b[1;32m    193\u001b[0m             filter_name,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    203\u001b[0m             form_mapping,\n\u001b[1;32m    204\u001b[0m         )\n\u001b[1;32m    205\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 206\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_get_dak_array_delay_open\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    207\u001b[0m \u001b[43m            \u001b[49m\u001b[43mfiles\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    208\u001b[0m \u001b[43m            \u001b[49m\u001b[43mfilter_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    209\u001b[0m \u001b[43m            \u001b[49m\u001b[43mfilter_typename\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    210\u001b[0m \u001b[43m            \u001b[49m\u001b[43mfilter_branch\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    211\u001b[0m \u001b[43m            \u001b[49m\u001b[43mrecursive\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    212\u001b[0m \u001b[43m            \u001b[49m\u001b[43mfull_paths\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    213\u001b[0m \u001b[43m            \u001b[49m\u001b[43mcustom_classes\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    214\u001b[0m \u001b[43m            \u001b[49m\u001b[43mallow_missing\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    215\u001b[0m \u001b[43m            \u001b[49m\u001b[43mreal_options\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    216\u001b[0m \u001b[43m            \u001b[49m\u001b[43minterp_options\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    217\u001b[0m \u001b[43m            \u001b[49m\u001b[43mform_mapping\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    218\u001b[0m \u001b[43m        \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    219\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    220\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mNotImplementedError\u001b[39;00m()\n",
+      "File \u001b[0;32m~/mambaforge/envs/coffea_2023/lib/python3.10/site-packages/uproot/_dask.py:962\u001b[0m, in \u001b[0;36m_get_dak_array_delay_open\u001b[0;34m(files, filter_name, filter_typename, filter_branch, recursive, full_paths, custom_classes, allow_missing, real_options, interp_options, form_mapping)\u001b[0m\n\u001b[1;32m    951\u001b[0m obj \u001b[38;5;241m=\u001b[39m uproot\u001b[38;5;241m.\u001b[39m_util\u001b[38;5;241m.\u001b[39mregularize_object_path(\n\u001b[1;32m    952\u001b[0m     ffile_path, fobject_path, custom_classes, allow_missing, real_options\n\u001b[1;32m    953\u001b[0m )\n\u001b[1;32m    954\u001b[0m common_keys \u001b[38;5;241m=\u001b[39m obj\u001b[38;5;241m.\u001b[39mkeys(\n\u001b[1;32m    955\u001b[0m     recursive\u001b[38;5;241m=\u001b[39mrecursive,\n\u001b[1;32m    956\u001b[0m     filter_name\u001b[38;5;241m=\u001b[39mfilter_name,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    959\u001b[0m     full_paths\u001b[38;5;241m=\u001b[39mfull_paths,\n\u001b[1;32m    960\u001b[0m )\n\u001b[0;32m--> 962\u001b[0m meta, form \u001b[38;5;241m=\u001b[39m \u001b[43m_get_meta_array\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    963\u001b[0m \u001b[43m    \u001b[49m\u001b[43mawkward\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    964\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdask_awkward\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    965\u001b[0m \u001b[43m    \u001b[49m\u001b[43mobj\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    966\u001b[0m \u001b[43m    \u001b[49m\u001b[43mcommon_keys\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    967\u001b[0m \u001b[43m    \u001b[49m\u001b[43mform_mapping\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    968\u001b[0m \u001b[43m    \u001b[49m\u001b[43minterp_options\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mak_add_doc\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    969\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    971\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m dask_awkward\u001b[38;5;241m.\u001b[39mfrom_map(\n\u001b[1;32m    972\u001b[0m     _UprootOpenAndRead(\n\u001b[1;32m    973\u001b[0m         custom_classes,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    985\u001b[0m     meta\u001b[38;5;241m=\u001b[39mmeta,\n\u001b[1;32m    986\u001b[0m )\n",
+      "File \u001b[0;32m~/mambaforge/envs/coffea_2023/lib/python3.10/site-packages/uproot/_dask.py:782\u001b[0m, in \u001b[0;36m_get_meta_array\u001b[0;34m(awkward, dask_awkward, ttree, common_keys, form_mapping, ak_add_doc)\u001b[0m\n\u001b[1;32m    779\u001b[0m form \u001b[38;5;241m=\u001b[39m awkward\u001b[38;5;241m.\u001b[39mforms\u001b[38;5;241m.\u001b[39mRecordForm(contents, common_keys, parameters\u001b[38;5;241m=\u001b[39mparameters)\n\u001b[1;32m    781\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m form_mapping \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 782\u001b[0m     form \u001b[38;5;241m=\u001b[39m \u001b[43mform_mapping\u001b[49m\u001b[43m(\u001b[49m\u001b[43mform\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    784\u001b[0m empty_arr \u001b[38;5;241m=\u001b[39m form\u001b[38;5;241m.\u001b[39mlength_zero_array(\n\u001b[1;32m    785\u001b[0m     behavior\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01mif\u001b[39;00m form_mapping \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m form_mapping\u001b[38;5;241m.\u001b[39mbehavior\n\u001b[1;32m    786\u001b[0m )\n\u001b[1;32m    788\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m dask_awkward\u001b[38;5;241m.\u001b[39mcore\u001b[38;5;241m.\u001b[39mtypetracer_array(empty_arr), form\n",
+      "File \u001b[0;32m~/mambaforge/envs/coffea_2023/lib/python3.10/site-packages/coffea/nanoevents/factory.py:127\u001b[0m, in \u001b[0;36m_map_schema_uproot.__call__\u001b[0;34m(self, form)\u001b[0m\n\u001b[1;32m    114\u001b[0m     branch_forms[field] \u001b[38;5;241m=\u001b[39m _lazify_form(\n\u001b[1;32m    115\u001b[0m         iform, \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfield\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m,!load\u001b[39m\u001b[38;5;124m\"\u001b[39m, docstr\u001b[38;5;241m=\u001b[39miform[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mparameters\u001b[39m\u001b[38;5;124m\"\u001b[39m][\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m__doc__\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m    116\u001b[0m     )\n\u001b[1;32m    117\u001b[0m lform \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m    118\u001b[0m     \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mclass\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mRecordArray\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m    119\u001b[0m     \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcontents\u001b[39m\u001b[38;5;124m\"\u001b[39m: [item \u001b[38;5;28;01mfor\u001b[39;00m item \u001b[38;5;129;01min\u001b[39;00m branch_forms\u001b[38;5;241m.\u001b[39mvalues()],\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    125\u001b[0m     \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mform_key\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m    126\u001b[0m }\n\u001b[0;32m--> 127\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m awkward\u001b[38;5;241m.\u001b[39mforms\u001b[38;5;241m.\u001b[39mform\u001b[38;5;241m.\u001b[39mfrom_dict(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mschemaclass\u001b[49m\u001b[43m(\u001b[49m\u001b[43mlform\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mversion\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mform)\n",
+      "\u001b[0;31mTypeError\u001b[0m: AGCSchema.__init__() takes 2 positional arguments but 3 were given"
+     ]
     }
    ],
    "source": [
-    "figs[1][\"figure\"]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "8391cff7",
-   "metadata": {},
-   "source": [
-    "### What is next?\n",
+    "if __name__ == \"__main__\":\n",
+    "    NanoAODSchema.warn_missing_crossrefs = False # silences warnings about branches we will not use here\n",
+    "    if USE_DASK:\n",
+    "        executor = processor.DaskExecutor(client=utils.get_client(AF))\n",
+    "    else:\n",
+    "        # executor = processor.FuturesExecutor(workers=NUM_CORES)\n",
+    "        executor = processor.IterativeExecutor()\n",
+    "\n",
+    "    run = processor.Runner(executor=executor, schema=NanoAODSchema, savemetrics=True, metadata_cache={}, chunksize=CHUNKSIZE)\n",
+    "\n",
+    "    if USE_SERVICEX:\n",
+    "        treename = \"servicex\"\n",
+    "\n",
+    "    else:\n",
+    "        treename = \"Events\"\n",
+    "\n",
+    "    filemeta = run.preprocess(fileset, treename=treename)  # pre-processing\n",
     "\n",
-    "Our next goals for this pipeline demonstration are:\n",
-    "- making this analysis even **more feature-complete**,\n",
-    "- **addressing performance bottlenecks** revealed by this demonstrator,\n",
-    "- **collaborating** with you!\n",
+    "    t0 = time.monotonic()\n",
+    "    all_histograms, metrics = run(fileset, treename, processor_instance=TtbarAnalysis(DISABLE_PROCESSING, IO_FILE_PERCENT))  # processing\n",
+    "    breakpoint()\n",
+    "    exec_time = time.monotonic() - t0\n",
     "\n",
-    "Please do not hesitate to get in touch if you would like to join the effort, or are interested in re-implementing (pieces of) the pipeline with different tools!\n",
+    "    all_histograms = all_histograms[\"hist\"]\n",
     "\n",
-    "Our mailing list is analysis-grand-challenge@iris-hep.org, sign up via the [Google group](https://groups.google.com/a/iris-hep.org/g/analysis-grand-challenge)."
+    "    print(f\"\\nexecution took {exec_time:.2f} seconds\")"
    ]
   }
  ],
@@ -1135,7 +723,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.13"
+   "version": "3.10.10"
   }
  },
  "nbformat": 4,
diff --git a/analyses/cms-open-data-ttbar/ttbar_analysis_pipeline.py b/analyses/cms-open-data-ttbar/ttbar_analysis_pipeline.py
index ddf6a1b8..8034657b 100644
--- a/analyses/cms-open-data-ttbar/ttbar_analysis_pipeline.py
+++ b/analyses/cms-open-data-ttbar/ttbar_analysis_pipeline.py
@@ -6,7 +6,26 @@
 #       extension: .py
 #       format_name: percent
 #       format_version: '1.3'
-#       jupytext_version: 1.14.4
+#       jupytext_version: 1.14.5
+#   kernelspec:
+#     display_name: Python 3 (ipykernel)
+#     language: python
+#     name: python3
+# ---
+
+# %%
+import warnings
+warnings.filterwarnings("error")
+
+# ---
+# jupyter:
+#   jupytext:
+#     formats: ipynb,py:percent
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.14.5
 #   kernelspec:
 #     display_name: Python 3 (ipykernel)
 #     language: python
@@ -47,13 +66,13 @@
 import time
 
 import awkward as ak
-import cabinetry
+# import cabinetry
 from coffea import processor
-from coffea.nanoevents import transforms
-from coffea.nanoevents.methods import base, vector
-from coffea.nanoevents.schemas.base import BaseSchema, zip_forms
-from func_adl import ObjectStream
-from func_adl_servicex import ServiceXSourceUpROOT
+from coffea.nanoevents import NanoAODSchema
+# from servicex import ServiceXDataset
+# from func_adl import ObjectStream
+# from func_adl_servicex import ServiceXSourceUpROOT
+
 import hist
 import json
 import matplotlib.pyplot as plt
@@ -62,7 +81,7 @@
 
 import utils  # contains code for bookkeeping and cosmetics, as well as some boilerplate
 
-logging.getLogger("cabinetry").setLevel(logging.INFO)
+# logging.getLogger("cabinetry").setLevel(logging.INFO)
 
 # %% [markdown]
 # ### Configuration: number of files and data delivery path
@@ -76,25 +95,26 @@
 #
 # | setting | number of files | total size |
 # | --- | --- | --- |
-# | `1` | 9 | 16.3 GB |
-# | `5` | 45 | 81.7 GB |
-# | `10` | 86 | 157 GB |
-# | `50` | 357 | 678 GB |
-# | `100` | 590 | 1.09 TB |
-# | `500` | 1542 | 2.58 TB |
-# | `1000` | 2249 | 3.57 TB |
-# | `-1` | 2269 | 3.59 TB |
+# | `1` | 12 | 25.1 GB |
+# | `2` | 24 | 46.5 GB |
+# | `5` | 52 | 110 GB |
+# | `10` | 88 | 205 GB |
+# | `20` | 149 | 364 GB |
+# | `50` | 264 | 636 GB |
+# | `100` | 404 | 965 GB |
+# | `200` | 604 | 1.40 TB |
+# | `-1` | 796 | 1.78 TB |
 #
-# The input files are all in the 1–2 GB range.
+# The input files are all in the 1–3 GB range.
 
 # %%
 ### GLOBAL CONFIGURATION
 
 # input files per process, set to e.g. 10 (smaller number = faster)
-N_FILES_MAX_PER_SAMPLE = 5
+N_FILES_MAX_PER_SAMPLE = 1
 
 # enable Dask
-USE_DASK = True
+USE_DASK = False
 
 # enable ServiceX
 USE_SERVICEX = False
@@ -123,9 +143,8 @@
 DISABLE_PROCESSING = False
 
 # read additional branches (only with DISABLE_PROCESSING = True)
-# acceptable values are 4, 15, 25, 50 (corresponding to % of file read), 4% corresponds to the standard branches used in the notebook
-IO_FILE_PERCENT = 4
-
+# acceptable values are 2.7, 4, 15, 25, 50 (corresponding to % of file read), 2.7% corresponds to the standard branches used in the notebook
+IO_FILE_PERCENT = 2.7
 
 # %% [markdown]
 # ### Defining our `coffea` Processor
@@ -136,7 +155,11 @@
 # - calculating systematic uncertainties at the event and object level,
 # - filling all the information into histograms that get aggregated and ultimately returned to us by `coffea`.
 
-# %% tags=[]
+# %%
+import hist.dask
+import dask_awkward as dak
+
+
 # functions creating systematic variations
 def flat_variation(ones):
     # 2.5% weight variations
@@ -145,15 +168,15 @@ def flat_variation(ones):
 
 def btag_weight_variation(i_jet, jet_pt):
     # weight variation depending on i-th jet pT (7.5% as default value, multiplied by i-th jet pT / 50 GeV)
-    return 1 + np.array([0.075, -0.075]) * (ak.singletons(jet_pt[:, i_jet]) / 50).to_numpy()
+    return 1 + np.array([0.075, -0.075]) * (dak.singletons(jet_pt[:, i_jet]) / 50).to_numpy()
 
 
 def jet_pt_resolution(pt):
     # normal distribution with 5% variations, shape matches jets
-    counts = ak.num(pt)
-    pt_flat = ak.flatten(pt)
-    resolution_variation = np.random.normal(np.ones_like(pt_flat), 0.05)
-    return ak.unflatten(resolution_variation, counts)
+    counts = dak.num(pt)
+    pt_flat = dak.flatten(pt)
+    resolution_variation = np.random.normal(dak.ones_like(pt_flat), 0.05)
+    return dak.unflatten(resolution_variation, counts)
 
 
 class TtbarAnalysis(processor.ProcessorABC):
@@ -164,7 +187,7 @@ def __init__(self, disable_processing, io_file_percent):
         name = "observable"
         label = "observable [GeV]"
         self.hist = (
-            hist.Hist.new.Reg(num_bins, bin_low, bin_high, name=name, label=label)
+            hist.dask.Hist.new.Reg(num_bins, bin_low, bin_high, name=name, label=label)
             .StrCat(["4j1b", "4j2b"], name="region", label="Region")
             .StrCat([], name="process", label="Process", growth=True)
             .StrCat([], name="variation", label="Systematic variation", growth=True)
@@ -174,25 +197,48 @@ def __init__(self, disable_processing, io_file_percent):
         self.io_file_percent = io_file_percent
 
     def only_do_IO(self, events):
-        # standard AGC branches cover 4% of the data
-            branches_to_read = ["jet_pt", "jet_eta", "jet_phi", "jet_btag", "jet_e", "muon_pt", "electron_pt"]
-            if self.io_file_percent not in [4, 15, 25, 50]:
-                raise NotImplementedError("supported values for I/O percentage are 4, 15, 25, 50")
-            if self.io_file_percent >= 15:
-                branches_to_read += ["trigobj_e"]
-            if self.io_file_percent >= 25:
-                branches_to_read += ["trigobj_pt"]
-            if self.io_file_percent >= 50:
-                branches_to_read += ["trigobj_eta", "trigobj_phi", "jet_px", "jet_py", "jet_pz", "jet_ch"]
+        # standard AGC branches cover 2.7% of the data
+            branches_to_read = []
+            if self.io_file_percent >= 2.7:
+                branches_to_read.extend(["Jet_pt", "Jet_eta", "Jet_phi", "Jet_btagCSVV2", "Jet_mass", "Muon_pt", "Electron_pt"])
+
+            if self.io_file_percent >= 4:
+                branches_to_read.extend(["Electron_phi", "Electron_eta","Electron_mass","Muon_phi","Muon_eta","Muon_mass",
+                                         "Photon_pt","Photon_eta","Photon_mass","Jet_jetId"])
+
+            if self.io_file_percent>=15:
+                branches_to_read.extend(["Jet_nConstituents","Jet_electronIdx1","Jet_electronIdx2","Jet_muonIdx1","Jet_muonIdx2",
+                                         "Jet_chHEF","Jet_area","Jet_puId","Jet_qgl","Jet_btagDeepB","Jet_btagDeepCvB",
+                                         "Jet_btagDeepCvL","Jet_btagDeepFlavB","Jet_btagDeepFlavCvB","Jet_btagDeepFlavCvL",
+                                         "Jet_btagDeepFlavQG","Jet_chEmEF","Jet_chFPV0EF","Jet_muEF","Jet_muonSubtrFactor",
+                                         "Jet_neEmEF","Jet_neHEF","Jet_puIdDisc"])
+
+            if self.io_file_percent>=25:
+                branches_to_read.extend(["GenPart_pt","GenPart_eta","GenPart_phi","GenPart_mass","GenPart_genPartIdxMother",
+                                         "GenPart_pdgId","GenPart_status","GenPart_statusFlags"])
+
+            if self.io_file_percent==50:
+                branches_to_read.extend(["Jet_rawFactor","Jet_bRegCorr","Jet_bRegRes","Jet_cRegCorr","Jet_cRegRes","Jet_nElectrons",
+                                         "Jet_nMuons","GenJet_pt","GenJet_eta","GenJet_phi","GenJet_mass","Tau_pt","Tau_eta","Tau_mass",
+                                         "Tau_phi","Muon_dxy","Muon_dxyErr","Muon_dxybs","Muon_dz","Muon_dzErr","Electron_dxy",
+                                         "Electron_dxyErr","Electron_dz","Electron_dzErr","Electron_eInvMinusPInv","Electron_energyErr",
+                                         "Electron_hoe","Electron_ip3d","Electron_jetPtRelv2","Electron_jetRelIso",
+                                         "Electron_miniPFRelIso_all","Electron_miniPFRelIso_chg","Electron_mvaFall17V2Iso",
+                                         "Electron_mvaFall17V2noIso","Electron_pfRelIso03_all","Electron_pfRelIso03_chg","Electron_r9",
+                                         "Electron_scEtOverPt","Electron_sieie","Electron_sip3d","Electron_mvaTTH","Electron_charge",
+                                         "Electron_cutBased","Electron_jetIdx","Electron_pdgId","Electron_photonIdx","Electron_tightCharge"])
+
+            if self.io_file_percent not in [2.7, 4, 15, 25, 50]:
+                raise NotImplementedError("supported values for I/O percentage are 2.7, 4, 15, 25, 50")
 
             for branch in branches_to_read:
                 if "_" in branch:
-                    object_type, property_name = branch.split("_")
-                    if property_name == "e":
-                        property_name = "energy"
-                    ak.materialized(events[object_type][property_name])
+                    split = branch.split("_")
+                    object_type = split[0]
+                    property_name = '_'.join(split[1:])
+                    dak.materialized(events[object_type][property_name])
                 else:
-                    ak.materialized(events[branch])
+                    dak.materialized(events[branch])
             return {"hist": {}}
 
     def process(self, events):
@@ -216,16 +262,17 @@ def process(self, events):
 
         #### systematics
         # example of a simple flat weight variation, using the coffea nanoevents systematics feature
-        if process == "wjets":
-            events.add_systematic("scale_var", "UpDownSystematic", "weight", flat_variation)
+        # if process == "wjets":
+        #     events.add_systematic("scale_var", "UpDownSystematic", "weight", flat_variation)
 
         # jet energy scale / resolution systematics
         # need to adjust schema to instead use coffea add_systematic feature, especially for ServiceX
         # cannot attach pT variations to events.jet, so attach to events directly
         # and subsequently scale pT by these scale factors
-        events["pt_nominal"] = 1.0
-        events["pt_scale_up"] = 1.03
-        events["pt_res_up"] = jet_pt_resolution(events.jet.pt)
+        events["pt_nominal"] = dak.ones_like(events.MET.pt)
+        events["pt_scale_up"] = dak.ones_like(events.MET.pt)*1.03
+        events["pt_res_up"] = dak.ones_like(events.MET.pt) #jet_pt_resolution(events.Jet.pt)
+
 
         pt_variations = ["pt_nominal", "pt_scale_up", "pt_res_up"] if variation == "nominal" else ["pt_nominal"]
         for pt_var in pt_variations:
@@ -234,19 +281,19 @@ def process(self, events):
             # very very loosely based on https://arxiv.org/abs/2006.13076
 
             # pT > 25 GeV for leptons & jets
-            selected_electrons = events.electron[events.electron.pt > 25]
-            selected_muons = events.muon[events.muon.pt > 25]
-            jet_filter = events.jet.pt * events[pt_var] > 25  # pT > 25 GeV for jets (scaled by systematic variations)
-            selected_jets = events.jet[jet_filter]
+            selected_electrons = events.Electron[(events.Electron.pt>25)]
+            selected_muons = events.Muon[(events.Muon.pt >25)]
+            jet_filter = (events.Jet.pt * events[pt_var]) > 25
+            selected_jets = events.Jet[jet_filter]
 
             # single lepton requirement
-            event_filters = ((ak.count(selected_electrons.pt, axis=1) + ak.count(selected_muons.pt, axis=1)) == 1)
+            event_filters = ((dak.count(selected_electrons.pt, axis=1) + dak.count(selected_muons.pt, axis=1)) == 1)
             # at least four jets
-            pt_var_modifier = events[pt_var] if "res" not in pt_var else events[pt_var][jet_filter]
-            event_filters = event_filters & (ak.count(selected_jets.pt * pt_var_modifier, axis=1) >= 4)
+            pt_var_modifier = dak.ones_like(selected_jets.pt)  # events[pt_var] if "res" not in pt_var else events[pt_var][jet_filter]
+            event_filters = event_filters & (dak.count(selected_jets.pt * pt_var_modifier, axis=1) >= 4)
             # at least one b-tagged jet ("tag" means score above threshold)
             B_TAG_THRESHOLD = 0.5
-            event_filters = event_filters & (ak.sum(selected_jets.btag >= B_TAG_THRESHOLD, axis=1) >= 1)
+            event_filters = event_filters & (dak.sum(selected_jets.btagCSVV2 >= B_TAG_THRESHOLD, axis=1) >= 1)
 
             # apply event filters
             selected_events = events[event_filters]
@@ -257,41 +304,41 @@ def process(self, events):
             for region in ["4j1b", "4j2b"]:
                 # further filtering: 4j1b CR with single b-tag, 4j2b SR with two or more tags
                 if region == "4j1b":
-                    region_filter = ak.sum(selected_jets.btag >= B_TAG_THRESHOLD, axis=1) == 1
+                    region_filter = dak.sum(selected_jets.btagCSVV2 >= B_TAG_THRESHOLD, axis=1) == 1
                     selected_jets_region = selected_jets[region_filter]
                     # use HT (scalar sum of jet pT) as observable
                     pt_var_modifier = (
                         events[event_filters][region_filter][pt_var]
-                        if "res" not in pt_var
-                        else events[pt_var][jet_filter][event_filters][region_filter]
+                        # if "res" not in pt_var
+                        # else events[pt_var][jet_filter][event_filters][region_filter]
                     )
-                    observable = ak.sum(selected_jets_region.pt * pt_var_modifier, axis=-1)
+                    observable = dak.sum(selected_jets_region.pt * pt_var_modifier, axis=-1)
 
                 elif region == "4j2b":
-                    region_filter = ak.sum(selected_jets.btag > B_TAG_THRESHOLD, axis=1) >= 2
+                    region_filter = dak.sum(selected_jets.btagCSVV2 > B_TAG_THRESHOLD, axis=1) >= 2
                     selected_jets_region = selected_jets[region_filter]
 
                     # reconstruct hadronic top as bjj system with largest pT
                     # the jet energy scale / resolution effect is not propagated to this observable at the moment
-                    trijet = ak.combinations(selected_jets_region, 3, fields=["j1", "j2", "j3"])  # trijet candidates
+                    trijet = dak.combinations(selected_jets_region, 3, fields=["j1", "j2", "j3"])  # trijet candidates
                     trijet["p4"] = trijet.j1 + trijet.j2 + trijet.j3  # calculate four-momentum of tri-jet system
-                    trijet["max_btag"] = np.maximum(trijet.j1.btag, np.maximum(trijet.j2.btag, trijet.j3.btag))
+                    trijet["max_btag"] = np.maximum(trijet.j1.btagCSVV2, np.maximum(trijet.j2.btagCSVV2, trijet.j3.btagCSVV2))
                     trijet = trijet[trijet.max_btag > B_TAG_THRESHOLD]  # at least one-btag in trijet candidates
                     # pick trijet candidate with largest pT and calculate mass of system
-                    trijet_mass = trijet["p4"][ak.argmax(trijet.p4.pt, axis=1, keepdims=True)].mass
-                    observable = ak.flatten(trijet_mass)
+                    trijet_mass = trijet["p4"][dak.argmax(trijet.p4.pt, axis=1, keepdims=True)].mass
+                    observable = dak.flatten(trijet_mass)
 
                 ### histogram filling
                 if pt_var == "pt_nominal":
                     # nominal pT, but including 2-point systematics
                     histogram.fill(
                             observable=observable, region=region, process=process,
-                            variation=variation, weight=xsec_weight
+                            variation=variation, weight=dak.ones_like(observable)*xsec_weight
                         )
 
                     if variation == "nominal":
                         # also fill weight-based variations for all nominal samples
-                        for weight_name in events.systematics.fields:
+                        for weight_name in []: # events.systematics.fields:
                             for direction in ["up", "down"]:
                                 # extract the weight variations and apply all event & region filters
                                 weight_variation = events.systematics[weight_name][direction][
@@ -299,7 +346,7 @@ def process(self, events):
                                 # fill histograms
                                 histogram.fill(
                                     observable=observable, region=region, process=process,
-                                    variation=f"{weight_name}_{direction}", weight=xsec_weight*weight_variation
+                                    variation=f"{weight_name}_{direction}", weight=dak.ones_like(observable)*xsec_weight*weight_variation
                                 )
 
                         # calculate additional systematics: b-tagging variations
@@ -307,19 +354,19 @@ def process(self, events):
                             for i_dir, direction in enumerate(["up", "down"]):
                                 # create systematic variations that depend on object properties (here: jet pT)
                                 if len(observable):
-                                    weight_variation = btag_weight_variation(i_var, selected_jets_region.pt)[:, i_dir]
+                                    weight_variation = dak.ones_like(observable) #btag_weight_variation(i_var, selected_jets_region.pt)[:, i_dir]
                                 else:
                                     weight_variation = 1 # no events selected
                                 histogram.fill(
                                     observable=observable, region=region, process=process,
-                                    variation=f"{weight_name}_{direction}", weight=xsec_weight*weight_variation
+                                    variation=f"{weight_name}_{direction}", weight=dak.ones_like(observable)*xsec_weight*weight_variation
                                 )
 
                 elif variation == "nominal":
                     # pT variations for nominal samples
                     histogram.fill(
                             observable=observable, region=region, process=process,
-                            variation=pt_var, weight=xsec_weight
+                            variation=pt_var, weight=dak.ones_like(observable)*xsec_weight
                         )
 
         output = {"nevents": {events.metadata["dataset"]: len(events)}, "hist": histogram}
@@ -330,52 +377,12 @@ def postprocess(self, accumulator):
         return accumulator
 
 
-# %% [markdown]
-# ### AGC `coffea` schema
-#
-# When using `coffea`, we can benefit from the schema functionality to group columns into convenient objects.
-# This schema is taken from [mat-adamec/agc_coffea](https://github.com/mat-adamec/agc_coffea).
-
-# %% tags=[]
-class AGCSchema(BaseSchema):
-    def __init__(self, base_form):
-        super().__init__(base_form)
-        self._form["contents"] = self._build_collections(self._form["contents"])
-
-    def _build_collections(self, branch_forms):
-        names = set([k.split('_')[0] for k in branch_forms.keys() if not (k.startswith('number'))])
-        # Remove n(names) from consideration. It's safe to just remove names that start with n, as nothing else begins with n in our fields.
-        # Also remove GenPart, PV and MET because they deviate from the pattern of having a 'number' field.
-        names = [k for k in names if not (k.startswith('n') | k.startswith('met') | k.startswith('GenPart') | k.startswith('PV'))]
-        output = {}
-        for name in names:
-            offsets = transforms.counts2offsets_form(branch_forms['number' + name])
-            content = {k[len(name)+1:]: branch_forms[k] for k in branch_forms if (k.startswith(name + "_") & (k[len(name)+1:] != 'e'))}
-            # Add energy separately so its treated correctly by the p4 vector.
-            content['energy'] = branch_forms[name+'_e']
-            # Check for LorentzVector
-            output[name] = zip_forms(content, name, 'PtEtaPhiELorentzVector', offsets=offsets)
-
-        # Handle GenPart, PV, MET. Note that all the nPV_*'s should be the same. We just use one.
-        #output['met'] = zip_forms({k[len('met')+1:]: branch_forms[k] for k in branch_forms if k.startswith('met_')}, 'met')
-        #output['GenPart'] = zip_forms({k[len('GenPart')+1:]: branch_forms[k] for k in branch_forms if k.startswith('GenPart_')}, 'GenPart', offsets=transforms.counts2offsets_form(branch_forms['numGenPart']))
-        #output['PV'] = zip_forms({k[len('PV')+1:]: branch_forms[k] for k in branch_forms if (k.startswith('PV_') & ('npvs' not in k))}, 'PV', offsets=transforms.counts2offsets_form(branch_forms['nPV_x']))
-        return output
-
-    @property
-    def behavior(self):
-        behavior = {}
-        behavior.update(base.behavior)
-        behavior.update(vector.behavior)
-        return behavior
-
-
 # %% [markdown]
 # ### "Fileset" construction and metadata
 #
 # Here, we gather all the required information about the files we want to process: paths to the files and asociated metadata.
 
-# %% tags=[]
+# %%
 fileset = utils.construct_fileset(N_FILES_MAX_PER_SAMPLE, use_xcache=False, af_name=AF_NAME)  # local files on /data for ssl-dev
 
 print(f"processes in fileset: {list(fileset.keys())}")
@@ -383,44 +390,33 @@ def behavior(self):
 print(f"  'metadata': {fileset['ttbar__nominal']['metadata']}\n}}")
 
 
+# %%
+fileset = {"ttbar__nominal": fileset["ttbar__nominal"]}
+
 # %% [markdown]
 # ### ServiceX-specific functionality: query setup
 #
 # Define the func_adl query to be used for the purpose of extracting columns and filtering.
 
 # %%
-def get_query(source: ObjectStream) -> ObjectStream:
-    """Query for event / column selection: >=4j >=1b, ==1 lep with pT>25 GeV, return relevant columns
-    """
-    return source.Where(lambda e:
-        # == 1 lep
-        e.electron_pt.Where(lambda pT: pT > 25).Count() + e.muon_pt.Where(lambda pT: pT > 25).Count()== 1
-        )\
-        .Where(lambda e:\
-            # >= 4 jets
-            e.jet_pt.Where(lambda pT: pT > 25).Count() >= 4
-        )\
-        .Where(lambda e:\
-            # >= 1 jet with pT > 25 GeV and b-tag >= 0.5
-            {"pT": e.jet_pt, "btag": e.jet_btag}.Zip().Where(lambda jet: jet.btag >= 0.5 and jet.pT > 25).Count() >= 1
-        )\
-        .Select(lambda e:\
-            # return columns
-            {
-                "electron_e": e.electron_e,
-                "electron_pt": e.electron_pt,
-                "muon_e": e.muon_e,
-                "muon_pt": e.muon_pt,
-                "jet_e": e.jet_e,
-                "jet_pt": e.jet_pt,
-                "jet_eta": e.jet_eta,
-                "jet_phi": e.jet_phi,
-                "jet_btag": e.jet_btag,
-                "numbermuon": e.numbermuon,
-                "numberelectron": e.numberelectron,
-                "numberjet": e.numberjet,
-            }
-        )
+# def get_query(source: ObjectStream) -> ObjectStream:
+#     """Query for event / column selection: >=4j >=1b, ==1 lep with pT>25 GeV, return relevant columns
+#     """
+#     return source.Where(lambda e: e.Electron_pt.Where(lambda pt: pt > 25).Count()
+#                         + e.Muon_pt.Where(lambda pt: pt > 25).Count() == 1)\
+#                  .Where(lambda e: e.Jet_pt.Where(lambda pt: pt > 25).Count() >= 4)\
+#                  .Where(lambda g: {"pt": g.Jet_pt,
+#                                    "btagCSVV2": g.Jet_btagCSVV2}.Zip().Where(lambda jet:
+#                                                                              jet.btagCSVV2 >= 0.5 
+#                                                                              and jet.pt > 25).Count() >= 1)\
+#                  .Select(lambda f: {"Electron_pt": f.Electron_pt,
+#                                     "Muon_pt": f.Muon_pt,
+#                                     "Jet_mass": f.Jet_mass,
+#                                     "Jet_pt": f.Jet_pt,
+#                                     "Jet_eta": f.Jet_eta,
+#                                     "Jet_phi": f.Jet_phi,
+#                                     "Jet_btagCSVV2": f.Jet_btagCSVV2,
+#                                    })
 
 
 # %% [markdown]
@@ -430,8 +426,9 @@ def get_query(source: ObjectStream) -> ObjectStream:
 
 # %%
 if USE_SERVICEX:
+
     # dummy dataset on which to generate the query
-    dummy_ds = ServiceXSourceUpROOT("cernopendata://dummy", "events", backend_name="uproot")
+    dummy_ds = ServiceXSourceUpROOT("cernopendata://dummy", "Events", backend_name="uproot")
 
     # tell low-level infrastructure not to contact ServiceX yet, only to
     # return the qastle string it would have sent
@@ -440,16 +437,22 @@ def get_query(source: ObjectStream) -> ObjectStream:
     # create the query
     query = get_query(dummy_ds).value()
 
-    # now we query the files using a wrapper around ServiceXDataset to transform all processes at once
+    # now we query the files and create a fileset dictionary containing the
+    # URLs pointing to the queried files
+
     t0 = time.time()
-    ds = utils.ServiceXDatasetGroup(fileset, backend_name="uproot", ignore_cache=SERVICEX_IGNORE_CACHE)
-    files_per_process = ds.get_data_rootfiles_uri(query, as_signed_url=True, title="CMS ttbar")
+    for process in fileset.keys():
+        ds = ServiceXDataset(fileset[process]['files'],
+                             backend_name="uproot",
+                             ignore_cache=SERVICEX_IGNORE_CACHE)
+        files = ds.get_data_rootfiles_uri(query,
+                                          as_signed_url=True,
+                                          title=process)
 
-    print(f"ServiceX data delivery took {time.time() - t0:.2f} seconds")
 
-    # update fileset to point to ServiceX-transformed files
-    for process in fileset.keys():
-        fileset[process]["files"] = [f.url for f in files_per_process[process]]
+        fileset[process]["files"] = [f.url for f in files]
+
+    print(f"ServiceX data delivery took {time.time() - t0:.2f} seconds")
 
 # %% [markdown]
 # ### Execute the data delivery pipeline
@@ -459,186 +462,29 @@ def get_query(source: ObjectStream) -> ObjectStream:
 # When `USE_SERVICEX` is false, the input files need to be processed during this step as well.
 
 # %%
-if USE_DASK:
-    executor = processor.DaskExecutor(client=utils.get_client(AF))
-else:
-    executor = processor.FuturesExecutor(workers=NUM_CORES)
-        
-run = processor.Runner(executor=executor, schema=AGCSchema, savemetrics=True, metadata_cache={}, chunksize=CHUNKSIZE)
-
-if USE_SERVICEX:
-    treename = "servicex"
-    
-else:
-    treename = "events"
-    
-filemeta = run.preprocess(fileset, treename=treename)  # pre-processing
-
-t0 = time.monotonic()
-all_histograms, metrics = run(fileset, treename, processor_instance=TtbarAnalysis(DISABLE_PROCESSING, IO_FILE_PERCENT))  # processing
-exec_time = time.monotonic() - t0
+if __name__ == "__main__":
+    NanoAODSchema.warn_missing_crossrefs = False # silences warnings about branches we will not use here
+    if USE_DASK:
+        executor = processor.DaskExecutor(client=utils.get_client(AF))
+    else:
+        # executor = processor.FuturesExecutor(workers=NUM_CORES)
+        executor = processor.IterativeExecutor()
 
-all_histograms = all_histograms["hist"]
+    run = processor.Runner(executor=executor, schema=NanoAODSchema, savemetrics=True, metadata_cache={}, chunksize=CHUNKSIZE)
 
-print(f"\nexecution took {exec_time:.2f} seconds")
+    if USE_SERVICEX:
+        treename = "servicex"
 
-# %%
-# track metrics
-dataset_source = "/data" if fileset["ttbar__nominal"]["files"][0].startswith("/data") else "https://xrootd-local.unl.edu:1094" # TODO: xcache support
-metrics.update({
-    "walltime": exec_time, 
-    "num_workers": NUM_CORES, 
-    "af": AF_NAME, 
-    "dataset_source": dataset_source, 
-    "use_dask": USE_DASK, 
-    "use_servicex": USE_SERVICEX, 
-    "systematics": SYSTEMATICS, 
-    "n_files_max_per_sample": N_FILES_MAX_PER_SAMPLE,
-    "cores_per_worker": CORES_PER_WORKER, 
-    "chunksize": CHUNKSIZE, 
-    "disable_processing": DISABLE_PROCESSING, 
-    "io_file_percent": IO_FILE_PERCENT
-})
-
-# save metrics to disk
-if not os.path.exists("metrics"):
-    os.makedirs("metrics")
-timestamp = time.strftime('%Y%m%d-%H%M%S')
-metric_file_name = f"metrics/{AF_NAME}-{timestamp}.json"
-with open(metric_file_name, "w") as f:
-    f.write(json.dumps(metrics))
-
-print(f"metrics saved as {metric_file_name}")
-#print(f"event rate per worker (full execution time divided by NUM_CORES={NUM_CORES}): {metrics['entries'] / NUM_CORES / exec_time / 1_000:.2f} kHz")
-print(f"event rate per worker (pure processtime): {metrics['entries'] / metrics['processtime'] / 1_000:.2f} kHz")
-print(f"amount of data read: {metrics['bytesread']/1000**2:.2f} MB")  # likely buggy: https://github.com/CoffeaTeam/coffea/issues/717
-
-# %% [markdown]
-# ### Inspecting the produced histograms
-#
-# Let's have a look at the data we obtained.
-# We built histograms in two phase space regions, for multiple physics processes and systematic variations.
+    else:
+        treename = "Events"
 
-# %%
-utils.set_style()
+    filemeta = run.preprocess(fileset, treename=treename)  # pre-processing
 
-all_histograms[120j::hist.rebin(2), "4j1b", :, "nominal"].stack("process")[::-1].plot(stack=True, histtype="fill", linewidth=1, edgecolor="grey")
-plt.legend(frameon=False)
-plt.title(">= 4 jets, 1 b-tag")
-plt.xlabel("HT [GeV]");
+    t0 = time.monotonic()
+    all_histograms, metrics = run(fileset, treename, processor_instance=TtbarAnalysis(DISABLE_PROCESSING, IO_FILE_PERCENT))  # processing
+    breakpoint()
+    exec_time = time.monotonic() - t0
 
-# %%
-all_histograms[:, "4j2b", :, "nominal"].stack("process")[::-1].plot(stack=True, histtype="fill", linewidth=1,edgecolor="grey")
-plt.legend(frameon=False)
-plt.title(">= 4 jets, >= 2 b-tags")
-plt.xlabel("$m_{bjj}$ [Gev]");
+    all_histograms = all_histograms["hist"]
 
-# %% [markdown]
-# Our top reconstruction approach ($bjj$ system with largest $p_T$) has worked!
-#
-# Let's also have a look at some systematic variations:
-# - b-tagging, which we implemented as jet-kinematic dependent event weights,
-# - jet energy variations, which vary jet kinematics, resulting in acceptance effects and observable changes.
-#
-# We are making of [UHI](https://uhi.readthedocs.io/) here to re-bin.
-
-# %%
-# b-tagging variations
-all_histograms[120j::hist.rebin(2), "4j1b", "ttbar", "nominal"].plot(label="nominal", linewidth=2)
-all_histograms[120j::hist.rebin(2), "4j1b", "ttbar", "btag_var_0_up"].plot(label="NP 1", linewidth=2)
-all_histograms[120j::hist.rebin(2), "4j1b", "ttbar", "btag_var_1_up"].plot(label="NP 2", linewidth=2)
-all_histograms[120j::hist.rebin(2), "4j1b", "ttbar", "btag_var_2_up"].plot(label="NP 3", linewidth=2)
-all_histograms[120j::hist.rebin(2), "4j1b", "ttbar", "btag_var_3_up"].plot(label="NP 4", linewidth=2)
-plt.legend(frameon=False)
-plt.xlabel("HT [GeV]")
-plt.title("b-tagging variations");
-
-# %%
-# jet energy scale variations
-all_histograms[:, "4j2b", "ttbar", "nominal"].plot(label="nominal", linewidth=2)
-all_histograms[:, "4j2b", "ttbar", "pt_scale_up"].plot(label="scale up", linewidth=2)
-all_histograms[:, "4j2b", "ttbar", "pt_res_up"].plot(label="resolution up", linewidth=2)
-plt.legend(frameon=False)
-plt.xlabel("$m_{bjj}$ [Gev]")
-plt.title("Jet energy variations");
-
-# %% [markdown]
-# ### Save histograms to disk
-#
-# We'll save everything to disk for subsequent usage.
-# This also builds pseudo-data by combining events from the various simulation setups we have processed.
-
-# %%
-utils.save_histograms(all_histograms, fileset, "histograms.root")
-
-# %% [markdown]
-# ### Statistical inference
-#
-# A statistical model has been defined in `config.yml`, ready to be used with our output.
-# We will use `cabinetry` to combine all histograms into a `pyhf` workspace and fit the resulting statistical model to the pseudodata we built.
-
-# %%
-config = cabinetry.configuration.load("cabinetry_config.yml")
-cabinetry.templates.collect(config)
-cabinetry.templates.postprocess(config)  # optional post-processing (e.g. smoothing)
-ws = cabinetry.workspace.build(config)
-cabinetry.workspace.save(ws, "workspace.json")
-
-# %% [markdown]
-# We can inspect the workspace with `pyhf`, or use `pyhf` to perform inference.
-
-# %%
-# !pyhf inspect workspace.json | head -n 20
-
-# %% [markdown]
-# Let's try out what we built: the next cell will perform a maximum likelihood fit of our statistical model to the pseudodata we built.
-
-# %%
-model, data = cabinetry.model_utils.model_and_data(ws)
-fit_results = cabinetry.fit.fit(model, data)
-
-cabinetry.visualize.pulls(
-    fit_results, exclude="ttbar_norm", close_figure=True, save_figure=False
-)
-
-# %% [markdown]
-# For this pseudodata, what is the resulting ttbar cross-section divided by the Standard Model prediction?
-
-# %%
-poi_index = model.config.poi_index
-print(f"\nfit result for ttbar_norm: {fit_results.bestfit[poi_index]:.3f} +/- {fit_results.uncertainty[poi_index]:.3f}")
-
-# %% [markdown]
-# Let's also visualize the model before and after the fit, in both the regions we are using.
-# The binning here corresponds to the binning used for the fit.
-
-# %%
-model_prediction = cabinetry.model_utils.prediction(model)
-figs = cabinetry.visualize.data_mc(model_prediction, data, close_figure=True)
-figs[0]["figure"]
-
-# %%
-figs[1]["figure"]
-
-# %% [markdown]
-# We can see very good post-fit agreement.
-
-# %%
-model_prediction_postfit = cabinetry.model_utils.prediction(model, fit_results=fit_results)
-figs = cabinetry.visualize.data_mc(model_prediction_postfit, data, close_figure=True)
-figs[0]["figure"]
-
-# %%
-figs[1]["figure"]
-
-# %% [markdown]
-# ### What is next?
-#
-# Our next goals for this pipeline demonstration are:
-# - making this analysis even **more feature-complete**,
-# - **addressing performance bottlenecks** revealed by this demonstrator,
-# - **collaborating** with you!
-#
-# Please do not hesitate to get in touch if you would like to join the effort, or are interested in re-implementing (pieces of) the pipeline with different tools!
-#
-# Our mailing list is analysis-grand-challenge@iris-hep.org, sign up via the [Google group](https://groups.google.com/a/iris-hep.org/g/analysis-grand-challenge).
+    print(f"\nexecution took {exec_time:.2f} seconds")
diff --git a/analyses/cms-open-data-ttbar/utils/__init__.py b/analyses/cms-open-data-ttbar/utils/__init__.py
index 6d56c7c0..bd7b66e5 100644
--- a/analyses/cms-open-data-ttbar/utils/__init__.py
+++ b/analyses/cms-open-data-ttbar/utils/__init__.py
@@ -5,7 +5,7 @@
 import matplotlib as mpl
 import matplotlib.pyplot as plt
 import uproot
-from servicex import ServiceXDataset
+# from servicex import ServiceXDataset
 import numpy as np
 
 def get_client(af="coffea_casa"):
@@ -124,32 +124,32 @@ def save_histograms(all_histograms, fileset, filename):
             f[f"{region}_wjets_scale_var_up"] = all_histograms[120j :: hist.rebin(2), region, "wjets", "scale_var_up"]
 
 
-class ServiceXDatasetGroup():
-    def __init__(self, fileset, backend_name="uproot", ignore_cache=False):
-        self.fileset = fileset
+# class ServiceXDatasetGroup():
+#     def __init__(self, fileset, backend_name="uproot", ignore_cache=False):
+#         self.fileset = fileset
 
-        # create list of files (& associated processes)
-        filelist = []
-        for i, process in enumerate(fileset):
-            filelist += [[filename, process] for filename in fileset[process]["files"]]
+#         # create list of files (& associated processes)
+#         filelist = []
+#         for i, process in enumerate(fileset):
+#             filelist += [[filename, process] for filename in fileset[process]["files"]]
 
-        filelist = np.array(filelist)
-        self.filelist = filelist
-        self.ds = ServiceXDataset(filelist[:,0].tolist(), backend_name=backend_name, ignore_cache=ignore_cache)
+#         filelist = np.array(filelist)
+#         self.filelist = filelist
+#         self.ds = ServiceXDataset(filelist[:,0].tolist(), backend_name=backend_name, ignore_cache=ignore_cache)
 
-    def get_data_rootfiles_uri(self, query, as_signed_url=True, title="Untitled"):
+#     def get_data_rootfiles_uri(self, query, as_signed_url=True, title="Untitled"):
 
-        all_files = np.array(self.ds.get_data_rootfiles_uri(query, as_signed_url=as_signed_url, title=title))
-        parent_file_urls = np.array([f.file for f in all_files])
+#         all_files = np.array(self.ds.get_data_rootfiles_uri(query, as_signed_url=as_signed_url, title=title))
+#         parent_file_urls = np.array([f.file for f in all_files])
 
-        # order is not retained after transform, so we can match files to their parent files using the filename
-        # (replacing / with : to mitigate servicex filename convention )
-        parent_key = np.array([np.where(parent_file_urls==self.filelist[i][0].replace("/",":"))[0][0]
-                               for i in range(len(self.filelist))])
+#         # order is not retained after transform, so we can match files to their parent files using the filename
+#         # (replacing / with : to mitigate servicex filename convention )
+#         parent_key = np.array([np.where(parent_file_urls==self.filelist[i][0].replace("/",":"))[0][0]
+#                                for i in range(len(self.filelist))])
 
-        files_per_process = {}
-        for i, process in enumerate(self.fileset):
-            # update files for each process
-            files_per_process.update({process: all_files[parent_key[self.filelist[:,1]==process]]})
+#         files_per_process = {}
+#         for i, process in enumerate(self.fileset):
+#             # update files for each process
+#             files_per_process.update({process: all_files[parent_key[self.filelist[:,1]==process]]})
 
-        return files_per_process
+#         return files_per_process