Skip to content

Instantly share code, notes, and snippets.

@andrzejnovak

andrzejnovak/rhalpha2.ipynb

Created March 3, 2026 07:34
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save andrzejnovak/cf8149a96d07e85e1d53f3b40304d13d to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save andrzejnovak/cf8149a96d07e85e1d53f3b40304d13d to your computer and use it in GitHub Desktop.
Download ZIP
Display the source blob
Display the rendered blob
Raw
rhalpha2.ipynb
{
"cells": [
{
"cell_type": "code",
"execution_count": 28,
"id": "58644ddb-d773-46e7-88be-168ac2ffd158",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"outputs": [],
"source": [
"import rhalphalib as rl\n",
"# import coffea\n",
"import uproot\n",
"import hist\n",
"import mplhep as hep\n",
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"import json, yaml\n",
"import pickle\n",
"from tqdm import tqdm\n",
"# from tqdm.rich import trange, tqdm\n",
"from rich.progress import track\n",
"from rich.progress import Progress\n",
"import logging\n",
"import pickle\n",
"from rich.logging import RichHandler\n",
"\n",
"FORMAT = \"%(message)s\"\n",
"logging.basicConfig(\n",
" level=logging.WARNING, format=FORMAT, datefmt=\"[%X]\", handlers=[RichHandler()]\n",
")\n",
"\n",
"log = logging.getLogger(\"rich\")"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "cb6b49a9-2e58-4d8d-a0e6-232e2d5befc8",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"outputs": [],
"source": [
"import os\n",
"base = '/home/anovak/work/htt_refit'\n",
"os.chdir(base)"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "0e858a01-82f7-4319-bc93-23f7dea49da9",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"outputs": [],
"source": [
"import samplelists\n",
"import processmap"
]
},
{
"cell_type": "code",
"execution_count": 120,
"id": "cd5cc332-a733-46e8-ad0f-069f174d1964",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"outputs": [],
"source": [
"import yaml, os, copy\n",
"\n",
"with open(\"metadata/xs.yml\") as stream:\n",
" xs_dict = yaml.safe_load(stream)\n",
"# xs_dict"
]
},
{
"cell_type": "code",
"execution_count": 121,
"id": "d2c1ce26-5f60-4a73-afcd-42a3c5a06d22",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"outputs": [],
"source": [
"# samplelists.getSamplesData(\"2018\")"
]
},
{
"cell_type": "code",
"execution_count": 122,
"id": "87edff66-3035-4778-ae21-21d5972ddec7",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"outputs": [],
"source": [
"lumi_dict = {\n",
" # \"2016APV\": 19.52,\n",
" # \"2016\": 16.81,\n",
" # \"2017\": 41.48,\n",
" \"2018\": 59.83,\n",
"}"
]
},
{
"cell_type": "code",
"execution_count": 123,
"id": "21a924ff-050b-42d4-a093-f275319943d6",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 27/27 [00:12<00:00, 2.19it/s]\n"
]
}
],
"source": [
"scaled_all = {}\n",
"for year in lumi_dict.keys():\n",
" lumi = lumi_dict[year]\n",
" scaled_all[year] = {}\n",
" for process, samples in tqdm(processmap.process_map.items()):\n",
" if process in [\"zee\", \"zmm\", \"zll\"]:\n",
" continue\n",
" scaled_process = {}\n",
" for sample in samples:\n",
" if process in [\"zee\", \"zem\", \"zmm\", \"ztt\"]:\n",
" bare_sample = '_'.join(sample.split('_')[:-1])\n",
" else:\n",
" bare_sample = sample\n",
" # path = f\"inputs/{year}/hists_sum_{bare_sample}.hist\"\n",
" path = f\"ainputs2018/{bare_sample}.hist\"\n",
" # print(f\"Readign sample: {sample}, from: {path}\")\n",
" if os.path.exists(path):\n",
" with open(path, \"rb\") as f:\n",
" loaded = pickle.load(f)\n",
" nd_hist = loaded['met_nn_kin']\n",
" unweighted = True\n",
" if hasattr(nd_hist, \"to_hist\"):\n",
" nd_hist = nd_hist.to_hist()\n",
" unweighted = False\n",
" if unweighted:\n",
" # sumw = loaded['sumw'][bare_sample]\n",
" sumw = loaded['sumw'][bare_sample] / 1000\n",
" else:\n",
" sumw = 1.\n",
" if \"Run\" in sample:\n",
" _factor = 1.\n",
" else:\n",
" _factor = lumi / sumw\n",
" # log.debug(f\"Scaling {sample} by {_factor:.9f} (lumi = {lumi}, xs = {xs:.3f}, sumw = {sumw:.3f})\")\n",
" raw_scaled = nd_hist * _factor\n",
" scaled_process[sample] = copy.deepcopy(raw_scaled[{'dataset': sample}])\n",
" scaled_all[year][process] = scaled_process"
]
},
{
"cell_type": "code",
"execution_count": 124,
"id": "e8cf5c3d-4019-48d7-ae63-043c0290ac73",
"metadata": {},
"outputs": [],
"source": [
"# scaled_all"
]
},
{
"cell_type": "code",
"execution_count": 125,
"id": "414d9587-53f3-4fcf-a42e-7015163cf241",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"('hadhad_signal_met', slice(150j, None, <built-in function sum>))"
]
},
"execution_count": 125,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"region_map = {}\n",
"metcut_map = {}\n",
"s = hist.tag.Slicer()\n",
"loc = hist.tag.loc\n",
"_cat = \"hadhad\"\n",
"had_th_lo, had_th_hi = 75.0, 150.0j\n",
"region_map[_cat] = {\n",
" \"sig\": {\n",
" \"nom\": {\n",
" 'region': f\"{_cat}_signal_met\",\n",
" 'met': s[had_th_hi::sum],\n",
" },\n",
" \"fail\": {\n",
" 'region': f\"{_cat}_cr_dphi_inv\",\n",
" 'met': s[had_th_hi::sum],\n",
" },\n",
" },\n",
" \"top_cr\": {\n",
" \"nom\": {\n",
" 'region': f\"{_cat}_cr_b_mu_iso\",\n",
" 'met': s[had_th_hi::sum],\n",
" },\n",
" \"fail\": {\n",
" 'region': f\"{_cat}_cr_b_mu_iso_dphi_inv\",\n",
" 'met': s[had_th_hi::sum],\n",
" },\n",
" },\n",
" \"wlnu_cr\": {\n",
" \"nom\": {\n",
" 'region': f\"{_cat}_cr_mu_iso\",\n",
" 'met': s[had_th_hi::sum],\n",
" },\n",
" \"fail\": {\n",
" 'region': f\"{_cat}_cr_mu_iso_dphi_inv\",\n",
" 'met': s[had_th_hi::sum],\n",
" },\n",
" },\n",
" \"qcd_cr\": {\n",
" \"nom\": {\n",
" 'region': f\"{_cat}_cr_mu\",\n",
" 'met': s[had_th_hi::sum],\n",
" },\n",
" \"fail\": {\n",
" 'region': f\"{_cat}_cr_mu_dphi_inv\",\n",
" 'met': s[had_th_hi::sum],\n",
" },\n",
" },\n",
"}\n",
"lep_th_lo, lep_th_hi = 50.0j, 75.0j\n",
"for _cat in [\"hadel\", \"hadmu\"]:\n",
" region_map[_cat] = {\n",
" \"sig\": {\n",
" \"nom\": {\n",
" 'region': f\"{_cat}_signal\",\n",
" 'met': s[lep_th_hi::sum],\n",
" },\n",
" \"fail\": {\n",
" 'region': f\"{_cat}_signal\",\n",
" 'met': s[lep_th_lo:lep_th_hi:sum],\n",
" },\n",
" },\n",
" \"top_cr\": {\n",
" \"nom\": {\n",
" 'region': f\"{_cat}_cr_b\",\n",
" 'met': s[lep_th_hi::sum],\n",
" },\n",
" \"fail\": {\n",
" 'region': f\"{_cat}_cr_b_dphi_inv\",\n",
" 'met': s[lep_th_lo:lep_th_hi:sum],\n",
" },\n",
" },\n",
" \"wlnu_cr\": {\n",
" \"nom\": {\n",
" 'region': f\"{_cat}_cr_w\",\n",
" 'met': s[lep_th_hi::sum],\n",
" },\n",
" \"fail\": {\n",
" 'region': f\"{_cat}_cr_w_dphi_inv\",\n",
" 'met': s[lep_th_lo:lep_th_hi:sum],\n",
" },\n",
" },\n",
" \"qcd_cr\": {\n",
" \"nom\": {\n",
" 'region': f\"{_cat}_cr_qcd\",\n",
" 'met': s[lep_th_hi::sum],\n",
" },\n",
" \"fail\": {\n",
" 'region': f\"{_cat}_cr_qcd\",\n",
" 'met': s[lep_th_lo:lep_th_hi:sum],\n",
" },\n",
" },\n",
" }\n",
"\n",
"region_map['hadhad']['sig']['nom']['region'], region_map['hadhad']['sig']['nom']['met']"
]
},
{
"cell_type": "code",
"execution_count": 126,
"id": "f9257a52-5500-4aa2-9a52-e6667a0915f1",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"outputs": [],
"source": [
"channels = ['hadel', 'hadmu', 'hadhad']\n",
"regions = [\"sig\", \"top_cr\", \"wlnu_cr\", \"qcd_cr\"]\n",
"\n",
"nnCuts = {\n",
" \"hadhad\": 0.9999j,\n",
" \"hadel\": 0.98j, #0.98\n",
" \"hadmu\": 0.98j, #0.98\n",
"}\n",
"nnLooseCuts = {\n",
" \"hadhad\": 0.995j,\n",
" \"hadel\": 0.9j, #0.9\n",
" \"hadmu\": 0.9j, #0.9\n",
" }"
]
},
{
"cell_type": "code",
"execution_count": 127,
"id": "70360fd4-f54e-43a0-b5dc-8e658bf6d518",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"outputs": [],
"source": [
"def apply_slice(h_obj, sli):\n",
" return h_obj[sli]"
]
},
{
"cell_type": "code",
"execution_count": 128,
"id": "616e6587-9cd3-49e1-b8c6-c1fb58ff3d67",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "2edf8ddab0b44a0eba13856993208bc7",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Output()"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
],
"text/plain": []
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 43.8 s, sys: 0 ns, total: 43.8 s\n",
"Wall time: 43.4 s\n"
]
}
],
"source": [
"%%time \n",
"\n",
"from rich.progress import Progress\n",
"from rich.progress import TextColumn, BarColumn, MofNCompleteColumn, TaskProgressColumn, TimeRemainingColumn\n",
"\n",
"with Progress(\n",
" TextColumn(\"[progress.description]{task.description}\"),\n",
" BarColumn(),\n",
" TaskProgressColumn(),\n",
" MofNCompleteColumn(),\n",
" TimeRemainingColumn(),\n",
") as progress:\n",
" tr_year = progress.add_task(\"[red]Year...\", total=4)\n",
" tr_channel = progress.add_task(\"[green]Channel...\", total=3)\n",
" tr_sample = progress.add_task(\"[cyan]Sample...\")\n",
"\n",
" fitted_temps = {}\n",
" for year in list(lumi_dict.keys()):\n",
" progress.update(tr_year, advance=1)\n",
" fitted_temps[year] = {}\n",
" progress.reset(tr_channel)\n",
" for channel in channels:\n",
" progress.update(tr_channel, advance=1)\n",
" fitted_temps[year][channel] = {}\n",
" progress.reset(tr_sample)\n",
" for process in list(scaled_all[year].keys()):\n",
" progress.update(tr_sample, advance=1, total=len(scaled_all[year].keys()))\n",
" fitted_temps[year][channel][process] = {}\n",
" for sample in scaled_all[year][process].keys():\n",
" fitted_temps[year][channel][process][sample] = {}\n",
" for i, region in enumerate([\"sig\", \"top_cr\", \"wlnu_cr\", \"qcd_cr\"]):\n",
" rsysts = list(scaled_all[year][process][sample].axes['systematic'])\n",
" fitted_temps[year][channel][process][sample][region] = {}\n",
" for pf_reg in ['nom', 'fail']: # Nominal selection vs flip (for qcd prediction)\n",
" fitted_temps[year][channel][process][sample][region][pf_reg] = {}\n",
" for syst in rsysts: \n",
" fitted_temps[year][channel][process][sample][region][pf_reg][syst] = {\"pass\": None, \"loose\": None, \"fail\": None}\n",
" nnCut, nnLooseCut = nnCuts[channel], nnLooseCuts[channel]\n",
" _slice = {'systematic': syst, \n",
" # 'h_pt': sum, \n",
" 'region': region_map[channel][region][pf_reg]['region'],\n",
" 'met_pt': region_map[channel][region][pf_reg]['met'],\n",
" }\n",
" for _nn, sli in zip([\"pass\", \"loose\", \"fail\"], [s[nnCut::sum], s[nnLooseCut:nnCut:sum], s[:nnLooseCut:sum]]):\n",
" fitted_temps[year][channel][process][sample][region][pf_reg][syst][_nn] = \\\n",
" apply_slice(scaled_all[year][process][sample], {**_slice, \"nn_disc\": sli})\n",
" # future = pool.submit(apply_slice, scaled_all[year][process][sample], {**_slice, \"nn_disc\": sli})\n",
" # fitted_temps[year][channel][process][sample][region][syst][_nn] = future\n",
" # future_set.add(future)"
]
},
{
"cell_type": "code",
"execution_count": 129,
"id": "f6f130be-a6c7-4eaa-ae08-d2bfccd6f605",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"outputs": [],
"source": [
"with open('templates_new_testA.pkl', 'wb') as handle:\n",
" pickle.dump(fitted_temps, handle, protocol=pickle.HIGHEST_PROTOCOL)"
]
},
{
"cell_type": "code",
"execution_count": 130,
"id": "b1aa40e4-dbc9-458a-a146-c3bd59a9c676",
"metadata": {},
"outputs": [],
"source": [
"with open('templates_new_testA.pkl', 'rb') as handle:\n",
" fitted_temps = pickle.load(handle)"
]
},
{
"cell_type": "code",
"execution_count": 131,
"id": "b4ecf9e4-9714-4bda-807c-77b342dbfb01",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"outputs": [],
"source": [
"hep.style.use(\"CMS\")"
]
},
{
"cell_type": "code",
"execution_count": 132,
"id": "d36a7488-32f2-44c2-ad03-019fc8da39ca",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"outputs": [],
"source": [
"# Dict patch to return available keys on KeyError\n",
"class NestedDict(dict):\n",
" def __getitem__(self, key):\n",
" if key in self:\n",
" value = super().__getitem__(key)\n",
" if isinstance(value, dict) and not isinstance(value, NestedDict):\n",
" value = NestedDict(value)\n",
" self[key] = value # auto-convert nested dicts\n",
" return value\n",
" else:\n",
" available = ', '.join(repr(k) for k in self.keys())\n",
" raise KeyError(f\"Key {key!r} not found. Available keys: {available}\")\n",
"\n",
" @staticmethod\n",
" def from_dict(d):\n",
" \"\"\"Recursively convert a regular dict into a NestedDict.\"\"\"\n",
" if not isinstance(d, dict):\n",
" return d\n",
" return NestedDict({k: NestedDict.from_dict(v) for k, v in d.items()})\n",
"\n",
"fitted_temps_patched = NestedDict().from_dict(fitted_temps)"
]
},
{
"cell_type": "code",
"execution_count": 133,
"id": "7411fc9e-8324-4cdc-b387-bcdd64148711",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"outputs": [],
"source": [
"import collections\n",
"\n",
"def fetch_temp(year, channel, region, nnreg, process, reg_passfail='nom', syst='nominal', rebin=None):\n",
" if not isinstance(process, list):\n",
" process = [process]\n",
" if not isinstance(year, list):\n",
" year = [year]\n",
" _temps = []\n",
" for y in year:\n",
" for p in process:\n",
" for sample in fitted_temps_patched[y][channel][p].keys():\n",
" # print(y, channel, p, sample, region, nnreg, syst)\n",
" try:\n",
" _temps.append(fitted_temps_patched[y][channel][p][sample][region][reg_passfail][syst][nnreg])\n",
" except:\n",
" _temps.append(fitted_temps_patched[y][channel][p][sample][region][reg_passfail]['nominal'][nnreg])\n",
" if len(_temps) == 0:\n",
" raise RuntimeError(\"No templates within input dictionary matches search terms.\")\n",
" _temp = sum(_temps)\n",
" if rebin == \"one\":\n",
" # print([_temp.axes[0].edges[0], _temp.axes[0].edges[-1]])\n",
" _temp = _temp[hist.rebin(edges=[_temp.axes[0].edges[0], _temp.axes[0].edges[-1]])]\n",
" elif rebin == \"two\":\n",
" reb_arr = np.r_[_temp.axes[0].edges[:15:2], _temp.axes[0].edges[16:]]\n",
" _temp = _temp[hist.rebin(edges=reb_arr)]\n",
" elif isinstance(rebin, (collections.abc.Sequence, np.ndarray)):\n",
" _temp = _temp[hist.rebin(rebin)]\n",
" _mask = _temp.values() < 0\n",
" _temp.view().value[_mask] = 0.0\n",
" _temp.view().variance[_mask] = 0.0\n",
" return _temp\n",
"\n",
"def rename1daxis(h_obj, name=None):\n",
" new = hist.new.Var(h_obj.axes[0].edges, \n",
" name=name if name is not None else h_obj.axes[0].name\n",
" ).Weight()\n",
" new.view().value = copy.deepcopy(h_obj.values())\n",
" new.view().variance = copy.deepcopy(h_obj.variances())\n",
" return new"
]
},
{
"cell_type": "code",
"execution_count": 142,
"id": "207fb8b0-95ac-4238-b89e-29f7db1370d0",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"<matplotlib.legend.Legend at 0x73ea7858fd10>"
]
},
"execution_count": 142,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAA0EAAAOKCAYAAABd0luuAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAgVlJREFUeJzt3QmcleP///HP1LSvtEzLtJGWKQqRFrKFvpQihCiSMIhCJVR87bJPZElREZIsKZEiqWghpl2LppqUSPt2/o/P9f3f53efM+ecOTNzZs5yvZ6Px60zc+77Pvfc555xv891XZ8ryePxeAQAAAAALFEs2gcAAAAAAEWJEAQAAADAKoQgAAAAAFYhBAEAAACwCiEIAAAAgFUIQQAAAACsQggCAAAAYBVCEAAAAACrEIIAAAAAWIUQBCSIpKQk73LDDTdIojhy5IisWbNGFi5cKLNmzZKlS5fKtm3bJN7pe+R+z2wSzs8+btw4n3XmzJkjtrD5ZweAopJcZK8EIOH16tVL3n77bfP48OHDUrx48Xzt5+jRo/Lxxx/La6+9JvPmzZN///03xzpNmzaVzp07S//+/aVWrVph73vmzJlm//lRsmRJOeecc/K1LQAAiB2EIAARceDAAfn0008LvJ/ff/9dunfvLkuWLAm53vLly83ywgsvyEMPPSRDhgzJtUVl165dcsEFF+T72GrUqCFbtmzJ9/YAACA20B0OQERMmjRJdu7cWaB9rFy5Ulq1apVrAPIPX0OHDjXBKbcWnlWrVhXo+AAAQGIgBAEosHXr1smAAQMKtI99+/bJZZddliNIXXvttTJ16lQzLkhbchYsWCCjRo2SevXq+az30UcfyX333RfyNQhBAABAEYIAFMjPP/9sxubs2LGjQPt56623JDMz0/t1+fLl5YMPPpDx48dLly5d5Pjjj5cKFSrI6aefLrfeeqtZNz093Wcfzz33nCxbtizsEPT333+Lx+MJe6ErHAAAiYExQQDCtnfvXlm7dq3ptrZ48WJTrU2rtmlAKCgNMG4jR440XdyCKVu2rLz00kvmWL766ivzPe0O9/TTT3uLM4QKQSkpKVKpUqUCHzcAAIg/hCAAYdOxN88//3zEz5h2ddPFkZqaKn369Ml1Oy2E8Oabb/p0jfvss89MWe1Alek0MDmaNGkSkWMHAADxhxAEWEJbbFasWCFbt26VihUrSsOGDeWEE07IMbYmGr799lufr3VsULjltevWrSvHHXecqSqndEzRpk2bAv5c7pagxo0bSyzbvHmzzJ07V7Kzs03xB+0OqO+ZHreW6s4PHVOlLXl6frKyskwXxnLlykmVKlVMKDzppJOkVKlS+T7mv/76S7777jtz7NrVUFvb6tevL2eeeaaUKFFCImn37t0ye/Zs83Poe67XgXN+8tvCd/DgQVm9erXZpy76u6LnWvenvystWrSQypUr5/uY9X3U93T9+vVmrqtjjjnGlHc/66yzCrTfeKLl7rVMvfP72q9fP9PNNZT9+/fL999/Lxs3bjTnTc+V/s7ror8XkaCt2TreUN9/vX71mGrWrCnt2rWT6tWrR+Q19EOY+fPnm2urUaNGIVu6nWkG9Jj0d1b/DhQrVkyqVatmfu4zzjhDkpO5hQMKxAMgIeivs7P07t3b+/0xY8Z4GjRo4PO8e+nYsaPnxx9/DOs1Jk6caPYdaKlRo4bPfg8fPhz2sd9///0+27777rt5+tm7devms/38+fNzrLN582afdZ599llPpNWvXz/o++BPn3Ov61i+fLl5T4oVKxbw/apdu7Zn9OjRnkOHDoV9XL/++qunb9++ntKlSwe9DnSpUKGC5/rrr/esWrUqTz/3ggULzDEnJycH3O8xxxzjufPOOz3//PNPyJ/dbezYsT7rzJ4923z/77//9tx0002esmXLBnytMmXKeAYNGuT566+/wj7+7Oxsz4gRIzwpKSkhz4/+fOeff77nq6++ytP52bRpk+eGG27wlC9fPuB+S5Ys6enatatn9erVIX/2eHH22Wd7j/3222/3fv/5558314L7Z1u/fn3Q/ejvwpVXXhn0vdbllFNO8YwbN85z4MCBPP1+6rGoI0eOmL8Fwf5G6u/hWWed5fn2229z3b/+LO5tf/rpJ/P97du3ey6//HJPUlKS9zk9R8Fs3LjR06dPH0+lSpWC/twVK1b09OrVy/P777/nelwAAiMEAQnC/+b74MGDnquvvjrkTZ170bAUqRufvIYg/R++e1u9qc6LDh06+Gy/du3aHOvojaR7nc8//9wTayFo0qRJIW/43Mu5555rbuBCOXr0qAkf4V4DzqJh6cMPP8z159X9Dxw40OfmLtRSp04dz88//5zvELRs2bIc5zjYoqFcg29uJkyY4ClVqlSez9E999zjCcd7773nKVeuXFj71AA3fvz4hAtBep3069cv4M8cLAQNGzYsaKgOtDRt2tSzbt26PIWgbdu25fi7FWq57bbbQv7OBQpBekyNGjXKsa9gIei1117L9cMK/wD94osv5vEdAqAIQUCCcP+PUT8h1E+e3d+rUqWKp0WLFp5atWoFvQHTm8xohKC5c+eam0Vn+ffff8Pedt++fT6fLusNbaAbFW09cR/fmjVrzCeuw4cP93Tp0sXcROnNR7Vq1TzNmzc3N20ff/xxrkEjUiFo5syZnhIlSvj8HI0bN/Y0adLE3OgEes8efPDBkMfz8MMPB9xOWyT0xuykk04yP2+gEKPnQj+JD+XGG28MuH+96U9LSzOLf6jT608DnPt7gfgHAQ0HqampPp/Q66f3+jMEa2HRazLUdajhItDPrue7Xr16npNPPtm8ZrCbcT3GUPT5QC16+j4ff/zx5vfx2GOP9XlOX6tHjx4JFYL0d8z98+g51/N64oknBgyqwa4r/Z3Qa8q/NclZtCUvVKu2+/fzySef9LRr1y7H/vV3rlmzZqZVNNBrXHfddWGHIH3f9G+J/99Zfe+1ZdafHlOw31f9ufW4tAUo0Dp6jgHkDSEISBDu/yG6/0epN4nz5s3L0f1HWwj8b9AC/Y+5KEJQQegnuu7Xbd26dcD1tMXCfQOtn+S7Q0ewRUPItGnTCj0EOe+Z3iSNGjXKs3v3bu+6ei61y492hfO/oQrWLW7Lli05wtNll13mWbhwYY519RPxp59+OkeLhbsrU24hRRe9Sfvkk09MK6Q7pGr3Rm0FCnaOw9m/+5q+4447ctw8a3clfe/99/39998H/Rk0hLjXbdmypWfKlCk5rl39GTSENWzY0Gd9vcENRgOkvj/+H0S8/PLLnp07d3rX01YSPXb/G/JECUF6TThBU0OlfsgRqquinh//wKQf6vz2228+74sGDg0N/iFbfwf37t2b6++nvhfOYw2i+iGJ+8MX/b2aPn26uSb83w/9XQwnBGnI03+LFy9uPpTSbrrBfl/1GvD/e6yv/cUXX/hso+dAPzBp1apVjvP09ddfh/X+APgfQhCQIALdPPXs2TPoDYHT5cS/f308haDFixfn+GR08uTJAdft3LlzroEn2KI3GNqqEkn+IUgXbdn45ZdfQo7t8b/pC7b+Sy+95LPeFVdcYW64Q9GbK/c2p512WsD1NKD5fxqvrWmhxmXoja9/6MhLCHJap95///2gr7Fnzx7zibl7m2BdhbTV072etozt2LEj17E91atX99lOXzMQHTvkXk8D1B9//BF039riGOiaiPcQ5P5blNs4Nj2/7q5gGiJz+9m166sTNpxl6NChAdcN1JVSw3mocUl6zN27d/fZRkNToPfdPwQ5AejTTz8N+TPo76W2RLu303GO7g8T/OnfV/8WwxNOOCHX33EA/4cQBCQI///5anee/fv3h9xGb7zc3XG0ZSReQpB+wu9/Q6qfzAe7CdBuLv7nSH/eSy+91Hz6rOHpzTff9AwYMCDoOIFXX301Yscf6IZXP3nOTf/+/X220TEtgfh3h9RP0sPhvlHUUBbOp/XaDSlYGHDTggt6U5jfEDR48OBcX0NbcsJp3dRP893rZWRkePLzvm3YsCFgWPU/9nCKj+gN93HHHZdwIahy5co+rV/B3HfffT7b6fiYcOi17Q5P2gIaqEttoBCkwT83+nfUvxX2jTfeCCsEhWoNdmhrj3sbbaUKp0uw/s75/w0Mt9UagMdTrGC15QDEqocffjjXcsdacvWUU07xfn3o0CGJdfv27ZP777/flBXWcrmOY489Vt577z0zd1CgUrNOSV6HloNetGiRfPzxx5Kenm7Kct94441mktZvvvlGpk2bJnXq1PHZ5s477zTljQvDOeecIxdeeGGu65122mk+Xwd7z8477zwZPny4WR577DFJS0sL6zjcpcWDTYI7ceJEn6/1/dDJa3OjZaavuuoqyQ8tJz1o0KCInR8treycH126desW1nH4l14PdI78z4/uu1WrVrnuW0seDx48WBLN3XffnWsJcD2POueXo3Xr1tK3b9+w9q/X9j333ONT6lxLaudGX+P888/PdT39OzpkyBCf773zzjthvZ8PPPBAruv5Xy/6s5QvXz7X7fR3bsCAAT7fmzBhQq7bAfj/SIJAYvAfXB1uCWXtb5/bp/Kx0BKkLTz66b17cLyz6FiWH374IWQLhHv9U089NaxPprV7lP8nrVrJLhL8WxRyG2Tv+Oabb/K1Xbjcn5brY386PsY91kgLK+TW4uim1eHy0xIUzifqjvxul5/fl0BdqbSksnsd7bYZLu1S6F9uPt5bgsIpuOJ/XWhX3byYNWuWz/ZDhgzJtSVIWw3Dpde4+2+Bdkv1/xvr3xKkf2fC4W790xatvBSG2bVrl8/YM90XgPAw0xaQgBo0aBD2RHqBWk5ijbbMDBw4UJYsWZLjuaZNm8q4ceNytAC46YSdOvGlQz+VDmdSUG1deuqpp6R3797e773//vvyyiuvRHzyT20lieb7pRNEjhgxIteWrl9//dV80u7I6wSrJ554opQpU8a06BXG+Skse/bskbfeeiusT9q1hdGh14meo3Dp5KwtW7aU6dOnS6ToZKNz5swJa90OHTpI6dKlJZJq166d6zrz5s3z+VrP24wZM8J+jX/++cfn62XLluW6TZs2bcLev17jOlmuTvSq9u7dK8uXLzfXc0F+bp3o191KrROhhtMK5NBJXXWb3377zXyt+9JJi/VvF4DQCEFAAor2DWOk/PHHHyb8fPDBBzmeK168uOkKot3+crtp0xuqlJSUfB3D9ddfL48++qiZSd6Z8V5nfT/zzDMl3t4z7Raos8+vWrVK1q1bZxa9acrMzDT/Hj16NNd9bN++3efrhg0b5ukYNMRpSNfXjMVrWq85PT96PnTRc7RixQpzw+sOf6EChwYmh96g6rWaF7pNJGVnZ8tFF10U1roagv27/BWEBl7tyhhOCHcLpxtZKO6ussGOK69/E/zfF/1gpaAh6M8///T5Wn838ko/5HFCkLNPQhCQO0IQkICqVasm8e61114zIcd9Q+nQsTNPPvmk+WS2sOlNu76OE4KUBolIh6DCes92794tr7/+ukyZMkV+/PFHc5MeirYgalgKRj9l9h9bk1d6M5nXEFRY50eDn4ZsHZfx3XffmU/mY+H8JIpw3zf/8xaJ6z6U/IQN//cyt2MO52f3v97yG4JC7RNAYIQgIAHFQxe3YLSbiba+TJ48OcdzWsRBw084g5kjqUmTJjk+WY8HOnhbB1kH+lRci2LUqlXL3HDrz6ddtrSYwq233iqzZ88O2V2roNdafroSFsY1raHwpptukl9++SXg81WrVjU3pY0aNZJmzZqZ4Pvll1/KI488EnPnJ1bpdRaOSBdlOXDgQK4tQXnl3+0zt5bBcH/2gvI/rngocAPEAkIQgJih/fovvvjiHJWd9GZUq7Zdd911UQl4NWrU8Pk6L2NgouXVV181gcahXbL03Hbu3FlOPvlkad68eb5+Dv+uTWvWrMnzPvwr9UWDBiAN07t27fJ+Tyu4XX311XLqqaea1r9AFc2+/vrrkPv13yYWzo92bwtW6S9W+HffWrBggZx++umF9nr5qfLo/15GosuZ/++Tdr8s6PVSpUqVAh8XYANCEICYoN2SevTokSMAaUnll156Kapd/LT7m1v16tUllulYBS1L7Khbt6589dVXYY2rye1m2T8QxsJNfn7cfPPN3gCkrTfaJa5Lly4FPj/aXU5DuzN2Sm9qjxw5kqdxQf7Xmw30nLnpOKzCDEE7duwwH7pUqlQp7G38r3X/Y84P/79rkQhBkTguwAbMEwQgJjz77LM+FbG0xUdbf3Tun4IEoL///tt0+dJuTbpoS0he6aB4t8aNG0ss0/lW3GN/3njjjbALC/gP1PanXefc1au0K1luXY/8b/C1uEQ0adBeunSp92vtMhhOAArn/Ch3pULtMhWsu12wDwPCqWyWaPznUdIQVNjcxQRyo+PA3O+jdlkMVRQhLy1B7nFAGoICjYMMRqssukOzFmOI9Q9pgFhBCAIQdRpUdEJPt1GjRuWYCDA/tHuSftqr3V90+eyzz/J0k6nHtnDhQp9PWd0TzMYi/6ID2r0rHFoVLbebT23R0Ekm3aFg9OjRYR+blhyP1/OjN8Kff/55ruu1bdvW5+tQY4j8TZo0STZs2CC20WvKPZ5Kz7O2oIVLS5frmC1n+fnnn3Pd5rnnngt7/2PHjpWsrCzv19qlNJwJgsPhvl401Lz88sthb5uRkeETmtq3bx+RYwJsQAgCEHVamctd0ahTp05yyy23RGz/3bt3z/dNqc4U764CpV32Yr3whHb1yWsXGw0zl19+eVhlsrVwhZsGWC1okRu9ude5duLx/OgNuf7c4QSUa6+91mdQvFbm++mnn3LdTs+9lny3kZa51+vPoa0u2g02HNrqOWjQIJk7d65Z9MOOcFpptPhKOK102tLp/77oexwp/vt65plncq1upzT8+H+ocM0110TsuIBERwgCEHUffvihz9f33XdfRPffr18/n2pQOv7Dv+UpkLffftuU6nbfqA0ePFhiXc2aNX2+Hjp0aNCKUTrGRSelPPvss81EqG46riXQdldeeaVPF0WtlqcFBUJVy9IucLpOLFSu8j8/L774os+n/P70vHTr1k3efffdHM9t2bIlx/e0e5MWoXDTn33Tpk0hj6t///5F0g0sVvm3/D744IMhKxUqveY0nLrfvxtvvDGsymx67ffq1StkSWlt/dN1dP4oR8WKFX0mUC4oncNJKxC6f+9uuOGGkKXY9Tk9Bnf3TJ2z65JLLonYcQGJjsIIAKJKP/12dzfT7lZ6w5yX2eL9dezY0ecmSLuwPfTQQ6ZVxx0MfvjhBxkxYoTp2uK07uinq3rTq+trOWQ3/dQ11ASIevPrrjqlNynRaPnQqmfafceh51Jvsnr27Gn+1Zs4vWnUFpBp06b5dA/TsKhdcpR+Gq2tcnoDr9XSnHEbGga1y44WrXB88sknppughkvdxinzrKFHuyDee++93rEL+vruqmxFTUuB6/vtFDnYuHGjKYGtn6Jr1zi9XrT1Twec6zXirgjnPj/Oe6xltrXlQeevcjz//PMya9Ysb1clHVTfsmVLc73pJ//uKnJ6/d9///3e19ExV7pdrFd0izS9vtLT000XL+f6O+ecc6RPnz5m3JaOa3MKTOjfDb129XrT98hdBOS2224L+zV1bJj+/mvp/UsvvdQ78bKGDH0/9G/GkiVLcrTU6DUcKXotapdSvS6dllj9YEj/luhEzeeee64puOE+Lr1eFi9e7N2H/r3TfRRVWW4gIXgAJAT9dXaW3r17h72druveNr/OPvtsn/0cPnw4rO1Wrlzps10klv379+d4HT2eCy+8MOD6pUuX9jRt2tRTv359T1JSUsB1br311lx/Ft0+3Pchv+d99uzZPtuNHTs2xzqHDh3ynHnmmXk+bzfddJNn4sSJAZ8L9LPoOQm0brly5TzNmjUzS/ny5X2eq1mzpmfChAm5/uz6c7nX0Z87XOG8B0OGDMnz+WnVqpXnl19+8RQvXjzHc/re+9NzGWjdEiVKeBo2bOhp2bKlp1q1aj7PJScne6ZNm2b+zc/PHgvcfwsCnZdQ9u3b52nXrl3A81+yZElzTem5099Z/+erVKniWb58eVi/n2lpaWY/7u3Lli1rvt+8eXNPxYoVAx7DNddcE3T/69ev91l3+PDhefrZH3300YCvWaFCBXNMoY5LtwWQN3xkACCqcusiFCn6CfLUqVPNmJ5AYwq0Apx+8ur/6bsO1tYB1FqoIV7op8ZaVc+/nHUwOl+QjnnQrn9XXHGF+eQ5HHpOtOui/xgpbcXQylu6uMc2aEvZF198YeatiTYdF6atDOHSVi8tM64tPtqKGA5tQdP3oVy5cj7f19YxbRnSVgh3dyZdT7tgakuarbQlRs+zu5XR3fVNryk9d+7qh07FRr22/Cc2DkYrqGlXO50vy6Hj2rRVVFuCA7VUaguTTkBcWLR1R3+n/Cfc1ZZxPaZAx6W/uzonmG4LIG8IQQCiatu2bUX2WnrDoOM6tHuW3uiHKnCgpWt1LNHq1avlrrvuknhTq1YtM75Ex1VUqFAh4Dpa3Upv1LWSlq6n50MDlIbFgQMHSp06dcw50xtMd0U4N+1GpN25tCuY02XHn76+TtyqN/3arS4WaCieOXOm6a4YLJRp1yINSlq6XcOMM6fM8OHDTdejtLQ0c35SU1PlggsuCFqUQ6vuaZeuYO+DM5Gtdm/S98N2GoT0fGu3Lz3/oeZY0nEwGhw1HLlLk4dDu7YuWrTIdFEMVoZfr4GzzjpLvv32W9NNr7C7m+nviV4vOiYoVJc7fU7HPum6+ncKQN4laXNQPrYDgLinkyXquBinfLb2t9dPiHXsgU7UmJcJLmOZtsZoINIxOVrdTG/mdeyElhJ2z/lTUFpO/LvvvjPjjXSwuc5cr0GqQ4cOESsnXBi0ZUZvJvX86DggDYN6fvQaCDUGLK+0JUPnKNJrTsO/tvxoWNWyxikpKRF7nUSj15VWfdu8ebMpGqDjsjS06PgtbfkJt1qje8yeFgL55ptvfKr/6WtoK5O+NxpYtYCG/o5Ea94d/Xuk4530unRaDPXnPv7446VNmzZBP3QAEB5CEAAASHihQhAA+9AdDgAAAIBVCEEAAAAArEIIAgAAAGAVQhAAAAAAqxCCAAAAAFglrqvDaXlRnTBNy9hGq4QlAACIfVu3bjWlsJVOSBpsbiAA8UtL3Ovvuc43phN3J2wI0vBz9OjRaB8GAAAAgBihExs7H3oEE9czbTkhSH9QndQs2jRP6mRuOvlduJO3Fabs7OyYmYCPY4n988L1Gx/vUywdSywdD9dv7L9HsXg8sXIsXL+x/x7F4vHEyrF4Yuj+d8uWLSYbhDPZeVy3BKWmppqZyXVG702bNkX7cGTXrl1mJnadhb5ixYrRPhxJS0uTzMxMiQUcS+yfF67f+HifYulYYul4uH5j/z2KxeOJlWPh+o399ygWjydWjmVXDN3/5iUbUBgBAAAAgFUIQQAAAACsQggCAAAAYBVCEAAAAACrEIIAAAAAWIUQlMDS09MlVnAssX9eYk0snRuOJT7OTSyJpfMSS8cSa8cTS8cSS2LpvMTSscTa8cTSscQjSmQnaIlAIK+4fhHPuH4Rz7h+Ec9i6fqlRDYAAAAABEF3OAAAAABWIQQBAAAAsAohCAAAAIBVCEEAAAAArEIIAgAAAGAVQhAAAAAAqxCCIqhUqVIybNgw8y8Qb7h+Ec+4fhHPuH4Rz0rF6f0vk6UCAAAAiHtMlgoAAAAAQdAdDgAAAIBVCEEAAAAArJIsCSA7O1vS0tICPpeenm4WAAAAAPEtIyPDLMEyQbgojAAAAAAg7lEYAQAAAACCYEwQAAAAAKsQggAAAABYhRAEAAAAwCqEIAAAAABWIQQBAAAAsAohCAAAAIBVCEEAAAAArEIIAgAAAS1YsECKFy8uSUlJZqlXr57s27cvX2fr9ddf9+5Hl/T09Kid9Tlz5niP45xzzonIPnU/zj51/wBiW3K0DwAAAMSm1q1bS79+/eSVV14xX2/cuFGeeOIJGTFiRJ72s2vXLnnggQe8X1erVk3++9//+gSI2bNne7/2eDwROX5Ezp9//ik1atSQo0ePypo1a+T444+PyH737NkjJ598sqxevVrat28v3333XcD1XnrpJXnxxRcL9FqXXXaZPPnkk/naNjs72xxfXk2bNk1OOOGEkOt8/vnn8uGHH8oPP/xgXkfPSdWqVaVJkybSqVMnue2226RcuXK5vtb5558vGzZsyNPxDRs2THr27Bnwud69e8v333+fp/316dNHBg8eLPGAEAQAAIJ67LHH5KOPPjI3Z+qpp54yN0cNGjQI+6xp4Nm2bZv3a70RPeaYYzjrcUSvAQ1AkXbXXXeZAJSbv/76y4SvgnBfg3mlr52f1z948GDQ5/RDhSuuuEIWLlyY47ktW7aY5ZtvvjEBUJdLL7006L70vdEAGer1Avnnn3+CPqcBKK8/844dOyRe0B0OAAAEVblyZXn22We9X+/fv18GDBgQ9hlbu3atvPDCC96v27RpY0IU4oe+5wVthQnk448/ljfeeEOK8lrOL72OI0k/VDjjjDNyBKASJUpI9erVfb73xx9/SNeuXaV///5B97dp06Y8B6BQjhw5kudWpXhDCAIAACFdc801pquN++Z1xowZYZ21e+65x3tzpuOLRo0aZcbNID5oC4N2x8rMzIzofrWVo2/fvnnqtqXdJPOyaBc+J1DUrFnTp0tmQUKQfigQ7jE0a9Ys4P60m6meA8d5550nS5YsMV3hNCDpsb/zzjuSkpLiXUeD6Ntvv53r8XXp0iXs40sPMjZPW6kOHTpkHp900klh7+/pp5+WeEF3OAAxKatR64jsp/aqBRHZD2A7DS8nnniiHDhwwHytn0ovW7bMfHIdjHbl0cDk0Jvpli1bBlwPsePw4cOyYsUK+fLLL+Xll1+WdevWRXT/erN8ww03yPbt26Uw6fWmXeA0dL/11ltSpUqVfO/LHTKOO+64Ah3X8uXL5ZNPPvF+3atXL3N87g8HdEyQjtW5+OKLzdg8p8vg/fffLz169JCSJUsW2vEVxv5iES1BAAAgVzq4e8iQId6vV65c6dPNLVALwt133+39Wj/RfuSRRzjTMe7mm2+WMmXKmMA7cODAiAcgpeNbnJbEY489VgrDpEmT5IMPPjCP77jjDrnwwgtjJhRMnjzZW/xDz/Xjjz8etHVUx865W3+ysrICVh8kBOUdLUEAACAsWvVpwoQJ3k+lH374Ybn22mtNVyN/Otbj559/9n6t3WQqVaoUsTOtA7q1opyOhdi7d6/Ur1/fVCzTSmOR7m6n4yN0kLi2jugAfe1i1bx5czn99NMl0Wg3LG0JKiy//fabDBo0yDxOTU0148vyMsYsHNqdzOnmlZaWlu+KcMFCRl6KggSiVeAcV111VcDfHzcdO6Sv6QRSvRY7duwY9PhoCQoPIQgAAISlVKlSpluccwP277//mhta/3EKWhL7wQcf9H6tpYWvu+66oPsdN26ct1iC/qtdg4JZv369CWNarcwZs+DWuHFjufPOO02LRnJycoHDj5YH1xasQJXFtHVMWzUK2soQa+O/WrVqleP7BRlP49CulLp/LbSgQXXs2LEmxEbaLbfcYqqUaVdNDe2lS5cu0P70Otdw6LRoli9fvkD7c7eutWjRIqxttBups51TqTFYCIpE+fK1Ed5fLCIEAQCAsGmBBG390ZtLNX78eHPT2bZtW+867tCgQSQjIyMiZ1i7UF1++eVm8Hgw2k1PWwF0LJLOvVKxYsV8vZbeqHfv3t3M4RKMtohddNFFhVI5LVq0ZHMgkQhBQ4cOlV9++cU81q6SWgxAA3AkaTh2xqFpEA40Bi2vfv/994i2srjLUmtLVTj+/vtvn3m2gh2jhkttFY21nzkWEYIAAECejBw50oQDvTHTsQ233367/PTTT1KsWDEzr4g7FOh4DK0uVVDahUirXjmV5nQshc6bot3SdNyEFmn4+uuvvV31Zs6caQKbbqdV6fLqpptu8glAGqZ0Ulct8a0tAQsWLDBjTjQs6Q098x6Fpu+NU2pdxxvp/FORpi13TlgrW7ZsRIJboK5mu3fvNte4FvTQ0K2tRBpMNHBdcsklcv3114dsfdJunM6cS+EEFm1ZXbRokffrRo0a+TyvXTSdkFSrVi3TYqsfUui4KD0+LXWt5cG15VJbLfXarlGjRlg/s/5O16tXT7744gvTxVX3pwFJJ2/VY9dWYZ0gNS5bizxxrHbt2jqqzPwLILFsOuH0iCwACscrr7xi/h/sLK+++qr5fteuXb3fq1Gjhueff/7JdV9jx471btO7d+8cz+/fv9/TsGFD7zoXXnihZ/369TnWO3jwoOfxxx/3JCcne9d97rnncqw3e/Zs7/Nnn312juenTZvm87M1a9bMs3bt2hzrzZ8/31OtWjWfdXXR/Sca98+3Zs2aPG27Y8cO7z1bqVKlPL/88kvA9759+/YFOsa33nrLu6/Bgwd7IuWpp57y7vfUU0/1pKSk5HjP3UutWrU806dPj9jrDx061LtvPX9ZWVk+zy9cuND7vJ7nFi1ahDy+MmXKmJ8pmG3btnnXLVeunOess84KuT/9fRs4cKDn0KFDnnjKBrQEAQCAPNOuRjqmQ1tEnK5OWoLYXRJbW4zy2x3N7d133/XOXK+tCFOmTDEtQf50DIiOF3K3COj8Mto9LlQpb3/uuU7q1KljWpMqVKiQYz0tXfztt9+aY4pUMQH9tL4gtJWhdu3aEku0u6RWNVPaAqTnK9K0hXD48OHmsRbguO+++yK2b3dLkLtFRlt7tJT11q1bfd7/zZs3m9LWOs/P1VdfXaDXnjhxok+rmZYW19aeYMen59k519oCqkU8tPudFg9x7Nu3z5wfHWOkY/xC/bza9VSvcadVSFu8tPXT3aVPf3b9XddWoqlTp5r14kF8HCUAAIgpeqMzevRob1czHYiula4cZ599thkEHwnaDcfx3HPPBQxAblrK2+lm5N+VKDd6A+met0j3FSgAOZo0aWLmbYkUDXsFWQqzslt+aFB2SlVrd0J32fRI0mtRu32pe++9N6LdE92hQJ166qny1VdfmYDwxx9/mH+XLl0qN954o3cdDeLaTUwrCuaH081S5wpyymnXrVvXhPrcjk+LN+h516CigUwLO2g3Ua2S5+6m98orrwScfNV/f3r9azl87fangU+73um5fu2113zO82effSb//e9/JV4QggAAQL5oZSudNNXhjHPQYgg6yWYk6KfWCxcu9I7zOPPMM8MKaO3atfN+/d1334X9evPmzfM+1hs8941tMHfddVfY+7eJjh3RSn1Kx6RoEYRIly9XGkIeffRR77xDkX4/3KFAC0fMnz/fFHVwWjx04lL9XXjzzTdNYQb3tRsotORGQ6OG6+eff94bgPTnmj59esCxPO7j0+20NL1OwKrjdpQeZ8OGDU3rjz7nLqzwwAMPeMfZBdqfvt6PP/5o3kf3nE4ayPr27WtKnutrOp566ilvJb1YR3c4AACQbyNGjJD333/fp9Sx3oQ2a9YsImdVq4k5pbC1lSPc/WrLlMNpIQiH3tQ59OZOB5nnRgs/6I2mEwILwrnpjXfaEqJl0bUVwml10K6FhUG7jDllo7X7mXPzHynaWqI/j9JwHar0erdu3czPrV3hlIYibY0Mp1vo4sWLzYcKc+fOzdHypPtr2rRpwO10niUNPUp/P7SLXjBaVOGJJ54wrVRKW7K0Ves///mPdx1twe3QoYN5rAUPdD6nYHSOI/3AQ4uQOIFUQ9xtt90msS4hQpBe+MFKDGo/YGfCLAAAEFlaKU0/YXY+8Vf5+fQ7GPenyvqJtTM2KC+0elZ+1g23NLCON9JxOHpDif/RlhmnVU1Lqkeyy6C/119/3fvYCQORpPNc5cVDDz3kDUEa3HVMjVaNC0aDos6rpXNOuYO0tjDpGDdtrQk1pk0rJOaFjisaPny493qdNWuWTwjSViNdwqWtYhoOdRJXZ3+FGYK05H6wsvuB5lBK6BCkfR8zMzOjfRgAAFjJ/1Pugk4m6eYegJ1f/t19QtEuTO5PucOlg9UJQf/X8qZzRTndpiI1T1Qg2r1Lu2spbSk57bTTJNq09US7bjrFCDZu3Biy9UfH0vmHe+12p2N4GjRoEPHj0y6JzZs3916voY4vXNoa6oSgSOwvlFANHNpq5RSGyA1jggAAQMzSm0mH9vrQ7mJ5XXTS1PwEui1btoS9nTM5LP43sadToEFviHU8kN54B1p69+7tPWXaDcz9nLZYRLsVKD/02N1z+bgnOnXTuXe0lckdgE4//XTTgqZdTAsjADkaN26c6/FFc39FISFaggAAQGJyD8bWAdvaXagwS/BqmW/3wP5w6HiRSLUCJWKJ7MKirXY6KajSa0IrqcUKd0lq9zXl0KDTtWtXbyuljj17+OGHZeDAgfma3DfSxxft/RUFQhAAAIhZ7vEOBw4cMAUYtItVbjQsOUUG9AY53KpkLVu29D7W8sb6mrkVR9D5USJVmjo/Y57cYqFEto5lCXdMiRYNcFrRtHyzexC+znETirbwOa0OWn67MMLfs88+6+1up3P/hBO0tJCHO0DXq1fP53kNPlrAwQlAGvS1VUhbgfJKK8Zp1T2lLUfuOYVCWeEq3e0+Pi0n/8wzz3hLY2sZ7ILsL5YRggAAQMzST5W1Sptzk6U3fDqIPLdPpfVGbPv27Sb86BiVcCuT6Y2ofhKvrTs7d+40ZY9zG+T94osv5uEnSnw6NkfnpQmHvp9Ol7hWrVrlqZy5e2Lec889VwqDXgfvvfeeeayl2rXIQ26BWgshOGFUCxr4F1bQ8OaMm9HA+PXXX/uE77z+fjjHp8elZatz60anxT+WLl3qU9jAob8nkyZN8n6AoD+vUykuGA1z7op27v3FMsYEAQCAmHb99dd7H+tg8dzG6miVLQ1AzqSteSnNrOWFL7roIu/Xjz/+uGmtCEYDlk5MGSn5GfPkXuLlU/hIhBOtQuZwzwsVSZdffrm3+6W27mgozq0VyD131qWXXpqjUIi7UMQ999yT7wDklM92Qo++/7l9QKC04tyu/39Na+uZO+Ro69tZZ53lU+kxt9ZFbTlyWr50DJ9284sHhCAAABDTbr75Zu/M9DoPiX7SrFW1gs3pMnToUO/XznwoeaHzrji0+12bNm18JpB0VybTT/m1yxyKlnZRc7rC6bw9+a0KpwHCKcQQqAVFy6RrkHFoVbLJkycH3JdeKzpPkDPXlB6Xlst2W79+vc+EvAUdx6QBzT05rI6RGjJkSMCKiDqGatCgQfLGG294v6flt7U1Ktj1P2fOHLnpppu88z25aTjSAKRjmRx33HGHz2SssYzucAAAIKZpl59XX33VlBJWy5cvlzPOOMOM0WjRooX5NFvL4n722WdmTINDu1lpd5680q5Vuq3TwqPTcJx88snm+/q6Sm9ktRuTdr3TG9FOnTrJ559/HrGfGaF9+eWX3sf63rirCEbaCy+8YN5rbT3RcNG9e3cTjPV60JY3bZnUa2TatGk+YeHpp5+WE0880WdfS5Ys8fm6c+fOYY9Xc2jId1fV02A2fvx479glnQxVu8hddtllply3hh89Pv0Z3BMHd+3aVfr165dj/126dDFhbsqUKd4ui/qz6e+fFu7QFif9HdRuf/qvuyupTp4cLwhBAAAg5l155ZVmjI6Oz9GiB9rtSMeEuMeFuF1wwQUyevTofL+ebrtjxw759NNPzdd6czt16lSzuOkNrA6e10/9CUFFZ+bMmYXeFc6h3Sk1BGjoduat+uGHH8wSiIZi7bbpbqEJVnEwUAtjXufO0jFsn3zyiXTs2FF+/fVXb4uTXpfBXHXVVfLWW28FDWDaoqoBTasNOpMWv/zyy0H3p91OtYUstyIisYTucAAAIC7op9Y6OF27wwW7edNPqnXg+YwZM3J088kL3VY/CdcbP52UPRDtPqWtT+4xICh8Gkjnz59fZCHIeQ0NMDqeply5ckHDz4UXXmiOTcf6FOV8UjVq1DBdRLXF1F1hL1C1RS188N5770mZMmWCrqfjmHTMla6rhUmCqV+/vvnAQEOpu5x9PEjyOOUf4pAzK6w2g2s/TACJI6tR64jsp/aqBRHZD4DYsnXrVtMdZ/PmzWaQvE5OqTdrOoYj0vOsaMuTdn/Trj9acEFv9rQC2plnnpnnrkyIf9oSo9UK161bZ6q8aWlvp8CAFtaINu2yp9eqHp+2COnYHQ1J2pUz3NLl/te/e3/aBVQLKGhRBv/ufvGUDQhBAGISIQgAABRWCKI7HAAAAACrEIIAAAAAWIUQBAAAAMAqhCAAAAAAVmGeIAAxWdAAAACgsNASBAAAAMAqhCAAAAAAViEEAQAAALAKIQgAAACAVQhBAAAAAKxCCAIAAABgFUIQAAAAAKsQggAAAABYJSEmS83Ozpa0tLSAz6Wnp5sFAAAAQHzLyMgwS7BMEK4kj8fjkTiVmpoqWVlZUrt2bdm0aVO0DweAiGQ1ah1T56H2qgXRPgQAABBj2YDucAAAAACsQggCAAAAYBVCEAAAAACrEIIAAAAAWIUQBAAAAMAqCVEiGwAAwJaql7FWGfPPP/+UBx98UGbMmCFbt26VLl26yKRJkwr1NefMmSNnn322eTx79mzp0KFDob4eEg8hCAAAAPly5MgR6dy5syxY8H+ha9u2bRE5mxs2bJD69et7v47jWV0QgwhBAAAAyJdFixZ5A9Cpp54qt956q5x00kmcTcQ8QhAAAADyZfXq1d7Hzz//vLRv354zibhACAIAAEC+HD582Pu4Tp06ET2L9erVowscCg3V4QAAAABYhRAEAACAPBkxYoQkJSVJ7969vd/TIgb6vXPOOcdnXS2UMGzYMGnbtq3UrVtXSpcuLbVq1ZLTTjtN+vfvLytXrgz6Og0aNDD7vOGGG3iHEFF0hwMAAECh+Prrr+Xiiy+WAwcO+Hx/y5YtZvnpp5/kpZdekjFjxvgEKqCwEYIAAACQJz179pQzzjhDZs6cKSNHjjTfGzdunKSkpMixxx5rvtY5g6666ioTgIoXLy5XXHGFnH/++VKtWjXZsWOHmetn4sSJcujQIbn55pvNvD/ukthAYSIEAQAAIE+OP/54s2jQceiEpVrMwDFr1iwTdtTLL78st9xyi88+tIvbeeedJ9dff70JQnPnziUEocgwJggAAAARt2rVKqlcubLUrl1b+vTpE3AdbR1yrF27lncBRYYQBAAAgIgbPny47Ny5UzZt2iQlSpQIuM6///7LmUdU0B0OAAAAReaff/6R33//XZYuXSoZGRmceUQFIQgAAACFZtq0afLJJ5+Y0KNd5LR1CIg2QhAAAAAiTucH6tatm8ybN8/7Pe0W17RpU1NUoVmzZnLRRRflmFcIKAqEIAAAAETcZZddZgKQTnaqJbC1GlzLli2lVKlSnG1EHSEIAAAAEbV48WL5/vvvzeN7771XnnzyyYDr/fXXX5x5RAXV4QAAABBR7nLXZ555ZtD1Pv30U848ooIQBAAAgIhyT5qqk6AG8u2338odd9zh/XrPnj28CygyCdEdLjs7W9LS0gI+l56ebhYAAAAUjZNOOkmqVasmf/75pzz99NOmSMJ5550nZcuWlfXr18v06dPlyy+/lOTkZCldurTs379f3nnnHTnhhBPk3HPPNYUTgEC0rHqw0uqaCawKQSkpKZKZmRntwwAAAICICTYTJkyQiy++WA4dOiRvvfWWWdyqV68u48ePl8mTJ8vo0aNl69atpoDC888/L/379+c8Is8NHKmpqZKVlSXWhCAAAIDCUnvVAk5uPnTs2FGWL18ujz32mCxYsEDWrVtnwpGWyNbS2f369ZPy5ctL27ZtZffu3fLxxx+blqLatWtzvlHokjwej0filJP29Jdl06ZN0T4cACKS1ah1TJ0Hbl4AALBDah6yAYURAAAAAFiFEAQAAADAKoQgAAAAAFYhBAEAAACwCiEIAAAAgFUIQQAAAACsQggCAAAAYBVCEAAAAACrEIIAAAAAWIUQBAAAAMAqhCAAAAAAViEEAQAAALBKvkPQgQMH5Omnn5YuXbpI06ZNpVy5ctKkSRPp3r27vPTSS3Lo0KGA2x09elRKly4tSUlJYS0bNmwoyM8HAAAAAD6SJR/mzJkjffv2ldWrV/t8f+XKlWaZPHmyjBo1SkaPHi1nnXWWzzobN240AQoAAAAA4iIELV++XC6++GLZs2eP+bpt27bSrVs3adCggaxbt06mTJki8+bNkxUrVpj1lixZIg0bNvRu7w5OGpLq1asX8vVSUlLyeogAAAAAELkQNGzYMG8Auvvuu+WZZ56RYsX+r1fdwIEDTTe5QYMGye7du+Xaa6+V+fPnm65t7hCkX/fs2VPKli2b10MAAAAAgKIZE7Rv3z6ZOnWqeVynTh157LHHfAKQE27uu+8+6dSpk/l64cKFJgQ5nBCUmppKAAIAAAAQ2yFIu7YdPHjQPO7Ro4cpcBBM165dvY8XL16cIwQ1atQoP8cLAAAAAEXXHS47O9v7+MQTTwy5bs2aNX1akIKFIC2SoGOJduzYYarLValSJS+HBAAAAACFF4JatGghY8eONY8vuOCCkOv++OOP3sdO4Dl8+LAJPKpUqVJyyy23yJgxY3zKaWt40lamRx55xJTdBgAAAIBISvJ4PJ6I7lFENm/ebFqK/vrrLylfvrysX7/etPCsWbNGTjjhhLD2oVXjJk2aJK1btw66jo4rysrKktq1a8umTZsi+BMAyK+sRsF/Z6Oh9qoF0T4EAHHuwJsNJN6U6vO/D50Lm1P4avjw4aZ4FhBNeckG+ZonKBRt6encubMJQOqOO+7wdnHzn1eoT58+csUVV0irVq1k7969snTpUhkxYoQsWrTITJJ69dVXy7Jly3JtEdIct2vXrnwfs7ZK6QIAAAAgOnSYTEHmE81L207EQpAWTNAJUh988EFTGlt17NjRfDLgWLt2rSQn/+8ldV2dcNWhQUkrzmlVOQ0/H374oQlUDz30kIwcOTLXlqdKlSrl+9j1kwv3cQIAAAAoWo8//rhpEImb7nCTJ0828wJpyHFcfvnlMm7cuHyN69FQ07hxYxOmjjnmGPnzzz+lePHiQZu8atWqZSZxzS9agoDIoTscgERDd7jg6A6HWGoJatq0qckRhd4dbsWKFXLbbbfJN9984/1eSkqKPPfcc6Y1J7801LRp00ZmzpwpO3fuNOEqVElt/QWsWLFivl8PAAAAQHQVtGHCCeURnyfI7bXXXpNTTjnFG4AqVKggDz/8sAksBQlADi2X7dDy2QAAAAAQCfkKQRkZGdKvXz/v/D9a4OD3338344EiVdZay2k7aOUBAACIT7NmzZLrrrtO6tevL2XKlJHKlStL8+bNpX///jmKZgVy5MgRM0XLf/7zHzOVSsmSJaVatWrStm1befTRR+Xvv//Oddy6fniv07tolWI9Bj2Wc845x9zT5tb9SkeOvPfee9K1a1fTzap06dJSt25dOfvss2X06NHesfCIL3keE6QFC6688kpzQeh4nffff1/OP//8XLfT6m/t27c3cwLpRfzkk0+GXF8vzNmzZ0uJEiVMl7hA4YoS2UDsYUwQgETDmKD8jQnScHHjjTfKxIkTg26vBbOeeOIJGThwYMDndVzHJZdcIj///HPQfWhxrQ8++MDcO/rTD+n1+xs3bgy6/XHHHSfz5883wcrftm3bTPj54YcfQg7jmDJlipx++ulB10Gcl8g+evSoDBkyxAQgnf/nu+++k2bNmoW1bdmyZc1F8vnnn5uqb4MHDzYhKpDMzEz5/vvvzWO9cJk0FQAAIL4MGDDAG4COPfZY0xqk06Joy4mGjvHjx5ueP/fcc4+pEKwfsvu3AOkH5zpdijPoXQtv6VyUOpXKV199JV9++aUZNqHr6Vh1nWfSsX//fhOgnACkj3UaFx2/np2dLe+++675wF2D0g033CCfffZZjtfX1iMngOnjCy+80LQi6evPmDHDLDoQv0OHDrJgwQI56aSTCv28IjLyFII0wOiEp0q7voUbgBw9e/Y0+9izZ48ZN/TJJ5+YJk03vZD0QtQWI20Fyq08NgAAAGKLVu3VLmhKu759+umnJjw4brnlFunVq5dcdtllpjubfsiuLS7u+8IxY8Z4A5DOK6ld4vRDdce9994rzz//vNx9990m8DzwwAPyzjvveJ/XoOVUD77//vtN1zk3narloosuMkFq+vTpZpiHdpVzvP766yYAaYVi7fmkx+qmr/vxxx+bY9PX1+EhCxcuzNPgfMRJCNK069D+nO6vQ2nRooXUqFFDrrrqKtNc+dFHH5ltteLbzTffbP7VyU71QtcL3pn4VH8h9BcHAAAA8UM/LHfGd2uYcAcgh/b20XBy3333mdaYN998U2699VbznG6rc0U63d30/tAdgBx33XWXqSY8bdo0mTBhgulp5HxIv3jxYu96/q1MSsPKnXfe6R17rl3fnJYkba1yXl/vR/0DkEODm/4MWhzsp59+kl9//dW0VCHBQpB7HiAtjBAuHUymAUgvtrffflv++ecf+frrr01T4tChQ3Osr13tdLKk9PT0vBweAAAAYoC2wqizzjpLzjjjjKDraejRAKGhQ8fdOCFo/fr1snXrVvNY7wf13jAYDVEagnS4hnZJc0KQfgDv0JYc/VDe38UXX2wWf9pNTuepVNdee23In1W76OnP4GxHCErA6nDuEJRfOr5H+3Dq0q1bN9PSo+W19eLWvp56oWuKvv3222lOBAAAiDNaDEuHN6iTTz455Lp6/6cV2/zvM91V43Lbh/t59z46duwo1atXN48fe+wxU7hA57JcunSpGe8TirbqOPT+VD/ID7a4w5UT3JBgLUGrVq2K2Aufd955ZgEAAEDi0CDiFB9u0KBBrutrV7klS5Z4x50r9+Pc9qHd2bTYllYTdm+n1d50zI6ONV+5cqX8+OOPZnHCV7t27Ux3Nv1QXosluDmtQHmlvZ2QgCEIAAAACCWPs6+YMtnKPV9PJPah2rRpY8acT548WaZOnSpffPGFCSra/c6p7qbV6bQ7m1azc2hxLoeOZQ80HikQLc2M+EAIAgAAQMQ0bNjQ+1inRcmN04XN6Rbn/1j3EWg8j+Pff//1tty4t3MHmh49ephFu8FpKJo7d64JQFoVTqsW6zxFOobommuuMdto0S73sVCoy/IxQQAAAEA4c0MqHX8TigYQZ7iFO3i4g1Ru+9CudA73PrT0ts4h5O6ipuWuW7Zsacaea9nuRYsWeVt5xo0bF3A/On9lKFpVzmlV0i55iA+EIAAAAERU69atzb9z5swxc+cEk5GRYbqmKS1c4B4n5BQ10HU0LAXzxBNPeB+fdtpp3sc6J2XVqlVNS87Ro0cDbquTm6alpZnHOoGqQ1ueSpcubR4//fTTIbvnDRo0yMw3pFXi3N3oENsIQQAAAIioRx55xLS6OJOS6rQo/rRSsFZtUzo/j3v6FQ0TI0aMMI+3b98uN910k5nM1N8zzzxjxvko7e6mrTwOp1S2dpUbP358wOPUrnG//PKLT3BziiroWCGnUpxOxBqoopyOF3L2rZOmhirljdiS5MnryLMYkpqaKllZWWYQ2qZNm6J9OABEJKvR//1PJBbUXrUg2ocAIM4deDP3CmexplSf3MfiRIKWiFbDhw+XYcOG+Tynoea1117zTnjaq1cvOeWUU0zLz7x588zkpk6w0Hl8NES46XPaUuN0R9NQo60tOj5H5xHS7mc676QqU6aMLF++3DvZqdI5g9q3b28mXtVQdd1118nZZ58tlStXNt3W9Pl33nnHjCkqWbKkzJo1y1SMc2jrU+PGjc29ptPKpJOmalc57Wqn4WvKlCnmOLWCnc6N5LReIfazAYURAAAAEHEvvPCCCRsffPCBGZvz7LPP5lhHw9Err7ySIwApbUnSSVAvueQSM4fkb7/9ZhZ/Ojmphhl3AHJadh5//HEzmeqhQ4dkzJgxZvGnY4LefPNNnwDkzG2pE7hqiW0NW+4S2246j5C2CBGA4gshCAAAIAZaVRKNjqnRFp6ZM2fK2LFjTUU2LSKgrTJ16tQxk5kOHjzYVGULRoONFj7QogUaprRIwl9//SUVKlQwLTI6z89dd90lpUqVCri9dmm7+OKLTQDTbbV1QIOZthTUrVvXzFl56623mjAWiB6nHr+Gp3fffdd0n9NWIN1WX7979+5y/fXXe7v+IX7QHQ5ARNEdDgAAxHp3OAojAAAAALAKIQgAAACAVQhBAAAAAKxCCAIAAABglYSoDqcz/Dqz/fpLT083CwAAAID4lpGRYZZgmSBcVIcDEFFUhwMAANFAdTgAAAAACIIxQQAAAACsQggCAAAAYBVCEAAAAACrEIIAAAAAWIUQBAAAAMAqhCAAAAAAViEEAQAAALAKIQgAAACAVQhBAAAAAKxCCAIAAABgFUIQAAAAAKsQggAAAABYhRAEAAAAwCrJ0T4AAACAWNbjhSMSb97rXzzahwDENFqCAAAAAFiFEAQAAADAKoQgAAAAAFYhBAEAAACwCiEIAAAAgFUIQQAAAMizcePGSVJSklSrVs18vWfPHnnyySfllFNOkYoVK0qlSpWkRYsW8sADD8j27duD7ufIkSPy/vvvS6dOnaRp06ZSoUIFqVy5sjRr1ky6du0qn3zyiRw9ejTkscyfP1+uvfZaOfnkk83rVq1aVU477TS57bbbZP369YW2LeIXJbIBAABQIOvWrZP//Oc/smLFCp/v//LLL2bJyMiQyZMny7nnnuvz/O7du+XMM8+UpUuX5tjnP//8I5mZmTJ16lTp2LGjfP7551KiRAmfdTwej/Tq1UveeeedHNvv2LFDfvrpJ3njjTfk7bfflh49ekRsW8Q/QhAAAADy7cCBA9K5c2cTgBo1aiRXXHGFnHTSSbJy5Ur57LPPZOHChfL333/LxRdfbNapV6+ed9t+/fp5A9CJJ55oQkmDBg3k0KFDsnz5chkzZoz88ccfMnPmTHnqqadk6NChPq/98MMPe0PM8ccfLzfeeKM5hoMHD8oPP/wgb775puzbt0/69u0rZ5xxhtSvXz8i2yL+EYIAAACQb//++6/89ttvcuGFF8oHH3xgurM57r//frnvvvvk2Weflf3798uIESNMsHG6wX300Ufmcfv27WXWrFk5WnrS09NNoNq6dat88803OULQW2+9Zf5t0qSJCVvu177mmmukTZs2pqubtjh9+eWXcvPNN0dkW8S/hAhB2dnZkpaWFvA5/eXRBQAAAIWjfPnyMnHiRJ8goYoXLy4jR46Ub7/91nQv065lgwcPNi0ua9euldKlS5vlrrvuyhGAlI436tChg0yaNMms7/bXX3/Jhg0bzOOLLroox2urSy+9VLp3724elyxZMiLbIrq0a6UuwTKBVSEoJSXF9BkFAABA0dNWkmOPPTbo81ocQYscaOvP999/b0KQLjt37gyrpSkQLZ6gAUpbmLSlRrvc6ffcypUrZ1qnIrktoitUA0dqaqpkZWWFtR+qwwEAAKBAtOtYKDqmxuHfouNPxwPpOloIQccMTZs2LeB6xYoV8xYs0A/DGzZsKAMHDpQZM2bIrl27Qr5GQbZFYkiIliAAAABEjxYzyK3XjnaZ0/E1a9as8XlOv54wYYIpRqCFE7QQQm4lsR0vvviiKczw7rvvmopuOvZIFw05zZs3NxXrLrvsMlPyOpLbIv7REgQAAIACCWfMTHLy/z5714prjmHDhplx3cOHDzetMDpOp0aNGnLWWWeZqmw6F1G3bt2C7lPH8uhYJB1vdO+990rjxo3N9zVEaWnuJ554Qk4//XTTFW/btm0R2xbxj5YgAAAAFIhOKqolroPRyVJ13I3SsUDq9ddfN2WqVatWrUwVubPPPts7+apDq8Ll5tRTTzWLltHevHmzzJ0712z38ccfm8pyOtfQ3r17zfifSG6L+EVLEAAAAAok0GSnbj/++KP3sROCXnrpJfOvzr8zZ84cM7+QfwByAlQgWtRAu7Hp4u4+V6tWLbnyyivllVdekd9//91MtKp0rqEtW7YUeFskBkIQAAAACuTll182rSXBOC0+SruYuQskaCtM2bJlg1aG04AUiLbQVK1a1SzBiieUKVPGlLr2L6FckG2RGAhBAAAAKBAdM6NlsrWFxU1LYut4m/nz55uvr7rqKmnRooV5XK9ePfPv4sWLfcYJObT7XOfOnb0lsjVkeTwe7/PNmjXzKXKgr+Xv4MGD8uGHH5rHGrS04EFBt0ViYEwQAAAACkRbTbTC27Jly+Tyyy+Xpk2byqpVq+STTz6RhQsXmnV0Xp7HHnvMu835558vy5cvl3Xr1kn79u3lxhtvNPO8/Pnnn6Z7nU6sqgHIqSqnQWvAgAHSpUsXOeecc6RJkybSsmVLs652V2vXrp307NnT7OPw4cOyevVqeeedd8xrqBtuuMFbnKEg2yIxJHnckTrOOBMi1a5dWzZt2hTtwwEgIlmNWsfUeai9akG0DwFAnOvxQs5Wglj3Xv/ihf4aWrmtd+/e5rGGHZ3TJ9i4GZ2H57333jNd3xwabHT+oN9++y3gNlqqun///qY6XIcOHbytQBpelixZYh5r0NIAE2zckEPHG2kp7OLF/++8FGRbxH82INICAABEOVDEu5NOOslMOvrMM8/IlClTTLU4DTFa9EBbbgYPHmxKUrtpC4+Wpx41apR88MEHZoyQBqM6deqYVqJbb73V2wXtjTfeMOW0tZCBtjK5iyxoS9Lo0aNNENMbX63wVrFiRdPdTru9paenm+pz/gqyLeIfLUEAIoqWIACwg7slSEOPM8YHiIeWIAojAAAAALAKIQgAAACAVQhBAAAAAKxCCAIAAABgFUIQAAAAAKsQggAAAJBnvXr1MnP36EJlOMQbQhAAAAAAqxCCAAAAAFiFEAQAAADAKoQgAAAAAFYhBAEAAACwCiEIAAAAgFUIQQAAAACskiwJIDs7W9LS0gI+l56ebhYAAAAA8S0jI8MswTJBuJI8OsNVnEpNTZWsrCypXbu2bNq0KdqHA0BEshq1jqnzUHvVgmgfAgAAiLFsQHc4AAAAAFYhBAEAAACwCiEIAAAAgFUIQQAAAACsQggCAAAAYBVCEAAAAACrEIIAAAAAWIUQBAAAAMAqhCAAAAAAViEEAQAAALAKIQgAAACAVQhBAAAAAKxCCAIAAABgFUIQAAAAAKsQggAAAABYhRAEAAAAwCqEIAAAAABWIQQBAAAAsAohCAAAAIBVCEEAAAAArEIIAgAAAGAVQhAAAAAAqxCCAAAAAFiFEAQAAADAKsmSALKzsyUtLS3gc+np6WYBAAAAEN8yMjLMEiwThCvJ4/F4JE6lpqZKVlaW1K5dWzZt2hTtwwEgIlmNWsfUeai9akG0DwEAAMRYNqA7HAAAAACrEIIAAAAAWIUQBAAAAMAqhCAAAAAAViEEAQAAALAKIQgAAACAVQhBAAAAAKxCCAIAAABgFUIQAAAAAKsQggAAAABYhRAEAAAAwCqEIAAAAABWIQQBAAAAsEpytA9g8+bNsmHDBvO4Xr16UqtWrWgfEgAAAIAElu+WoAMHDsjTTz8tXbp0kaZNm0q5cuWkSZMm0r17d3nppZfk0KFDIbefPn26nH766VK7dm1p27atWfRxq1atZNq0afk9LAAAAAAIKcnj8Xgkj+bMmSN9+/aV1atXB11HA9Ho0aPlrLPOyvHcs88+KwMHDgz5Gk899ZTce++9IddJTU2VrKwsE542bdqUh58AQGHJatQ6pk5u7VULon0IAACgCOQlG+S5JWj58uVy8cUXewOQtuBoi9CHH35o/tWv1YoVK8x6a9as8dn+m2++8YabatWqycSJE2Xnzp1mmTBhglStWtU8N2jQIJk1a1ZeDw8AAAAAItsSdOWVV8oHH3xgHt99993yzDPPSLFi/5eldHcahjTEKO3yNn/+fElKSjJft27dWhYuXCglSpQw/7Zs2dJn/0uWLDHraHc6/Ve3DYaWICD20BIEAAASqiVo3759MnXqVPO4Tp068thjj/kEIKVh57777pNOnTqZrzXoOEHml19+MV+rnj175ghA6uSTT5Zrr73WPF6wYIH89ttveTlEAAAAAIhcCNJWmoMHD5rHPXr0kNKlSwddt2vXrt7HixcvNv9+9tln3u9dffXVQbd1P+feBgAAAACKNARlZ2d7H5944okh161Zs6ZPC5I7DGlr0RlnnBF02zZt2ni7zznbAAAAAECRzxPUokULGTt2rHl8wQUXhFz3xx9/9D5u1KiRt1iCSklJkQoVKgTdVp/Tognbtm2TlStX5uUQAQAAACByIei4444zSzgToGZkZJjH5cuXl3bt2vm0JNWoUSPXfeg6GoK2bt2a67pajGHXrl2SX6VKlTILAAAAgOjQeUh1ya+81HvLUwgKx7p166Rz587y119/ma/vuOMOqVKlinm8Z88e82/ZsmVz3Y+zjrNNbqGrUqVK+T7mYcOGyfDhw/O9PQAAAICCefzxx2XEiBFSFCIWgrRgwqhRo+TBBx+U3bt3m+917NjRJ1w4ya548eK5H1hyss94olBq1apl5i/KL1qBAAAAgOgaMmSIDBgwIN/bN23a1DSOFFkImjx5spkXaO3atd7vXX755TJu3DgpWbKkT+uOBiSnwlwoTmAqU6ZMrutqEYWKFSvm+/gBAAAARFdBh6g4hdUiXh3OnxY6OPfcc6V79+7eAKRFDyZOnCgffvihlCtXzmd9HR+kwhm/46zjbAMAAAAAkZDvEPTaa6/JKaecIt988423otvDDz9swlCwOYDq1q1r/v3jjz9y3b/O9upMygoAAAAAUQ1BWvmtX79+3vE6ffr0kd9//92MB/Jv/XFr0qSJ+Ve7xG3YsCHoehs3bvSOK9K+fQAAAAAQtRCk3dy04ps65phjZObMmfLGG29I1apVc922ffv23sezZ88Oup77ubZt2+b1EAEAAAAgMiHo6NGjpmqD1uDWsTrfffednH/++WFvf8kll0ixYv97SQ1OwYwZM+Z/B1esmFx66aV5OUQAAAAAiFwI+vzzz2XNmjXmsXZ9a9asWV42l5o1a3rHC82dO9eMK/Kn35szZ455fM0114Q1sSoAAAAAhCtPJbJnzJjhfVy5cmWfr0Np0aKFN8w8+uijMn36dNmxY4fccsst8sMPP0inTp1MK9O0adNk/PjxZj3tXqfrAgAAAEDUQpB7HiAtjBCu9957T6666irzuF69ejJ16lS57LLLZNu2bTJ27FizuGmZ7SlTpniryQEAAABAVLrDuUNQQbRr106WLVsmQ4cONV3qdHyRlthu3ry5PPDAA/Lrr79KmzZtIvJaAAAAAOCW5NEqB3EqNTXVzCdUu3Zt2bRpU7QPB4DO8dWodUydh9qrFkT7EAAAQIxlg3xPlgoAAAAA8YgQBAAAAMAqhCAAAAAAViEEAQAAALAKIQgAAACAVfI0TxAA5KbqoG0ROUnbn6zOyQYAAIWCliAAAAAAViEEAQAAALAKIQgAAACAVQhBAAAAAKxCCAIAAABgFUIQAAAAAKsQggAAAABYJSHmCcrOzpa0tLSAz6Wnp5sFAAAAQHzLyMgwS7BMYFUISklJkczMzGgfBgAAAIBCFKqBIzU1VbKyssLaD93hAAAAAFiFEAQAAADAKoQgAAAAAFYhBAEAAACwCiEIAAAAgFUIQQAAAACsQggCAAAAYBVCEAAAAACrJMRkqQAiI6tR6wLvo+qgiBwKAABAoaElCAAAAIBVCEEAAAAArEIIAgAAAGAVQhAAAAAAqxCCAAAAAFiFEAQAAADAKoQgAAAAAFYhBAEAAACwCiEIAAAAgFUIQQAAAACsQggCAAAAYBVCEAAAAACrEIIAAAAAWIUQBAAAAMAqhCAAAAAAVkmWBJCdnS1paWkBn0tPTzcLAAAAgPiWkZFhlmCZwKoQlJKSIpmZmdE+DAAAAACFKFQDR2pqqmRlZYW1H7rDAQAAALAKIQgAAACAVQhBAAAAAKxCCAIAAABgFUIQAAAAAKsQggAAAABYhRAEAAAAwCqEIAAAAABWIQQBAAAAsAohCAAAAIBVCEEAAAAArEIIAgAAAGAVQhAAAAAAqxCCAAAAAFiFEAQAAADAKoQgAAAAAFYhBAEAAACwCiEIAAAAgFUIQQAAAACsQggCAAAAYBVCEAAAAACrEIIAAAAAWIUQBAAAAMAqhCAAAAAAVkmWBJCdnS1paWkBn0tPTzcLAAAAgPiWkZFhlmCZwKoQlJKSIpmZmdE+DAAAAACFKFQDR2pqqmRlZYW1H7rDAQAAALAKIQgAAACAVQhBAAAAAKxCCAIAAABglYQojAAgdvTavSYi+xkpbSOyHwAAAH+0BAEAAACwCiEIAAAAgFUIQQAAAACsQggCAAAAYBVCEAAAAACrEIIAAAAAWIUQBAAAAMAqhCAAAAAAViEEAQAAALAKIQgAAACAVQhBAAAAAKxCCAIAAABgFUIQAAAAAKsQggAAAABYhRAEAAAAwCqEIAAAAABWIQQBAAAAsAohCAAAAIBVCEEAAAAArJIsCSA7O1vS0tICPpeenm4WAAAAAPEtIyPDLMEygVUhKCUlRTIzM6N9GAAAAAAKUagGjtTUVMnKygprP3SHAwAAAGAVQhAAAAAAqxCCAAAAAFiFEAQAAADAKoQgAAAAAFYhBAEAAACwCiEIAAAAgFUIQQAAAACsQggCAAAAYJXkaB8AAARSddA2TgwAACgUtAQBAAAAsAohCAAAAIBVCEEAAAAArEIIAgAAAGCViIWgUaNGSVJSkowYMSLkekePHpXSpUubdcNZNmzYEKlDBAAAAIDIhaAJEyaEtd7GjRvlwIEDnHoAAAAA8Vsie+zYsTJv3ryw1l29erX38ejRo6VevXoh109JSSnw8QEAAABAgUPQ/v37ZdGiRTJmzBgZP3582Ns5IUi7uvXs2VPKli2b30MAAAAAgKIJQW3btpUFCxaY8T155YSg1NRUAhAAAACA+BgTtGXLlnwFIHcIatSoUb62BwAAAIAiD0ErV6403eGcRb/ObwjSIgkrVqyQ77//Xnbs2JGfwwEAAACAwg1BJUuWlFKlSvks4Th8+LCsW7fOPNZtbrnlFqlQoYI0bdpU2rdvL1WrVpVatWrJgAEDZM+ePfk5NAAAAAAo/Opw4Vq/fr0cOnTIPH7++eeDdrV77rnn5KOPPpJJkyZJ69atc92vx+ORXbt25fu48hLkAAAAAESe9hAryFQ6mgliMgS5y2OrPn36yBVXXCGtWrWSvXv3ytKlS81kq1p1TidJvfrqq2XZsmVSrly5kPvdvHmzVKpUKd/HNWzYMBk+fHi+twcAAABQMI8//rjJAkWhSEPQ2rVrJTn5fy85atQo6du3r/e5KlWqSJ06daRTp04m/Hz44Yem69xDDz0kI0eODLlf7UK3fPnyfB8XrUAAAABAdA0ZMsQMi8kvHWKjjSMxF4Juv/12s4SiIemFF16Q6dOny+7du+Wtt96Sp556SooXLx50G51zqGLFioVwxAAAAACKQkGHqGgmKNTCCIVNW3batGljHu/cudO0IAEAAABAJMRkCFJNmjTxPqZ0NgAAAICED0FaTttBVzcAAAAAcReCtPrbKaecIieeeKIMGjQo1/WdQgclSpSQ+vXrF8ERAgAAALBBkYWgsmXLmrE+v/76q2RkZJixPsFkZmbK999/bx6fc845uZbIBgAAAICY7A7Xs2dP8++ePXtMGeyDBw/mWEfL2t1www1mUlVtBcqtPDYAAAAA5EWRlsi+6qqr5IMPPpCPPvpIZsyYIY0aNZKbb77Z/Ltr1y4zMeqYMWPMY6dWePPmzYvyEAEAAAAkuCINQVq7++2335Z//vlHvv76a9mwYYMMHTo0x3rly5c3M8amp6cX5eEBAAAAsECRhiCl43u++uorE4J0bNDq1atNGPJ4PFKnTh0599xz5d5775V69eoV9aEBAAAAsEBEQpAGFg0xeXHeeeeZBQAAAACKUszOEwQAAAAAhYEQBAAAAMAqhCAAAAAAViEEAQAAALAKIQgAAACAVQhBAAAAAKxS5PMEAUBRymrUusD7qL1qQUSOBQAAxAZaggAAAABYhRAEAAAAwCqEIAAAAABWIQQBAAAAsAohCAAAAIBVCEEAAAAArJIQJbKzs7MlLS0t4HPp6elmAQAAABDfMjIyzBIsE1gVglJSUiQzMzPahwEAAACgEIVq4EhNTZWsrKyw9kN3OAAAAABWIQQBAAAAsAohCAAAAIBVCEEAAAAArEIIAgAAAGAVQhAAAAAAqxCCAAAAAFiFEAQAAADAKoQgAAAAAFYhBAEAAACwCiEIAAAAgFUIQQAAAACsQggCAAAAYBVCEAAAAACrJEf7AAAUXFaj1pxGAACAMNESBAAAAMAqhCAAAAAAViEEAQAAALAKIQgAAACAVQhBAAAAAKxCCAIAAABgFUIQAAAAAKswTxCAmNRr95qI7GektI3IfgAAQOKgJQgAAACAVRKiJSg7O1vS0tICPpeenm4WAAAAAPEtIyPDLMEygVUhKCUlRTIzM6N9GAAAAAAKUagGjtTUVMnKygprP3SHAwAAAGAVQhAAAAAAqxCCAAAAAFiFEAQAAADAKoQgAAAAAFYhBAEAAACwCiEIAAAAgFUIQQAAAACsQggCAAAAYBVCEAAAAACrEIIAAAAAWIUQBAAAAMAqhCAAAAAAViEEAQAAALAKIQgAAACAVQhBAAAAAKxCCAIAAABgFUIQAAAAAKsQggAAAABYhRAEAAAAwCqEIAAAAABWIQQBAAAAsAohCAAAAIBVCEEAAAAArJIsCSA7O1vS0tICPpeenm4WAAAAAPEtIyPDLMEygVUhKCUlRTIzM6N9GAAAAAAKUagGjtTUVMnKygprP3SHAwAAAGAVQhAAAAAAqxCCAAAAAFiFEAQAAADAKoQgAAAAAFYhBAEAAACwCiEIAAAAgFUIQQAAAACsQggCAAAAYBVCEAAAAACrJEf7AACgMFUdtI0TDAAAfNASBAAAAMAqhCAAAAAAViEEAQAAALAKIQgAAACAVQhBAAAAAKxCCAIAAABgFUIQAAAAAKsQggAAAABYhRAEAAAAwCqEIAAAAABWIQQBAAAAsAohCAAAAIBVkiUBZGdnS1paWsDn0tPTzQIAAAAgvmVkZJglWCawKgSlpKRIZmZmtA8DAAAAQCEK1cCRmpoqWVlZYe2H7nAAAAAArEIIAgAAAGAVQhAAAAAAqxCCAAAAAFiFEAQAAADAKoQgAAAAAFYhBAEAAACwCiEIAAAAgFUIQQAAAACskhztAwBsltWodbQPAQAAwDq0BAEAAACwCi1BALyqDtpW8LOxmxMKAABiGy1BAAAAAKxCCAIAAABglah3h9u8ebNs2LDBPK5Xr57UqlUr2ocEAAAAIIFFrCVo1KhRkpSUJCNGjAhr/enTp8vpp58utWvXlrZt25pFH7dq1UqmTZsWqcMCAAAAgMIJQRMmTAh73WeffVY6deokP/74Y47nFi1aJBdffLE8/fTTkTo0AAAAAIhsCBo7dqzMmzcvrHW/+eYbuffee83jatWqycSJE2Xnzp1m0SBVtWpV89ygQYNk1qxZkTg8AAAAACj4mKD9+/ebVpsxY8bI+PHjw95u8ODBcvToUSlRooR8+eWX0rJlS+9z11xzjTRt2lRat24thw4dkvvvv1/mz5+f30MEAAAAgMi0BOn4nXLlykn79u1NCDp48GBY2/3yyy+ycOFC87hnz54+Achx8skny7XXXmseL1iwQH777bf8HCIAAAAARC4EbdmyxbTm5NVnn33mfXz11VcHXc/9nHsbAAAAAIhKCFq5cqXpDucs+nU4Fi9ebP7VKnJnnHFG0PXatGlj1nFvAwAAAABRC0ElS5aUUqVK+SzhWLFihfk3JSVFKlSoEHQ9fU6LJqhwAxYAAAAAxNxkqdnZ2ebfGjVq5LqurrNt2zbZunVrrut6PB7ZtWtXvo8rL0EOQHzptXtNgffxXkSOBAAAhHLgwAGz5JdmgpgMQXv27DH/li1bNtd1nXWcbULZvHmzVKpUKd/HNWzYMBk+fHi+twcAAABQMI8//riMGDFCikKRhiAn2RUvXjzXdZOT/3do+/bty3XdWrVqyfLly/N9XLQCAQAAANE1ZMgQGTBgQL6316l2tHEk5kKQtu7s3r07rJLaTmAqU6ZMrutqEYWKFStG5BgBAAAAFL2CDlFxCqsVWmGE/Cpfvrz5N5zxO846zjYAAAAAEAlFGoLq1q1r/v3jjz9yXTcrK8v8W6dOnUI/LgAAAAD2KNIQ1KRJE/OvdonbsGFD0PU2btxo1nH69gEAAABAXIag9u3bex/Pnj076Hru59q2bVvoxwUAAADAHkUagi655BIpVux/L/nGG28EXW/MmDHmX1330ksvLbLjAwAAAJD4ijQE1axZU66++mrzeO7cufLaa6/lWEe/N2fOHPP4mmuuCWtiVQAAAAAIV5GWyFaPPvqoTJ8+XXbs2CG33HKL/PDDD9KpUyc5evSoTJs2TcaPH2/Wq1q1qlkXAAAAAOI6BNWrV0+mTp0ql112mWzbtk3Gjh1rFreUlBSZMmWKt5ocAAAAAMRldzhHu3btZNmyZTJ06FBp1qyZmQuoQoUK0rx5c3nggQfk119/lTZt2kTj0AAAAAAkuORIte54PJ48bVO9enX573//axYAAAAASOiWIAAAAACIFkIQAAAAAKsQggAAAABYhRAEAAAAwCqEIAAAAABWIQQBAAAAsAohCAAAAIBVIjJPEIDE0Gv3mmgfAgAAQKGjJQgAAACAVQhBAAAAAKxCCAIAAABgFUIQAAAAAKsQggAAAABYJSGqw2VnZ0taWlrA59LT080CAAAAIL5lZGSYJVgmsCoEpaSkSGZmZrQPAwAAAEAhCtXAkZqaKllZWWHth+5wAAAAAKxCCAIAAABgFUIQAAAAAKsQggAAAABYhRAEAAAAwCqEIAAAAABWIQQBAAAAsAohCAAAAIBVCEEAAAAArEIIAgAAAGAVQhAAAAAAqxCCAAAAAFiFEAQAAADAKoQgAAAAAFYhBAEAAACwCiEIAAAAgFUIQQAAAACsQggCAAAAYBVCEAAAAACrEIIAAAAAWIUQBAAAAMAqhCAAAAAAViEEAQAAALAKIQgAAACAVZIlAWRnZ0taWlrA59LT080CAAAAIL5lZGSYJVgmsCoEpaSkSGZmZrQPAwAAAEAhCtXAkZqaKllZWWHth+5wAAAAAKxCCAIAAABgFUIQAAAAAKsQggAAAABYhRAEAAAAwCqEIAAAAABWSYgS2UA0ZDVqzYkHAACIQ7QEAQAAALAKIQgAAACAVQhBAAAAAKxCCAIAAABgFUIQAAAAAKsQggAAAABYhRAEAAAAwCqEIAAAAABWIQQBAAAAsAohCAAAAIBVCEEAAAAArEIIAgAAAGAVQhAAAAAAqxCCAAAAAFiFEAQAAADAKoQgAAAAAFYhBAEAAACwSrIkgOzsbElLSwv4XHp6ulkAAAAAxLeMjAyzBMsEVoWglJQUyczMjPZhAAAAAChEoRo4UlNTJSsrK6z90B0OAAAAgFUIQQAAAACsQggCAAAAYBVCEAAAAACrEIIAAAAAWIUQBAAAAMAqhCAAAAAAViEEAQAAALAKIQgAAACAVQhBAAAAAKxCCAIAAABgFUIQAAAAAKsQggAAAABYhRAEAAAAwCqEIAAAAABWIQQBAAAAsAohCAAAAIBVCEEAAAAArEIIAgAAAGAVQhAAAAAAqxCCAAAAAFiFEAQAAADAKoQgAAAAAFZJlgSQnZ0taWlpAZ9LT083CwAAAID4lpGRYZZgmcCqEJSSkiKZmZnRPgwAAAAAhShUA0dqaqpkZWWFtR+6wwEAAACwCiEIAAAAgFUIQQAAAACsQggCAAAAYBVCEAAAAACrEIIAAAAAWIUQBAAAAMAqhCAAAAAAViEEAQAAALAKIQgAAACAVQhBAAAAAKxCCAIAAABgFUIQAAAAAKsQggAAAABYhRAEAAAAwCpRC0EdO3aUpKSksJZx48ZF6zABAAAAJJiohaDVq1dH66UBAAAAWCw5Gi964MAB+eOPP8zj9PR06dy5c8j1TzzxxCI6MgDIKatR64icltqrFnB6AQCwNQStXbtWjh49ah5fcsklcuGFF0bjMAAAAABYqFi0u8I1atQoGocAAAAAwFLJ0QxBJUuWlHr16kXjEGBxtyS6JAEAANgtqiHo+OOPl+LFi5uucTpGaOPGjSYU1a1bNxqHBQAAAMACUekOt2rVKvNvzZo15YknnpDq1atL/fr15ayzzjIhqFKlStKtWzdZv359NA4PAAAAQAKLakvQrFmzzOJv165d8vHHH8vMmTPlhRdekD59+oTcn8fjMdvkV6lSpcwCAAAAIDq0grQu+aWZIGZD0N69e2Xz5s3er7X15/bbb5fTTz9dKlSoIL/++qu8+uqr8u6778qePXvk1ltvldNOO01OOumkoPvU/WnrUX4NGzZMhg8fnu/tAQAAABTM448/LiNGjJCikByN8tg6Dkhdc8018tZbb0mxYsV8QpEuGoruvvtuOXTokNx4443y448/SlJSUsB91qpVS5YvX57vY6IVCAAAAIiuIUOGyIABA/K9fdOmTX0aW2IqBOnEpxpscnPnnXfKhAkT5KeffpJFixbJ0qVL5eSTTw64roajihUrFsLRAgAAACgKBR2iEqzBJGbGBIVDW4e0OIKGIKUtQcFCEGC7qoO2RWZHuyOzGwAAgFgWlepw4WrSpIn38Y4dO6J6LAAAAAASQ0yHoMOHD3sf090NAAAAQFyGoJ49e5pxQeedd16uZezcxQ4aNWpUBEcHAAAAINEVeQhq2bKlKYOt8wN99dVXQdfbv3+/vPPOO+axlr8+88wzi/AoAQAAACSqIg9BPXr08JbI1tLXmzZtChiA7rjjDlNOWz311FNSunTpoj5UAAAAAAmoyKvDpaamysiRI+Wuu+4yAUjreffr18+0ECUnJ5sucBMnTpQ1a9aY9Tt06CB9+/Yt6sMEAAAAkKCiUiK7f//+kpWVJc8++6zs3r3bhKJAdb5vueUWefLJJ/NU8xsAYrYEOQAAiAlRmydIu7j16dNHnnnmGTMR6oYNG2TXrl2SkpIi7dq1k9tuu03at28frcNDAstq1DrahwAAAIAoiupkqY0bN5bXX389mocAAAAAwDIxPU8QAAAAAEQaIQgAAACAVQhBAAAAAKxCCAIAAABgFUIQAAAAAKsQggAAAABYhRAEAAAAwCqEIAAAAABWIQQBAAAAsAohCAAAAIBVCEEAAAAArEIIAgAAAGAVQhAAAAAAqyRLAsjOzpa0tLSAz6Wnp5sFAAAAQHzLyMgwS7BMYFUISklJkczMzGgfBgAAAIBCFKqBIzU1VbKysuwJQQAQD7IatY72ISS02qsWRPsQAABxgjFBAAAAAKxCCAIAAABgFUIQAAAAAKsQggAAAABYhRAEAAAAwCqEIAAAAABWIQQBAAAAsArzBAFALnrtXhORczRS2nKuAQCIAbQEAQAAALAKLUEoElmNWnOmAQAAEBNoCQIAAABgFUIQAAAAAKsQggAAAABYhRAEAAAAwCqEIAAAAABWoTocABSRqoO2ca4BAIgBtAQBAAAAsAohCAAAAIBVCEEAAAAArEIIAgAAAGAVQhAAAAAAqxCCAAAAAFiFEAQAAADAKgkxT1B2drakpaUFfC49Pd0sABBtvXavifYhJLT3on0AAIBCl5GRYZZgmcCqEJSSkiKZmZnRPgwAAAAAhShUA0dqaqpkZWWFtR+6wwEAAACwCiEIAAAAgFUIQQAAAACsQggCAAAAYJWEKIwAxKuqg7ZFZD9UHQMAAAgfLUEAAAAArEIIAgAAAGAVQhAAAAAAqxCCAAAAAFiFEAQAAADAKoQgAAAAAFYhBAEAAACwCiEIAAAAgFUIQQAAAACsQggCAAAAYBVCEAAAAACrEIIAAAAAWIUQBAAAAMAqhCAAAAAAViEEAQAAALAKIQgAAACAVQhBAAAAAKxCCAIAAABgFUIQAAAAAKskSwLIzs6WtLS0gM+lp6ebBQAAAEB8y8jIMEuwTGBVCEpJSZHMzMxoHwYAAACAQhSqgSM1NVWysrLC2g/d4QAAAABYhRAEAAAAwCqEIAAAAABWIQQBAAAAsEpCFEYA4lWv3WuifQgAAADWoSUIAAAAgFUIQQAAAACsQnc4hJTVqDVnCAAAAAmFliAAAAAAVqElKIHRigMAAADkREsQAAAAAKsQggAAAABYhRAEAAAAwCqEIAAAAABWIQQBAAAAsAohCAAAAIBVCEEAAAAArEIIAgAAAGAVQhAAAAAAqxCCAAAAAFglOdoHABS1qoO2RWQ/25+sHpH9AAAAoGjREgQAAADAKoQgAAAAAFZJiO5w2dnZkpaWFvC59PR0swAAAACIbxkZGWYJlgmsCkEpKSmSmZkZ7cMAAAAAUIhCNXCkpqZKVlZWWPuhOxwAAAAAqxCCAAAAAFiFEAQAAADAKoQgAAAAAFYhBAEAAACwCiEIAAAAgFUIQQAAAACsQgiKoAMHDsjw4cPNv0C8OXL4gPz6xQjzLxBv9Lrl7y/iFfcPiGcH4vT+lxAUQfrmjxgxIu4uAkAdPXxAfpvxiPkXiDd63fL3F/GK+wfEswNxev9LCAIAAABgleRoHwByymrUmtMCAPmw+eRz5d/ixTl3haD2qgWcVwAJg5YgAAAAAFYhBAEAAACwCt3hAAAJo8rdf0rFMny+Vxjoql14/j1ypBD3DiBmQ9Dff/8ta9euld27d0utWrWkYcOGkpSUFO3DAgAAAJCAohqCVq9eLQMHDpQvvvhCDh8+7P1+3bp15c4775S7775bihXjE71EUHXQtojsp9fuNQXexzhpGJFjAQAAQHyKWsKYO3eutGzZUj799FOfAKQ2btwo99xzj3Tr1k2O0EScb2P/zpZY8eqsXRIrYulYVn83KtqHELNi6dxwLPFxbmJJLP2diaVjibX/N8XSscSSjIwMiRWxdCyxdjyxdCzxKCotQTt27DABZ+/evVK8eHEzy+wNN9wgxxxzjCxcuNC0Di1evFg++eQTeeSRR8zzyLtx/2RL78opMXHqXv3mX7nl3IoSC2LpWNbMfUVOOPO2aB9GTIqlc8OxxMe5UbfsWSoljkT/9/uLr0+UH05fJrEgUscyUtom3P+bYulYYoneXKenp0ssiKVjibXjiaVjiUdRCUFPPvmkbN++3Tx+8cUX5bbb/u9/oGeffbbMnj1bWrRoIevWrZORI0fK7bffLlWrVo3GoQJBDUyfV/Cz8/iJnGEAAIBE7w539OhReeutt8zj4447Tm699dYc61SoUEGGDRtmHmuxhEmTJhX1YQIAAABIUEUegubPn+9tBerRo0fQKnDdu3eX5OT/NVR99tlnRXqMAAAAABJXkXeH07E+jjZt2gRdr1y5cqZL3KJFi3y2AQAAcdoFWESyHz8xYvtKlGM5tH+XyOBjo30YgFWKPAStWLHC+/iEE04Iue7xxx9vQtC2bdvMXEKVK1cugiNMHMWrHClwaertT1aXRLP5aEPptTs2BiwDAACg6CV5PB5PUb7gFVdcIR9++KF5rMGmUqVKQdft37+/KZygli9fLk2aNPF5vmTJknLo0CEzl1CNGjXyfUyRmphVT+XmzZvNhK8F2eeR7MjMqbP96CFJqVS8QPs48m+xmDkW9dfR/L/Pjv3/ZkvpCrFRDSiWjsXjOSr7d22R0hVrSlJS9OfniqVzw7HE/rnh+o399ygWjyfWrt+C3j9ESnZ2tqSkRP+8xNqxxNrxxMqxeCJ0/+veX35t3brV1B8oUaKEHDx4MLZagvbs2eN9XLZs2ZDrup93b+dw5hDSH1ZPfqyIpWPJ2vm/c5R/Bd0+ksdi9hKBfYjs+ycy+0m0Y1H6P+JYEUvnhmOJj3PD9Rv771GsHU8sHUtM3T9kxc55iaVjibXjiaVj2RxD128484wWeQg6cOCA97HOERSKUxhB7du3L8fzpUuXlv3795v9VKtWLd/HFAufugAAAAC28xSgJejPP/80AUgzQsyFIHfrjjZThTpId2AqU6ZMjucDtQ4BAAAAQChF3vG/fPny3se7du0Kua77efd2AAAAABA3Iahu3brex5s2bQq5rvO8dlerXbt2oR8bAAAAgMRX5CHIXeFt2bLQZYozMzPNv3Xq1KElCAAAAEB8hqD27dt7H8+ePTvoehs3bpR169aZx23bti2SYwMAAACQ+Io8BOkEqU2bNjWPdb4gnSsokDFjxngfd+vWrciODwAAAEBii8qMiAMGDDD/7t69W+64444cpfCWLl0qTz31lHncoEEDQhAAAACAiEnyFKQYdz4dPnzYdItbsGCB+bpDhw7Su3dvqVixoixcuFBGjRol//77rxQrVkymTp0ql1xyicQybc1au3atCXU6W27Dhg2ZewhxQyc327Bhg3lcr149cw3nhf4JWbNmjdmPVnE8/vjjpXLlyoV0tIAvrl9Ek07VoX//9u7da3q6VK1aNU/bc/0i3m2O53sIT5Rs3brVc8opp2gAC7iULFnS8+qrr3pi2apVqzydO3f2JCcn+xx73bp1Pc8884znyJEj0T5EWCQjI8Ncf8OHDw9r/S+++MJz2mmn5fjdO/XUUz2ff/55rtsfPXrU89xzz3nq1avns73+Plx88cWeFStWROCnQqLav3+/56mnnjJ/Q5s0aeIpW7asp3Hjxp7LL7/c8+KLL3oOHjwYcnuuX0SL/u0bM2aMp379+p6kpCSfv3/HHHOM5/777/fs2rUr5D64fhGLDh065GndunVY9xKJcA1HLQQp/Z/cyy+/7Gnbtq2nSpUqnlKlSnkaNGjg6du3r2fZsmWeWPbdd9+Z/2kHC3G6dOnSxXP48OFoHyosob9H4YagkSNHhrx2ddEb1GA04Hft2jXk9vr7MWfOnAj/lEgEs2fP9pxwwgkhrx8NRsGuH65fRPO+5Zxzzsn172dKSopn3bp1AffB9YtYNWjQIO81HOpeIlGu4aiGoHi1fft2T9WqVc2bVLx4cc8jjzzi2bRpk2fPnj2eb775xqeFa9iwYdE+XFjgrbfeCusPl5o1a5anWLFiZt1q1ap5Jk6c6Nm5c6dZJkyY4L229RPOr7/+OuA+9DXcn/roTa1e//p78PDDD5vfC31OP9z4888/C+mnRjzKzMz0lCtXznv9aHh/+umnPR9++KH51wnzupQvX96zevVqn+25fhFNeo0616f+v37GjBmeLVu2mL+f+uHoBRdc4H2+ffv2OT4I5fpFrJo5c6ZPy2awe4lEuoYJQflw7733et887YLkT5vBtUXL+Z84N4EoDPv27fPMnTvXc+ONN5ruo+GGoNNPP92sV6JECc+SJUtyPL948WLznK6jzeL+tm3b5r2J1ev833//zbHOSy+95D0e/WQJcFxxxRXea+Puu+/O0W1Yu0g8+eST3nX0etXvcf0i2v755x9PhQoVzHV5/PHHB+yyqddqhw4dvNev3jC68fcXsWjbtm2eGjVq+LTEBLuXSKRrmBCUR/o/bCflHnfccT7/c3YbO3as9w3ULn9AJLVp08b7SYz/EioE/fzzz971brjhhqDr9e7d27ver7/+6vPcCy+84H1u3LhxAbfX3wv9/dB1qlevzvg4GHv37vUG9jp16pggH0ynTp2819m8efO4fhF18+fP916Tr7zyStD1Pv74Y+96OubBwd9fxKKjR496/97WqlUr5L1Eol3DUSmRHc/mz58v27dvN4979OgRtApc9+7dJTk52Tz+7LPPivQYkfi2bNkiR48ezfN27mvx6quvDrqe+zn/69f5ukSJEnL55ZcH3F5/L6666irzeNu2bfLjjz/m+ViReJYsWSIHDx70/v0sXbp00HW7du3qfbx48WLzL9cvomn16tXex82aNQu6nlaJC7QN1y9i0XPPPSdffPGFlClTRl5//fWQ6ybaNUwIyiPnf8aqTZs2QdcrV66ctGjRIsc2QCSsXLlS9u/f713063A416L+gTnjjDOCrqfXthPw/a9f5+uTTjrJXOfBtG3bNsc2sFt2drb38Yknnhhy3Zo1a3of79u3z/zL9Yto0ukvnnjiCbOECkFZWVnexzVq1PA+5vpFrFm8eLEMGTLEG4ZCXdfO+ol0D/G/pgqEbcWKFQE/7QlEa50vWrTIpFidS4i5UxApJUuW9Pm6VKlSebp+U1JSpEKFCkHX0+eqVatmrl13wNJW0B07doR9/TvCDWlIbPrB0NixY83jCy64IOS67k/+GjVqZP7l+kU06U1fqBs/Zx5EDUlKbwK7devmfY7rF7Fk9+7dpkVeW+f1Ou3Xr593vp9gEu0aJgQV4JNM9yc8gbif37p1KyEIMXP95nbtOuvoHzC9dv23z8/1Dxx33HFmyY1OmpeRkWEe6+R57dq14/pFzHZN/umnn2Tnzp3yyy+/yKRJk2TTpk3muUceeUSaN2/uXZe/v4gl6enpprtmamqqvPHGG2Ftk2jXMCEoH7NDO8qWLRtyXffz7u2AaHGuw9yuXfc67muX6x+Fbd26ddK5c2f566+/zNd33HGHVKlSxef64/pFrPj222/Np+luer1OmDBBLrzwQp/vc/0iVowfP17efvttKVasmHl87LHHhrVdol3DjAnKowMHDngfFy9ePOS6TmEEd592IBau39yuXff16752uf5RWLRLxvPPP2/6if/222/mex07dpThw4fnuP64fhHLtLtP//79zWBzN65fxIK1a9fKbbfdZh7ff//90qFDh7C3TbRrmBCUR+5k6lQ5Csb9ZmvVDSBWrt/crl339eu+drn+URgmT54saWlpcvfdd5t+6kqrBk2ZMsVn/BvXL2KNVrDS6UZ27dolP//8swntFStWNGMYunTpIlOnTvWuy/WLaDt06JBpufz3339N8YJhw4blaftEu4YJQXmk/dMd+kcvFPfz7u2AaHGuw9yuXfc67muX6x+RpINszz33XDOlgH466Qy4nThxonz44Yc5Kgdx/SJW6UBwbcXUm8pp06aZT7m1SMJ9993nnc6A6xfRpi0/OoatUqVK5u+su7UlHIl2DTMmKI/q1q3rfayDH6tXrx50XWdwpFaIqV27dn7fIyCi168OMPzjjz9yXdcp81qnTh3v9/SxXs/6yadzfQfjft69D0C99tprctddd3m7OehN5L333isDBgwIWjaV6xfxQAt56HggDUOrVq0yfwv12uX6RbSLeIwcOdI8vvLKK01rpX/VNXfhgjVr1siMGTPMY73XPfnkkxPuGqYlKI+aNGnifbxs2bKQ62ZmZnrfPFqCEEvXr3Y5ClUKc+PGjd5uSU2bNvVpynb+GIV7/fvvA9DKb1qO1QlAffr0kd9//10efPDBkPNGcP0imnQcxXXXXSfPPvtsruu6/+ZptUPF9Yto0u5nGj6UTop60UUX5Vh69erlXV8LJjjff/jhhxPyGiYE5VH79u29j2fPnh3yAtAqR/4TPgHxcP26n/O/fp19rF+/PuQfwVD7gL20m5tWfFPHHHOMzJw505RnrVq1aq7bcv0impYvX25uDF955ZVc13VPmOrMEcj1i3jXPtHuITzIs6ZNm2qU9pQvX96zc+fOgOsMGzbMrKPLpEmTOMsoVOvXr/deb8OHDw+63ubNmz3FihUz67Vv3z7oeh06dDDr6LpbtmzxeU6vZ+e1HnjggYDb//PPP56KFSuadfT3BVBHjhzxNGzY0Pv389dff83TieH6RTTdd9995tpNSkry/Pbbb0HX27Nnjyc1NdWsW7lyZc+hQ4fM97l+Ee/3EpsT7B6CEJQPr7/+uvcN7Nmzp+fo0aM+zy9ZssRTpkwZ83yDBg08Bw8ejNT7BRQoBKlrr73Wu+7o0aNzPK/fc1/f/vR61utan9frfOnSpTludHU7Zx9vvPEG7xqMTz75xHtdPPnkk/k6K1y/iJa5c+eaAKTXb9u2bT1///13wL+PN954o/c6HzJkiM/zXL+I93uJaxPoHiJJ/1M4bUyJSyu+aHPeggULzNdaY713796mLObChQtl1KhRpvygTkKl5TEvueSSaB8yEpw2KdevX9881hKtocpe6rqnnnqqmctCByhqH+BOnTqZCkY6kFe7e+ifBe2etGjRIp9iII5PPvlEunbtatbT6167N+k+dYLLsWPHyty5c816WoLzu+++C2tOASS+22+/3YwHUqNHj5Z69eqFtV2LFi28s4dz/SKa0tPTzf/jnUqGffv2lcaNG5tS7loE4Z133jH/qlNOOUXmz58vJUqU8G7P9Yt4v5fYkEj3EIUWrxLc1q1bPaeccoo3qfovJUuW9Lz66qvRPkxYIi8tQc4nmtWrVw96/aakpHjmzZsXch8ZGRmeEiVKBN1Hq1atPNu2bYvgT4l4d9FFFwW9XkIt7733ns9+uH4RLbt37/ZcdtlluV6zl1xyiWfDhg0B98H1i3i/l5ibIPcQhKAC0Ca9l19+2TSLV6lSxVOqVCnTxNe3b1/PsmXLIvcuAREOQSo7O9szdOhQT7Nmzcz4jAoVKniaN29u+uj++eefYe3j559/9tx0002e+vXrm+tffw/atWtn/rg5/eABxwknnBCREMT1i2ibM2eOp0ePHp7TTjvNc+yxx3qOOeYYzxlnnOHp1auXZ8aMGbluz99fxPu9RHYC3EPQHQ4AAACAVSiRDQAAAMAqhCAAAAAAViEEAQAAALAKIQgAAACAVQhBAAAAAKxCCAIAAABgFUIQAAAAAKsQggAAAABYhRAEAAAAwCqEIAAAAABWIQQBAAAAsAohCAAAAIBVCEEAAAAArEIIAgAAAGAVQhAAAAAAqxCCAAAAAFiFEAQAAADAKoQgAAAAAFZJjvYBAAAAAChchw8flq+//lrWrl0ru3fvltq1a8v5558vKSkpOdbV57/88kvZuHGj+bpx48bSsmVLqVmzZsK8TYQgAAAAIEGMGzdOevfubR6PHTtWevXqJe+//77cddddsmXLFp91S5QoIXfeeac89dRTUqxYMTl69Kg88cQT8uijj8revXt91i1VqpQMGjRIhg4dKiVLlpR4RwgCAAAAEtQzzzwj9957b8DnDh06JCNHjjSBJyMjQ66++moTmAI5cOCAPPzwwyYoPfLIIxLvkjwejyfaBwEAAAAgsi1BV111lXzwwQcmuJxzzjly9tlnyzHHHCM//vijTJw4UY4cOeLd7qKLLpLp06ebx+eee65Zv3z58jJ37lyZPHmydz1tBfr9999Nd7p4RggCAAAAEjAEOd3YXn31VZ/vKR0f1LFjR3G3h+i6r732mlx//fUSap+ffvqpXHLJJRLPqA4HAAAAJKj7778/RwBS5513nlx++eXipuN9/AOQ0nFFrVq18n69cuVKiXeEIAAAACABVaxY0RQzCKaVK9jouvfdd19Y62r1OLcNGzZIUlKSWf7zn/+EdWwVKlQw68+ZMyfi+wkHIQgAAABIQC1atDBd3IJJcZXHzsu6oXzxxRdmHFJBRWo/wRCCAAAAgATUoEGDkM8nJSXla93c9O/fX3bt2hX2+oW9n0AIQQAAAEAC0rl/CmPd3Lqn6XxEOr4oFvYTDCEIAAAAQEToXEJq1KhRphR3tPcTDCEIAAAAQET07NnTzDOkcxP169fPZy6iaOwnGEIQAAAAgIjQsUOvvPKKKbKwZMkSeemll6K6n2AIQQAAAAAiplGjRjJ48GDz+MEHH5RNmzZFdT+BEIIAAAAARNSQIUPkhBNOMHMK3XnnnVHfjz9CEAAAAICI0m5sWtRATZkyRT799NOo7scfIQgAAABAxJ1//vly7bXXmse333677NmzJ6r7cSMEAQAAACgUI0eOlMqVK8vGjRtlxIgRUd+PgxAEAAAAoFCkpKTIE088YR4/99xz8ssvv0R1Pw5CEAAAAIBCc/PNN8sZZ5whhw8flltuuUU8Hk9U96OSPAXZGgAAAIDVNmzYIPXr1zePt2/fLlWqVMmxjrbcnHrqqSbAvPrqq3LPPfeYim+zZ8+WDh06RHQ/4aAlCAAAAEChOumkk+Suu+4yj3XunwMHDkR1P4QgAAAAAIVu+PDhUrduXfn777/l0KFDUd0PIQgAAABAoStXrpy89NJLMbEfQhAAAACAItGlSxfp2rVr1PdDYQQAAAAAVqElCAAAAIBVCEEAAAAArEIIAgAAAGAVQhAAAAAAqxCCAAAAAFiFEAQAAADAKoQgAAAAAFYhBAEAAACwCiEIAAAAgFUIQQAAAACsQggCAAAAIDb5f4JNybMfGw5aAAAAAElFTkSuQmCC",
"text/plain": [
"<Figure size 1000x1000 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"bkg_list = ['zem', 'ztt', 'wjets', 'vqq', 'qcd', 'tt-dilep', 'tt-semilep', 'tt-had', 'st', 'vv']\n",
"# fetch_temp(\"2018\", \"hadhad\", \"sig\", \"loose\", 'ztt', reg_passfail='nom', syst=f'nominal', rebin=None).plot(ls='--')\n",
"# fetch_temp(\"2018\", \"hadhad\", \"sig\", \"pass\", 'ztt', reg_passfail='nom', syst=f'nominal', rebin=None).plot(ls=\"-.\")\n",
"# fetch_temp(\"2018\", \"hadhad\", \"sig\", \"pass\", 'ztt', reg_passfail='nom', syst=f'nominal', rebin=None).plot(ls=\"-.\")\n",
"# fetch_temp(\"2018\", \"hadhad\", \"sig\", \"loose\", 'ztt', reg_passfail='fail', syst=f'nominal', rebin=None).plot(ls=\"-.\")\n",
"sig = 'h125'\n",
"chan = \"hadhad\"\n",
"hep.histplot([fetch_temp(\"2018\", chan, \"sig\", reg, sig, reg_passfail='nom', syst=f'nominal', rebin=None) for reg in [\"pass\", \"loose\", \"fail\"]], \n",
" stack=True, histtype='fill', label=[\"pass\", \"loose\", \"fail\"]);\n",
"plt.title(f\"{sig}:{chan} - repro\")\n",
"plt.legend(title=f'Yield = {sum([fetch_temp(\"2018\", chan, \"sig\", reg, sig, reg_passfail=\"nom\", syst=\"nominal\", rebin=None) for reg in [\"pass\", \"loose\", \"fail\"]]).values().sum():.4f}')"
]
},
{
"cell_type": "code",
"execution_count": 137,
"id": "d9acdcab-d769-4d91-aab0-9d0a4cae6f3f",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"np.float64(12.061672716164331)"
]
},
"execution_count": 137,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sum([fetch_temp(\"2018\", \"hadhad\", \"wlnu_cr\", reg, 'ztt', reg_passfail='nom', syst=f'nominal', rebin=None) for reg in [\"pass\", \"loose\", \"fail\"]]).values().sum()/1."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "61c6c8eb-1df6-4f86-abd2-d9c4138da4ec",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "a24024a1-63ab-43f7-aee3-cb7831059734",
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python (Pixi)",
"language": "python",
"name": "pixi-kernel-python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.11.14"
},
"pixi-kernel": {
"environment": "default"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment