diff --git a/notebooks/plotting/test_DataMC.ipynb b/notebooks/plotting/test_DataMC.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..25af1f07496c288513904e51fe85319660866450
--- /dev/null
+++ b/notebooks/plotting/test_DataMC.ipynb
@@ -0,0 +1,570 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "65ddaec4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "from coffea.util import load\n",
+    "from pocket_coffea.utils.plot_utils import Shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "eefe8b4f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<pocket_coffea.utils.plot_utils.Shape at 0x7f81d4a64a00>"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "filename = \"/work/mmarcheg/PocketCoffea/output/datamc/ttHbb_ttbar_ST_WJets_datamc_2018_MuonIsoTight_bugfix/output_all.coffea\"\n",
+    "o = load(filename)\n",
+    "histname = \"ElectronGood_pt_1\"\n",
+    "h_dict = o[\"variables\"][histname]\n",
+    "datamc = Shape(h_dict, histname, plot_dir='plots/')\n",
+    "datamc"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "acf4ddcc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['_categorical_axes',\n",
+       " '_stack_sum',\n",
+       " 'build_stacks',\n",
+       " 'categorical_axes_data',\n",
+       " 'categorical_axes_mc',\n",
+       " 'categories',\n",
+       " 'data_key',\n",
+       " 'define_figure',\n",
+       " 'dense_axes',\n",
+       " 'dense_dim',\n",
+       " 'density',\n",
+       " 'format_figure',\n",
+       " 'get_axis_items',\n",
+       " 'get_datamc_ratio',\n",
+       " 'get_systematic_uncertainty',\n",
+       " 'group_samples',\n",
+       " 'h_dict',\n",
+       " 'is_data_only',\n",
+       " 'is_mc_only',\n",
+       " 'load_attributes',\n",
+       " 'log',\n",
+       " 'lumi',\n",
+       " 'name',\n",
+       " 'only_cat',\n",
+       " 'plot_data',\n",
+       " 'plot_datamc',\n",
+       " 'plot_datamc_all',\n",
+       " 'plot_datamc_ratio',\n",
+       " 'plot_dir',\n",
+       " 'plot_mc',\n",
+       " 'plot_systematic_uncertainty',\n",
+       " 'samples',\n",
+       " 'samples_data',\n",
+       " 'samples_mc',\n",
+       " 'stack_sum_data',\n",
+       " 'stack_sum_mc_nominal',\n",
+       " 'style',\n",
+       " 'variations',\n",
+       " 'xaxis',\n",
+       " 'xbinwidth',\n",
+       " 'xcenters',\n",
+       " 'xedges',\n",
+       " 'xlabel',\n",
+       " 'years']"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "[item for item in dir(datamc) if not item.startswith(\"__\")]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "c5f3b72c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Regular(50, 0, 500, name='ElectronGood.pt', label='$p_{T}^{e}$ [GeV]')]"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "datamc.dense_axes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "eeac458e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[StrCategory(['SingleEle_1b', 'SingleEle_2b', 'SingleEle_3b', 'SingleEle_4b', 'baseline'], name='cat', label='Category'),\n",
+       " StrCategory(['2018'], name='year', label='Year')]"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "datamc.categorical_axes_data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "eb91f8fe",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['2018'] ['SingleEle_1b', 'SingleEle_2b', 'SingleEle_3b', 'SingleEle_4b', 'baseline'] ['nominal', 'JERDown', 'JERUp', 'JES_TotalDown', 'JES_TotalUp', 'pileupDown', 'pileupUp', 'sf_btag_cferr1Down', 'sf_btag_cferr1Up', 'sf_btag_cferr2Down', 'sf_btag_cferr2Up', 'sf_btag_hfDown', 'sf_btag_hfUp', 'sf_btag_hfstats1Down', 'sf_btag_hfstats1Up', 'sf_btag_hfstats2Down', 'sf_btag_hfstats2Up', 'sf_btag_lfDown', 'sf_btag_lfUp', 'sf_btag_lfstats1Down', 'sf_btag_lfstats1Up', 'sf_btag_lfstats2Down', 'sf_btag_lfstats2Up', 'sf_ele_idDown', 'sf_ele_idUp', 'sf_ele_recoDown', 'sf_ele_recoUp', 'sf_ele_trigger_eraDown', 'sf_ele_trigger_eraUp', 'sf_ele_trigger_htDown', 'sf_ele_trigger_htUp', 'sf_ele_trigger_pileupDown', 'sf_ele_trigger_pileupUp', 'sf_ele_trigger_statDown', 'sf_ele_trigger_statUp', 'sf_jet_puIdDown', 'sf_jet_puIdUp', 'sf_mu_idDown', 'sf_mu_idUp', 'sf_mu_isoDown', 'sf_mu_isoUp', 'sf_mu_triggerDown', 'sf_mu_triggerUp']\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(datamc.years, datamc.categories, datamc.variations)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "5a799685",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([  0.,  10.,  20.,  30.,  40.,  50.,  60.,  70.,  80.,  90., 100.,\n",
+       "       110., 120., 130., 140., 150., 160., 170., 180., 190., 200., 210.,\n",
+       "       220., 230., 240., 250., 260., 270., 280., 290., 300., 310., 320.,\n",
+       "       330., 340., 350., 360., 370., 380., 390., 400., 410., 420., 430.,\n",
+       "       440., 450., 460., 470., 480., 490., 500.])"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "datamc.xedges"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "62416ae9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "year = '2018'\n",
+    "cat = 'SingleEle_1b'\n",
+    "datamc.build_stacks(year, cat)\n",
+    "datamc.get_systematic_uncertainty()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "a9ede2b9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "datamc.stack_mc_nominal.plot(stack=True, histtype='fill')\n",
+    "plt.legend();\n",
+    "#plt.yscale('log')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e5ffc260",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['plot_data',\n",
+       " 'plot_datamc',\n",
+       " 'plot_datamc_all',\n",
+       " 'plot_datamc_ratio',\n",
+       " 'plot_dir',\n",
+       " 'plot_mc',\n",
+       " 'plot_systematic_uncertainty']"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "list(filter(lambda x: 'plot' in x, dir(datamc)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "23a8834c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/work/mmarcheg/PocketCoffea/pocket_coffea/utils/plot_utils.py:253: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  self.ratio = num / den\n",
+      "/work/mmarcheg/PocketCoffea/pocket_coffea/utils/plot_utils.py:256: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  self.ratio_unc = np.sqrt(num) / den\n",
+      "/work/mmarcheg/PocketCoffea/pocket_coffea/utils/plot_utils.py:526: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  return np.where(self.nominal != 0, self.up / self.nominal, 1)\n",
+      "/work/mmarcheg/PocketCoffea/pocket_coffea/utils/plot_utils.py:530: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  return np.where(self.nominal != 0, self.down / self.nominal, 1)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1200x1200 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#datamc.define_figure(year)\n",
+    "#datamc.plot_datamc()\n",
+    "#datamc.plot_datamc_ratio(ax=datamc.rax)\n",
+    "datamc.define_figure(year)\n",
+    "datamc.plot_datamc()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "105ce019",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "datamc.plot_datamc_all(save=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "70efe610-3668-43e2-8bc4-d0eaaaac5d2d",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from pocket_coffea.utils.plot_utils import PlotManager\n",
+    "\n",
+    "plotter = PlotManager(o[\"variables\"], plot_dir=\"plots/\")\n",
+    "plotter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c922cbf7-0bdd-45fc-843d-5667c9e6a968",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from pocket_coffea.utils.plot_utils import SystUnc, SystManager\n",
+    "\n",
+    "syst_manager = SystManager(datamc)\n",
+    "syst_manager"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8d712bd2-e9be-4410-aa27-f06b6b057460",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "[d for d in dir(syst_manager) if not d.startswith(\"__\")]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5f139750-b13f-45fa-9ae3-18f01726cd2d",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "syst_manager.syst_dict"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9760a85f-9ae9-43b5-b8f7-9df57e2ac350",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "pileup = syst_manager.get_syst(\"pileup\")\n",
+    "JES_Total = syst_manager.get_syst(\"JES_Total\")\n",
+    "pileup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bdfabb2c-8023-4921-bb21-6cfd64c0395e",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "[d for d in dir(pileup) if not d.startswith(\"__\")]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "61768a25-1746-43d7-9c04-e3c41f00f8ea",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "pileup.err2_up"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "51d6a9d3-558d-456e-acd8-0eafd709465b",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "pileup.err2_down"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7752ee8b-0dbd-4ded-bb88-06725af4267b",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "pileup._n_empty"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a62e6c6b-e08e-4387-af71-81eb1ea902c5",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "s_sum = pileup + JES_Total\n",
+    "s_sum"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a1e65a02-632d-44e3-a9b3-b1062ae2d2e2",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "s_sum.name"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0f39e4ac-627a-4a54-813f-e769c2c5b371",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "s_sum.up"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3b2968aa-3aac-4af0-b534-2178dc5d277c",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "s_sum.down"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e4cca839-62b8-404a-8c30-b977dc422fab",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "[s.name for s in s_sum.syst_list]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "881d8932-6df6-4596-baa6-f0ad6e05bffc",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "s_sum.plot()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3787a08f-a9e9-467c-ac70-545b428c845c",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "syst_tot = syst_manager.total\n",
+    "dir(syst_tot)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "94d67dde-bb55-4df8-b166-648330d54212",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "[s.name for s in syst_tot.syst_list]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "36cfc805-5d95-4546-862d-bfe8287bb492",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "syst_list_btag = [s for s in syst_tot.syst_list if s.name.startswith(\"sf_btag\")]\n",
+    "syst_btag = SystUnc(name=\"btag\", syst_list=syst_list_btag)\n",
+    "fig, ax = syst_tot.plot()\n",
+    "syst_btag.plot(ax=ax)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a3874d45-10d5-43bf-aa82-7479b48a9e71",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "syst_manager.total.up"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "baf0d172-045e-45f4-9756-8c59b1c65536",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.15"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/notebooks/plotting/test_samples_map.ipynb b/notebooks/plotting/test_samples_map.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..a1f60b4e413ddd5fba183816e94583ba227ffc59
--- /dev/null
+++ b/notebooks/plotting/test_samples_map.ipynb
@@ -0,0 +1,256 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "f5850c4d-67aa-4432-95ae-7cf076f62ef3",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "from coffea.util import load\n",
+    "from pocket_coffea.utils.plot_utils import Shape\n",
+    "from pocket_coffea.parameters.plotting import style_cfg"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "67a77d56-73f1-497c-849c-fce02e1f96d9",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['ttHTobb', 'TTToSemiLeptonic', 'DATA_SingleEle', 'DATA_SingleMuon', 'WJetsToLNu_HT', 'SingleTop', 'TTTo2L2Nu'])"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "filename = \"/work/mmarcheg/PocketCoffea/output/datamc/ttHbb_ttbar_ST_WJets_datamc_2018_MuonIsoTight_bugfix/output_all.coffea\"\n",
+    "o = load(filename)\n",
+    "histname = \"ElectronGood_pt_1\"\n",
+    "h_dict = o[\"variables\"][histname]\n",
+    "h_dict.keys()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5b9ed326-e783-42e5-b474-be114cb90baf",
+   "metadata": {},
+   "source": [
+    "## Modify the default style config\n",
+    "As a test, we can modify the entries of the style config dictionary in order to:\n",
+    "\n",
+    "- have unstacked plots for MC with a `step` style.\n",
+    "- group the `TTToSemiLeptonic` and `TTTo2L2Nu` in a single sample `ttbar`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "1052f76a-9b55-4194-96f1-d423be7ddd79",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'histtype': 'fill', 'stack': True}"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "style_cfg[\"opts_mc\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "f12d7d6a-0b82-40b8-8e5b-2e73ba58a1d0",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'histtype': 'step', 'stack': False}\n",
+      "{'ttbar': ['TTToSemiLeptonic', 'TTTo2L2Nu']}\n"
+     ]
+    }
+   ],
+   "source": [
+    "style_cfg[\"opts_mc\"][\"histtype\"] = \"step\"\n",
+    "style_cfg[\"opts_mc\"][\"stack\"] = False\n",
+    "style_cfg[\"samples_map\"] = {\"ttbar\" : [\"TTToSemiLeptonic\", \"TTTo2L2Nu\"]}\n",
+    "print(style_cfg[\"opts_mc\"])\n",
+    "print(style_cfg[\"samples_map\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5992560f-01b8-4694-a088-ded6950d33ce",
+   "metadata": {},
+   "source": [
+    "## Define Shape object"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "d3ef1a3b-532d-4d2c-a5db-3304e7476381",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<pocket_coffea.utils.plot_utils.Shape at 0x7fe8c9b3f610>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "shape = Shape(h_dict, histname, plot_dir='plots/', style_cfg=style_cfg, density=True)\n",
+    "shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "95ef4c9f-5b39-44ca-b898-fb484f4e8616",
+   "metadata": {},
+   "source": [
+    "## Samples after regrouping\n",
+    "The regrouping of the samples is done internally in the Shape object by reading the dictionary `samples_map` in the style config."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "f4eb5461-92d3-43cb-8b75-75a9984f7054",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['ttbar', 'ttHTobb', 'DATA_SingleEle', 'DATA_SingleMuon', 'WJetsToLNu_HT', 'SingleTop'])"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "shape.h_dict.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "b083b293-ce50-4a9c-9ad7-aedad05020f1",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['ttbar', 'ttHTobb', 'WJetsToLNu_HT', 'SingleTop']"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "shape.samples_mc"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "67444510-60e3-4652-b0c9-efea3d33e238",
+   "metadata": {},
+   "source": [
+    "## Density plot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "4b3a1212-c6fd-41bc-a0b5-47062e26bded",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABEQAAAM/CAYAAADYxwevAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAD6yUlEQVR4nOzdd1iT19sH8G8A2YgiTlDciqMOXBUHOItbq9bViqNaxdGqtba2Ks7aap1o3btqtXWvirMVt6K4EUEEFRUHU+Z5/+DN80vIIGEFzPdzXbmuh5zznHMnJJDnzhkyIYQAEREREREREZERMTF0AERERERERERE+Y0JESIiIiIiIiIyOkyIEBEREREREZHRYUKEiIiIiIiIiIwOEyJEREREREREZHSYECEiIiIiIiIio8OECBEREREREREZHSZEiIiIiIiIiMjoMCFCREREREREREaHCRHKUnx8PA4dOoQxY8agWbNmqFy5MmxtbWFpaQknJye4ubnhq6++wpYtWxAXF6dTmx4eHpDJZFpvBw4c0KmtwYMHZ9nWjBkzsmwnNTUVhw4dwsSJE+Hh4QEXFxfY29vDzMwMxYoVg4uLCzw8PPDNN99gz549SEpK0ik+IiIiIiIiKnjMDB0AFVzx8fFYvHgxfvnlF8TExKit8/TpUzx9+hTXrl3DqlWrYGtrC29vb/j6+sLBwSFH/QcEBKBr165Z1rtw4UKO+klLS4Ofnx/mzZuH58+fq63z7t07vHv3DuHh4Thz5gwWL16M4sWLY+zYsZgyZQqsrKxyFAMRERERERHlL44QIbUuXryIatWq4ccff9SYDFEnLi4Oy5cvR40aNXQe4aFJQEBAlnWio6Px4MGDbPfx9u1btGrVCuPHj9eYDNHkzZs3mDlzJurWrYuHDx9mOwYiIiIi+jDt2bMHMpkMqamphg6FiNRgQoRU7N27Fx4eHnj27Fm223j16hV69uyJP/74I9ttXL58GSkpKVrrXLp0KdvtJycno0OHDjolXrQJCQlB69atERERkaN2iIiIiOjDkZ6ejhUrVhg6DCLSglNmSMn169fx2WefITk5WW25qakpWrRogapVq8LS0hJhYWG4efMmnjx5olI3LS0N3t7eqF27NurVq6d3LImJiQgMDETjxo011snJdJnffvsNly9fVltmZWWF5s2bw8XFBdbW1njy5AlCQ0Nx8+ZNtfWfPn2K8ePH46+//sp2PERERERU+EVFRSEwMBC///47/P39DR0OEWnBhAhJ4uLiNCZDZDIZfHx8MH36dDg6OiqVpaamYsuWLZgyZQpevHihVJaSkoLBgwfj2rVrMDHRf0BSQEBAniREUlNTsXDhQrVlEyZMwA8//IASJUqolN28eRNz5szBn3/+qVL2999/4/bt26hdu7ZesTx+/BgVK1bMsp6VlRUqVaqEGjVq4JtvvkHLli316ie3/fXXX+jduzcA4MSJE2jTpo1B4yEiIiIqCGrUqIF3794ZOgwi0gGnzJBk2bJlCA4OVrlfJpNhy5YtWLZsmUoyBADMzMwwZMgQHDhwABYWFirlN27cwKlTp3SKIfPipNqms6Snp+PixYtaz9ckICAAr169Url/2LBhWLBggdpkCAB89NFH2L59O/r166e2fM+ePTr1r0jTKJXMEhMTcefOHezZs0da98SQFON2c3OTjmNjY2Fqairt8BMSEpLvsTVt2lTqf926dfnePxERUWElhEBISAjOnDmDixcvIioqKtf7eP/+PQIDA3H58mWddyjMysOHD9G7d2+ULVsWNjY2WLx4MQBg48aN0meC/LJp0ybs2rULu3btQq1atfKt39wUHR2NgIAA3Lx5EwkJCdluR/H5z+7t9OnTOX48ycnJKF68OGQyGUqWLKnXmi7ydWBkMhkmTpyY41jyyvPnzxEQEICAgIAcLX2QE3nx3s5rTIgQgIw/EsuWLVNbNmXKFAwcODDLNpo0aYI5c+aoLduwYYNOcWQeDaItIXLv3j2V7HuTJk106uf+/ftq7x80aFCW/zBNTEywdOlStWU3btzQqX9FiomFUaNGYdmyZSq3+fPn46uvvlJKSC1duhRHjhzRu7/cIo+7Ro0asLe3l+6/dOkS0tPTAQAlS5ZE5cqV8zWuxMREXLt2Tfr5448/ztf+iYiIDKFs2bI6XVw2atRI7fkpKSlYvHgxKlasiKpVq8LDwwPNmjVDmTJl4O7ujrNnz+Y4xnPnzqFZs2awsbFBgwYN0KRJE9jZ2aF27drYv38/hBDZajcmJgZt2rTBX3/9hefPnyMhIQFv377NcbzZ1b17d/Tu3Ru9e/dGyZIlDRYHANSrVw8ymQzv37/Psu67d+/wzTffoFSpUnB0dIS7uzvq1asHGxsbfPTRRzh8+HA+RJw3zM3N8emnnwLIWOtQnySL4heeffr0ye3QEBoaim+//RYdOnRAhQoVYGdnh2bNmuHLL79U+kyryaVLl9CyZUuULVsW7u7ucHd3R7ly5eDu7p7t0fT6vG6AvHtv5wtBJITYuXOnAKByK1OmjIiLi9O5nVevXokiRYqotFO9enWleq1bt1bb3/fff69yX3h4uNq+1q1bp1TP1NRUTJo0SW2706dPVzp39uzZauudP39e58dat25dYWNjo3Rr166dzufLtWnTRuo/LCxMa93Y2FjRpEkTqf7gwYP17i83pKWlCXt7ewFADBo0SKls1qxZUnzdunXL99j+/fdfqX97e3uRlpaW7zEQERHlp9jYWLWfa9Td3NzcVM6PiYkRHh4eWZ67du3abMc4c+bMLNsfMmSISE9P17vtP/74Q2qjX79+YseOHSI4OFgIIcSGDRukMkOQf+ZNSUnJ977v3LkjPfbExEStdaOjo0XNmjWz/B2NGjVKrxgiIiLEkSNH1N4GDhwotTt//nyN9aKjo3PyNEiOHz8u9TdixAidzklOThbFixcXAET58uWz9frU5o8//hAWFhYan28TExPx9ddfi/fv36s9f+/evcLMzEzj+aampuLvv//WKyZ9XjdC5O17Oz8wIUJCCCFGjhyp9sU7adIkvdv65ptvhLu7u9KtZcuWIjk5WaqjKSGyb98+YWJionTfjh071Pbz5ZdfqvyDnz59uk4JkYULF6qtN2bMGL0fb06kpaWJokWLCgCiZMmSOv2hOHHihBRvo0aN8iFKVffv35diWLx4sUFiICIiogyBgYHS/2U/Pz+NF5ZHjhwR586dUzm/b9++Sp8tjh49Kl69eiUePnwoVq5cKYoVKyZdXF2/fl3v+E6ePClkMpkAICpUqCC2b98unj59Kl69eiUOHTok6tatK/W/adMmvduXX5A5ODiofJYy1oRIamqqaNeunc4XtoMGDZLqfvLJJ+LcuXPi9evXIiIiQmzdulU4OTlJ5fv378+VGBU/t586dSpX2tQmJSVFlCpVSgAQjo6OOv1O/P39pRgnTJiQq/FcunRJSmbIZDIxdOhQsWbNGrF161YxYcIEYWtrK/X93XffqZwfHh4u1SlatKjYsGGDeP36tYiOjhbr168XdnZ2AoCwsbERjx8/1ikmfV83ef3ezg9MiJAQQohatWqpTRCo+6eZGzQlRE6dOiXq1aundN+4cePUtqH4BpMnM3RNiPz1118aM5je3t7i9u3befK4M7t3757Ub6dOnXQ6Jzw8XDqnTp06eRyhelu3bs3z1wgRERHpZvfu3dL/5Tdv3uh1bkBAgHRu27Ztlb7Aknv06JF0cdW1a1e945OPPrGxsREhISEq5a9fvxZly5YVAETFihX1bl/++c/FxUWlzJgSIunp6eLZs2di165donnz5kqfb7Vd2L548UKYmpoKAKJNmzZqv6C7d++eMDc3FwCEu7t7rsSb3wkRIYQYM2aM1Ofx48f1qn/hwoVcjcXLy0tKhqiL5cmTJ9KoHRMTE5X+R40aJcV24sQJlfMVR8SMHj1aYxzZfd0Ikffv7fzANURIWqwzMxMTE9SvXz/f43F3d1f6Wd06IrGxsbh165bSfc2bN9e5j1atWqFIkSJqyzZu3IjatWujbt26GDVqFLZu3Yq7d+/qtfiSrq5cuSIda9tNR9GDBw+k4/Lly0vHrVq1gkwmw5gxYwAA//77L7p37w5HR0eYmJjgzZs3Su2kp6fjn3/+weDBg+Hq6gobGxuUL18eXl5eWL16NdLS0rKM29TUVOU1UqFCBchkMnTr1k3p/ujoaGn+8pEjRyCEwJ49e+Dl5YVSpUrB0tIS1atXx/z586U1SADg9u3bGDVqFCpXrgwrKyu4urpiwoQJGhdq+uKLLyCTyWBvb6/UDgBUr14dMpkM06dPBwAEBwfju+++Q7169VCsWDEUL14cLVq0wL59+7Kc6xgdHY05c+agQ4cOqFGjBqytrVGqVCm4ublh6tSpareizvwcLViwAACwf/9+tG3bFsWKFYODg4PSc9WrVy+tcYSEhKBIkSKQyWQYMWKE1rpERPRhevjwIQDA0dERxYoV0+vcP/74Qzr28/NT+/moUqVK0v/Ow4cP4/Xr1zq3n56ejqtXrwIAunTponZtseLFi2PQoEEAgLCwMERHR+v1GPKat7d3lmuz/PzzzwaNMSYmBo6Ojihbtiz69OmjdR2+zO7cuSN97ps8ebLa9fRq1KiBTp06AcjYdTGrz0kFleLGCOp2jVQkhMDevXsBZHx203WtQl3ExMTg6NGjAIDevXujXbt2KnWcnZ2xadMmABnvozVr1khlycnJ2Lp1KwCgRYsWand7bNeunXR9tG3bNrXXMjl53XwI720ABkqVUoHy5MkTtSMl8jKLp22EiOLoA/z/8Mz4+Hil8xWHr8lvYWFhOo8QEUKIsWPHahwlou5maWkpmjRpIkaOHCk2bNggIiMjc/w8jB8/Xmr/4MGDOp2juM7Kr7/+KoTIGN5mY2MjAIg1a9aI77//Xhq+BkDUqlVLqY379++LVq1aaX289evXF0+ePFEbg7u7uwAgPvroI6X7o6KipPNnzJihVHbs2DGp7MaNG6JHjx4a+542bZpIT08Xs2bN0jgvslmzZiI1NVUlNldXVwFAeHh4KN3/9u1b6dytW7eKGTNmqF3vRn5bvny5xt/BokWLhLW1tdbnz87OTu2aNIrP0eHDh8XgwYOVzuvUqZNIT0+XhkA2adJEYxxCCNGvXz8BQFhbW4unT59qrUtERB+m4cOHCwDi448/1vtc+dpkZcuW1Vrv1q1b0v+q3bt369z+s2fPpPO0TTlYunSp3t/Ea/rcp/jZL/MIkadPn4rx48eLypUrCwsLC+Hg4CBatWolfv/9d42jOP7991+xYcMGrbebN2+qPTe/Roi8efNG6+cSbd/0K67Lp2ntPiGE0lp9UVFROY45JyNEXrx4IaZOnSrq168vihYtKmxtbUXdunWFj4+PuHfvnsbz0tLSRIUKFQQAUaJECa2/l8uXL0vxTZw4Ua/4snLy5EmpbU3LA8jJR1g0bNhQuu/UqVPS+fPnz9d47rx586R6//77r0p5Tl43efnezk9mIKOnKcuv7zcMuSXzCJG0tDRcvnwZrVu3lu7LvGJyuXLlUKFCBb36+eWXXxAUFKTzKtPv37/HpUuXcOnSJaxatQpAxgrMnTt3xtixY1GmTBm9+geUd5jRZYRIUFAQFi5cCACwtLSUdv958OAB4uPjAQDr1q3DhQsXIJPJ0KZNG9StWxft27eX2ggMDISnp6e0+nrNmjXRunVrVKxYEWFhYfjzzz/x5s0bBAYGol+/fjh16pTSt0WpqanSiteZY5ZniQHlrXgzlw0dOhRXr16Fm5sb2rVrB3Nzc+zYsUPa9nnx4sV4/PgxNm3ahBIlSqBz586oWbMmrl27ht27dwPIeA0cPnwYXbt2ldqNi4vDvXv31PavuEr3kiVLcPnyZZibm8PLywtubm5ISUnB5s2bpW3KJk+ejOHDh6tsJb1q1Sp88803ADJWLO/Zsydq1aqFIkWKICgoCHv37kViYiJiY2MxYsQI3Lx5U+PzMHPmTFy4cAHm5uZo27Ytateuje7du0Mmk8HFxQW3b99GZGQkNLl27Rp27NgBAJg0aRLKli2rsS4REX245CNEqlatCiBj9G9ISAhevXqFsmXLolq1ajAxUT8wXP55wMnJSWsfit/+ahsFmVmJEiVgZmaG1NRUldG9ihTL8ur/2Y0bN9C+fXu8fPlSui8pKQlnz57F2bNnsXbtWhw+fFhlZ5gWLVqgRYsWeRJTbrG3t0dsbKzSfXPnzsW8efOyPLdGjRpSPW3PvfwzkqmpKRwcHHIQbc4cPXoU/fr1U9ltMigoCEFBQVixYgXmz5+PSZMmqYx2MTExwWeffYZff/0V0dHROHXqlNLnZEV5ubvMixcvpOOsrmHKlCmDZ8+eKe34Iv/MDAAdO3bUeK6Xlxe+//57ABnXC5lfxzl53RSk93aOGDojQ4anuCuH4i235geqo22ESHp6uihXrpzS/XPnzlU6v0uXLkrlvXv3FkJo/qZA3QgRITJWjp42bZrSokXZuVlZWYmVK1fqtXpySkqKsLKyEkDGIkRZOXjwoHB2dpb6/PHHH6WyLVu2KMVTt25dcfHiRZU2Xr58KS0mZWtrKzZt2qQyyuLFixeidu3aGr8FunnzplT2+++/K5Up7jCTebTCp59+KpWZmpqqPF9xcXGiatWqSo/j008/FS9fvlRqZ8KECVL5zz//rFSm+Frevn27Utmvv/6q1Labm5u4deuWUp3o6Gil5zjzwnGvX7+W5s9WrFhRPHr0SOU5vnv3rrRQLtRk1hWfIwCiVatWar/J6NSpk/RcqRsJI4QQ7du3FwBEqVKlRExMjNo6RET04ZP/7xoxYoT48ssvpfUg5LcyZcqIWbNmiYSEBJVzP/nkEwFkLO6ujeIIkcmTJ+sVn3w0IwBx6NAhlfJr165J/1+bNWumc7vBwcFKu5WUKlVKWjxW3S4zLi4uAoBo3ry5+Pnnn8XWrVvFuHHjRMmSJaU6zZs31/h/NzsMucuM4udiXXYL0ebOnTvS5+Xu3bvneny6jhA5f/68NHrYzs5OfPPNN2Ljxo1i06ZNYuzYsUojeOUjqTO7evWqVOfLL7/U2Jd8jcUKFSrk+g4pDx48kEYXvXv3TmO9mJgY6TEpPu+KO7u8fv1a4/nR0dEar6c00ed1k1fv7fzEhAgprUyueFMclpXbtCVEhBCiT58+Svd37txZOjc9PV04Ojoqlf/2229CCP0TInLy1Zj79eun0rY+t4ULF+r8HNy4cUM6z9XVVSxbtkzltmjRIjFq1CjRtGlTpX46duyo9I/166+/lsrKli0rXr16pbbPESNGSAmcs2fPaoxNcXpL5iFwisMqr1y5olQmnwZTrlw5lTYrVqwonbdkyRK1/fr4+CglCtQt7Hb69GmpzqpVq5TKFi9eLJU9ePBAqUzxD3alSpU0/vP54YcfpHqXLl1SKlu9erVUpm7xKrmOHTtKH0AzU5wq9NFHH2n8R6O4UJa66VmK08ZWrlypMRYiIvqwJSQk6Pw5pVGjRiqfEb799luN/9cVKV6Aff7553rF+OLFC1GtWjUBZCwOOXToULFx40axbds2MW7cOGnb0VKlSqn8/9aFrouqAhmL8GdOeISFhYmPPvpIqrN582a9Y9CksCZE7ty5I7Zt2yaWLl0q+vfvL32JV65cOfHw4cNcj0+XhEhaWpo0NbpOnTri+fPnKnXCw8OlhUitrKzU7q6Snp4uqlevLgDN02YUd1TM7eky+pg2bZoUx7Jly6T7R48eLYCMBVnT0tI0np+amipNo9e0UUVm+rxu8vq9nR+YECGNa4hUrVo1z/rMKiGyaNEipfsdHBykN/vDhw9VzpPPR8tuQkRRWlqauHr1qli1apX46quvRLNmzbJcL0J+MzMzE2FhYTr1s3bt2mwlXUaMGCGSkpKU2mrZsqVUfvToUbX9PXnyRNrSeNq0aVpjU5xPOHDgQKWyr776SgAQ5ubmKnGUL19eAKor0L969Upqr27duhqz7IpbvmUevSG3d+9eqc4///yjVPb5558LIGPrscz/HOR/rAGIgIAAjY996tSpUr3M+97fvXtXnDp1Spw5c0brNwXyf7JdunRRKZM/R6ampiIoKEhjGz///LPGxExaWppo1KiRACBq1KhhkA9ZRERUMAQFBSl9ThgwYIC4efOmSEhIEMHBwWLLli1Kox8Vv2QSQnmXmSZNmqj9tvnkyZPSt7wARPv27fWO8/Xr16Jt27YaP980bNhQREREZOs50DUhUq1aNY2jPxSfx9atW2crDnUKa0Lku+++U/kdffLJJ+LZs2d5Ep8uCZEjR45I9bWtE6L4Za/8S9PMFBMNmT9PCiHE/PnzVa4z8lN6erpYuXKlFEOpUqWU1lSUj7wuXrx4lm0VL15cABCfffaZTn3r+7rJy/d2fuAaIoQSJUqovf/x48dITk6Gubl5Pkekuo7I69ev8eDBA9SsWVNl/RALCws0aNAg1/o2MTFBw4YN0bBhQ+m+1NRUBAYG4syZM9i3bx/+/fdfteempqZi3bp1mDlzZpb9KK4foo2VlRWcnJzQrl07DBs2DI0aNVIqT09Px/Xr1wFkzB3u0KGD2nbWrVsn7bpiZmaG5cuXa+wzKSlJOnZxcVEbd/369ZVeGy9fvpTmFGeOUXH9jiFDhqhdvRzImNsLZKz/Ubt2bbV1FNfk0LROiZubm9Jc6Xfv3klzLd3c3PDxxx+rbVsxhipVqqjMj61ZsyZq1qyp8dykpCTs2LFD2gmoadOmSuWKz5Gnpyfq1KmjsS3F5z0yMlJpvZbdu3dLO/3Mnz8fZmb8U05EZKxCQ0Ol9a6+/fZbzJw5U/o/W7VqVVStWhVdu3ZFs2bNcO/ePRw6dAhnz55Fq1atAAAff/wxRo8ejRUrVuDSpUuoU6cORowYAVdXV0RHR+Ps2bPYsWMHTE1NUaRIEaSkpGjcqU+TtLQ0LF26FP/995/GOjdu3MDChQsxd+5cWFpaZvPZ0G7ChAkwNTVVW1anTh10794d+/btQ1BQUK71qetadYXBsWPHMH78ePz+++8oXrx4vvd/5MgRABlr+NWoUUNjvXr16qFSpUoIDQ3F2bNnpbXfFPXr10/6vP7nn3+qrCMiXz8kt3eX0UVoaCgmTJgg7XBjYWGB3bt3w9raWqoTExMDIOM6ISvy95M+u0PpqqC8t3OCn6JJ2sr07t27SvenpKTgzp07Btl6t379+rCyskJiYqJ0X0BAgNqESOPGjfM8aWNmZoZGjRqhUaNGmDhxIi5duoRevXqpXfDy3LlzOrUpv6CVyWR49+4d7OzsshXbgwcPpC1oP/30U43JBvlipAAwbdo0ndtXvDBPSkqSEhLZXVBV3bZgABAfH4/bt28DyEgWaCJPyGROWMTHx2tcUFWeMAKAzz77TGPbQgipfW2L3CYkJOD+/fsICQlBSEgIHj58iFu3buHatWtITk6W6mX+B6r4PHz66aca2wdUEyJyKSkp+PHHHwEALVu2VNnemIiIjEvXrl2VFltUx97eHosWLYKXlxeAjAtAeUIEyEiux8XFYfPmzXj69ClmzJihdL65uTk2bdqEL7/8EikpKbC1tdU5PiEEhg4dis2bNwMAOnTogMmTJ6NOnTooUqQI7t69i2XLlmHnzp1YtGgR7t69i71796osap4bsrqwbdq0Kfbt24fXr1/jzZs3BrnoLyh+/vlnzJs3Dy9fvsT9+/exdOlS7N69G3/++Sfu37+Pixcv5snvSBv557kbN25o/Lyb2fPnz9Xe7+rqinr16uHGjRvYs2cPVqxYISX6nj17Jl1v9OnTR+e+ciomJgbz5s3DokWLpC8nHRwcsHXrVrRs2VKprqOjIwCoLCyrzps3b6S2clNBem/nhPrlpsnoZH6TyR08eFDvtgYMGABHR0elW+ZRBlkpUqSIyrfr8n2xz58/r3S/tm/7Nfnvv/9UbvKRAbpo0qSJUoJBkaY/vIoUEws1a9bMdjIEUL7Ilu8Pn9nLly+1rv6sjeLv7ubNm0hJSQGgOgpEl4SIlZWVxpEf169fl0awaEpGKCYsMvcfGBgona8tIaNpJXEAiIiIQFRUlMYYbt68iVGjRqFUqVJo2LAh+vTpgylTpuCvv/6CiYkJJkyYgE8++USqr+050vS7klNccVwxIbJu3TpptMuvv/6ab/+kiYiocOvQoYP07azi/yMAsLW1xaZNm3D48GH069cPtWrVgoWFBcqVK4cvvvgCgYGB6Natm/QFTOZdWLTZv3+/dME0fPhwHDt2DG3btkXp0qXh4OAAd3d37NixA7NmzQKQsYPImjVrcuMhq6hYsaLWcvkuPQAQEhKSJzEUJjKZDKVKlULLli2xa9cujB07FkBGQuKPP/7I93hevXql9znykRTq9OvXDwCk3Wbk9u3bJx337dtX7z6z4/jx46hTpw5+/vlnKRnStWtX3Lp1S0pkKpLvbhkfH6/0ZVxmiYmJUsK0XLlyuRpzQXpv5wRHiBCAjG/tV69erXL/pk2bMGXKFJ2H5KempuLQoUMqf3yyk2F3d3dXGmYYEBCAhIQElcRF8+bN9W67a9eu0jZzcqVKlcLz5891vsBs0qQJbG1tpQ8H+rhx44aUWMh88a4v+YcamUymNM1HUWBgoHS8ZcsWDBo0KFt9adsmWB5HuXLlVLYglpc1bNhQ42tJsW1N3+BERkZKCafsjFCxtLTUmJDJHINi+0IIzJ07Fz/99BOEEHB1dUWfPn3w8ccfo2HDhihZsqT0upF/41atWjWVTLw8jlKlSqF8+fIa4wAytiWTD02WJ0Ti4+Ph6+sLIOMfdOakIRERkSYmJiaoVq0agoKCEB0drbaOl5eX2osvAAgLC5OOtU0fzWzdunUAMrZqXbRokcZ633//PVasWIFnz55h3bp1GDNmjM596ErTdBm5tLQ06ZhfOKj66aefsGzZMgDA2bNnMWTIkHztPzU1FUDGZzRdpqcD2qeUfPbZZ9KWtLt27ZKmncuny7i4uGgdMZwbkpKS8PXXX+P333+X7qtXrx4WLFiAdu3aaTxP8bP2mzdvULp0abX15KNDgNzf8rYgvbdzggkRAgD06NEDZcqUURnd8PDhQ/j5+WH8+PE6tfPPP/+ozcRWr15d75gyJzru3r0Lf39/6Y+hXHZGiJQrV04lIfLixQsEBwfrHGtsbCwSEhJU7ndycsryXPl0GUB1FIG+5BfZrq6uGoewyveNB4BixYpluy953DY2NiofhuRxZH48r1+/RmhoKADt01AuXboEAFpHFOmSkLG3t0eVKlXUljVs2FDrvGd5+/J1ZOTWrVsnTVNZsmQJfHx81H6oSktLk4ZzqkvqKD5HWX3QMjExQfny5fHo0SNEREQAABYvXoznz5+jSJEimDt3rtbziYiIMpN/hipatKje5yp+uVK3bl2dz3v48CEA7Z9TgIyLKjc3Nxw8eFAaCZnbQkNDtU4FVxwVIp+SYAwmTZqEiIgINGzYEJMnT9ZYr2TJknBwcMDr16/x9OnTfIwwg/yLpsTERKURudlVqVIlNGvWDBcuXMDff/+NFStWICEhQRotktfTZdLT0/HFF1/gzz//BJAxUmvhwoUYNmxYlsk7xYRIUFCQxoSIfDo6kPsJkYL03s4JTpkhABmL9ciHwWX23Xff4eTJk1m28fTpUwwdOlRtWc+ePfWOSV2iY/HixUo/V6lSReMfAG0U580qGjRoEOLj43VqY9OmTdIUDUW6LPCqeGGfkxEiiguqakusKI7KCA8P19rmtWvXMGPGDMyYMUNaAFROHnfDhg2V/lC/evVKajfz41FcUFXb3F15202aNNH4z0deRyaTqTzPikkPxQVVY2JipEVOs8ryy9uvVasWbGxsAGSs2fHTTz8ByEgcjhs3TuM/qX379kkjhjI/VsXnSNckmDwxFBkZiVevXuGXX34BAIwePVol6UNERMbJy8sLderUwejRo7XWS01NlS5gFKeG3LhxQ/q/r25tNLnt27cDyPjiQZ/RufL1AmJjY7OsK/9SLa/WhlP8Qkod+fTsEiVKKE1d/dDdvn0bO3fuxI4dO7TWS0hIkEYc2Nvb50doSuSjfENCQrROExFC4NixYzh69Kj0mtdEPm3m9evXOHXqFA4dOiSN4u7Tp08uRa7eDz/8ICVD6tati6CgIIwYMSLLZAigfL1x6NAhjfUOHz4sHef2upAF6b2dE0yIkGTs2LFK/yDlkpKS0KlTJ8ydO1dtsiA9PR07d+5E69atpfUXFBUvXhy9evXSO57ixYurTG9QnN8HZG+6DAD0799f7f2XL19GmzZtcPDgQbXJDiDjwnbOnDn4+uuv1ZZrW7RTsR8gYxRATv44BQcHS3+EtF1k16tXTzo+fvy4xnoxMTHo27cvfH19sWXLFqVMcnx8PO7cuQMg+wuqakpIvH79WvpWRlvSQv68ubq6Kq27kpCQIC0KrG1BVW1tp6enq11Q9d69exqn6SiKiIjAlClTpJ+1LaianYTI3LlzERMTg6JFi0qjVYiIiFxdXXH79m2sXbtW6zpmW7dulS70FL9dt7Kygq+vL3x9fbF161a1575+/RoHDhwAkPEllz67zHz00UcAMnYvvH//vsZ6r169kv5Xys/JbQsXLtT4+e7atWvSxeMnn3xiVFNm5J//7969q/azvNyJEycghACQ9ZdMeaFt27YAMkaIrFq1SmO9o0eP4pNPPoGXl5fSVC91+vbtK/2u//zzT2lnl7yeLvPmzRvpi97q1avj9OnTWa5xo6hOnTpS0m7//v1K073k0tLSpPdtpUqVtE4bz46C9N7OCSZESGJnZ4cdO3ao/SeXlJSEqVOnolSpUujSpQtGjx6NUaNG4ZNPPkHFihXRr18/jRnYn3/+OdurGmfefjez7CZEWrZsie7du6stu3TpErp27YqKFSuiQ4cOGDp0KL7++msMHDgQHh4eKFeuHH788UfpH4Ki3r17a1zHQy4uLk66eM9qiFlWdL3IrlGjhvRHc+/evdi2bZtKncePH8PT01NKTGReO0bboqe6JESKFy+ucVSD4jc22hZUldfLXEdxQVVtC5lq+8cWHBwsZa8V6ymu3H/x4kWV33taWhr27t2LZs2aKQ0DrFWrlsY4dB0VJE+IxMXFSdsk//DDD0Y1jJeIiLSTfxGTkpKC/v37q91x5vr169JUiLJly0rfigMZF2Py6cI///yzygVkUlISvL29kZiYCBMTE/zwww96xTd48GDpeODAgWrXL4mLi8PgwYOlL96++OILvfrQ1b179zBhwgSVi8fQ0FB8/vnn0s8FbY2DvCb/Euf9+/eYMGGClDhTFB4eLj0v5ubmOn0BmNt69eoljQyfMWOG0ohruefPn2PcuHEAMl7r2nYulNfx8PAAkLF2iHxr37yeLrN161Zp8dRFixbpfa0kk8mkJQ0ePXokjSJW9Msvv0if68ePH5/rj6cgvbdzRBBl8tdffwkLCwsBIMe3r776SqSlpan00bp1a7X1T506pVRv48aNWtu/ceOGUv3p06errTd9+nSVGCIjI0XVqlVz5XECEJUrVxbPnj3L8vk9e/asdM4XX3yh1+8mswkTJggAwtTUVMTHx2ute+TIEaV427VrJ6ZOnSpmzZol+vTpI8zMzKSyr7/+WqSnpyud/9tvv0nlwcHBSmW9evUSAISTk5NKv5UrVxYARIcOHTTGNmvWLKntqKgotXUePHgg1Vm2bJlS2dKlSzXGNmDAAAFA2Nvbq30tym3ZskVq4/Lly9L98fHxSs9Ny5Ytha+vr5g7d64YOnSoqFKlilRmbW0tHffv318cOnRI5TkqV66cxhgyW79+vdLvrHz58iIhIUHn84mIyDiMHj1a+l/h4uIi5s6dK3bt2iVWrlwphg0bJkxNTQUAIZPJxNGjR1XOP3r0qHR+8eLFha+vr/jrr7/EsmXLRN26daWy2bNnq+1f8fOXus9cgwYNUmp/8uTJYsuWLWLr1q1i6tSpokyZMlK5h4eHSE1N1evxy/t3cXFRKduwYYP0GUX+f7pFixbil19+Edu2bRPjx48XJUqUkPofOXKkXn3nhqyev9xoNzExUWO99+/fK30mrl27tpg3b574888/xbp168S4ceOElZWVVD5v3rxcjy/zNYAmf//9t3SOmZmZGDFihFi7dq3YuXOn+PHHH0XJkiUFAGFiYiKOHDmiU5urVq1S+Vx/6dIlveLX9/fWt29f6TP8/v37xZEjR7K8Xbx4UamN+Ph44erqKsUwYMAAsX37drFt2zapffnvU5/Pj7q+boTI+/d2fmBChNT677//RKlSpbKdHDA1NRVTp07VeAGqa0IkODhYYx92dnYqbyp9EiJCCPHs2TPRtGnTHCdD3NzcRGRkpE7P7cKFC6Xzli5dqtM5msifx48++kin+kuWLBGWlpYaH4eNjY2YOXOmSjJECCH69+8v/bHLXO7i4iIAiG7duind//r1a6ntqVOnaoyrW7duGj/IyG3btk1q68KFC0plgwcPlpIemWOrUaOGACDatm2rsW0hhBg3bpwAIMzNzUVSUpJS2dy5c7X+/kuWLCkOHDggunbtqnT/tGnTsnyOtDlx4oRSe5s2bdL5XCIiMh5JSUkq/4PUfW76+++/NbYxZ84cYWJiovH8SZMmqf18IETWF4ZJSUli4sSJokiRIhrbl8lkYsiQIeLt27d6P35dEiLu7u5i3759Shf2mW/9+/cXycnJevefU4ZOiAghxJ07d6TPKppuJiYmYtasWRpfBzmJT9eEiBBCrF27VutrycbGRqxdu1bn9l69eqX05ZeLi4tOjzEnvzcPDw+9rzdat26t0s6DBw+kLx/V3apVqyYePXqkV2z6vG7y+r2dHzhlhtRyd3dHcHAwpk2bJi0uqQsTExN06tQJly9fxuzZs5UWt8yOKlWqoFSpUmrLmjVrptOiQ9qUKVMGAQEBWL16dbYWqXRxccGKFStw8eJFnff2VpwektMFVeULlurazrhx4xAYGIgRI0agcePGsLGxQfny5dGmTRtMnz4dYWFh+Omnn9QOqZPHnXmHlOjoaDx+/FhtHIoLquqyNoi2OvL+zczMlNZEAZQXVFWMLTY2Vu8FVevVq6ey4NOUKVOwa9cutGjRAiVLloSpqSkcHBzg6emJJUuW4NGjR+jSpQsmTpyIGjVqoEiRIqhWrZo0BFPbc6SN4oJu9erVw8CBA3U+l4iIjIe5uTn279+PEydOoHv37nB1dYWVlRWKFi2KBg0a4Mcff8TDhw+1LnL/ww8/4NKlS+jduzeqVasGCwsLVKhQAf3798e///6LX3/9NdtD7s3NzbFgwQLcunULo0aNQsuWLVGyZEkUK1YMzZo1w9ChQ3Hp0iWsX78+Txfr7NatG65du4ahQ4eifPnyKFKkiDQdfN++fdi2bZte66N8SFxdXXHjxg38+uuv6Ny5M2rWrAkrKyu4uLigY8eOmDRpEu7evYsff/zR4OurDBs2DPfu3cO4ceNQs2ZN2NjYSK+l8ePHIzg4GMOGDdO5vRIlSkhb7gJ5P10GyNjdMjdUq1YN169fx8yZM1G3bl3Y2trC1tYW9erVw5w5c3Dt2jVUqlQpV/pSp6C8t3NCJoSahRAKqcOHD+P333/HtWvX8PLlS5QpUwbNmzeHj48PWrRokeP2Q0NDsWzZMhw6dAhPnjyBtbU1atSogYEDB2L48OFZrpobHx+PNWvWYN++fbh16xbevXuH8uXLo0aNGnB3d8fXX3+tV/Ihv8TGxuLEiRM4fPiw9NzK38TFihWDo6MjGjRogCZNmqB79+4oX758lm16eHjgzJkzKvefOnVKuoiU69Wrl7QfuKJp06bB19dX6b4ZM2ao3AcA06dPx4wZM7TGJITAhQsXcOzYMVy/fh137tzB27dvERMTAyEEihYtimLFisHV1RUNGjRAhw4d0Lx58xwnfYg0OXfunPS369ixY0r/rImIiOjD0rJlS3h5eem9TgsZFn9vhdsHkRBJS0vDqFGjsGbNGo111F086+PQoUMYMGCAtOhiZk2aNMH+/fu17gHduXNn6VtidZycnLBy5Up07dpVbfm6deswfPhwneJ1cXHJclVlIiq40tLS0KRJE1y7dg0dOnTAsWPHDB0SERER5aHatWtjypQpSgu8UsHH31vhZpZ1lYJvxowZUjKkaNGiGDRoEFxcXHDnzh3s2LEDSUlJmDlzJpydnfHll1/q3X5QUBD69OmDxMREABn7vbds2RKxsbHYvn07wsLCcOnSJfTt2xf+/v4qQ+3evXunlAyRDz2rXLkynj59in/++Qf37t1DZGQkPv30U5w7d07t8P6s9tEmog/HmjVrcO3aNchkMrUrhxMREdGHISUlBSdOnEB4eLjSlshUsPH39mEo9CNEQkJCUL16daSnp6NChQo4c+aM0h7OV69ehaenJ2JjY1G0aFGEh4frPX/J09MTp0+fBgCsX78eQ4YMkcoSEhLQvXt3+Pv7AwA2btyotAURAMybN08aQtW7d29s2LBBaavVlJQUTJgwQdpWU9O3wX369MHu3btRrlw5fP/991pjtrOzU4mDiAqHGzduoHnz5khISMCwYcOwdu1aQ4dEREREeWTOnDn4888/sWDBArRv397Q4ZCO+Hv7MBT6hMiYMWPg5+cHANi/f7/a6SZLlizB119/DQBYsGABJk6cqHP7V65ckUZr9OrVC3/99ZdKnWfPnqFKlSpITExEnTp1EBQUpFTerFkzXLx4EdbW1ggNDVW7SGhSUhJcXV0RGhoKGxsbxMTEqKxNUb9+fdy4cQOdO3fGwYMHdX4MRFTwnTx5EleuXEFkZCR27tyJqKgolCtXDrdu3ULx4sUNHR4RERER0QenUK8GKYTA3r17AWQs7unl5aW2Xv/+/aXj/fv369WH4mKemnZ4KFu2LNq0aQMAuHXrFh49eqRULp/q4unpqXHHFAsLC7Rq1QpAxuKroaGhSuVCCKmd6tWr6/UYiKjgW7NmDb777jssXboUUVFRKFGiBPbt28dkCBERERFRHinUCZEHDx4gMjISQMY0EzMz9UuilCpVShrlERAQgPj4eJ37OHnyJICMrT7btWunsV6nTp2kY/n0GQB4+/YtoqOjAWSsHaJNiRIlpOM3b94olUVFRUlxV6tWTcfoiaiwSE1NhbW1NSpUqIDhw4fjypUraNSokaHDIiIiIiL6YBXqRVXDw8OlY09PT611PT09cfnyZaSmpuLhw4eoV6+eXn24ubmhaNGiWtuXu3v3rnRsaWmJy5cvA8gYSaLNnTt3AAAymQyVK1dWKlNcUJUJEaIPz65duwwdAhERERGRUSnUI0SioqKkY03b3copTlXRdbeW9PR0vHjxIkftW1paolGjRmjUqBGcnJzUniuEwJYtW3D06FEAQPfu3eHg4KBUJzg4WDp2cnLCvHnz0Lx5c5QoUQK2trZwdXXFmDFjcP/+fZ0eGxEREREREZExK9QjRBQTIlnNs1dMMMiTHFl58+YNUlNTdWq/WLFierW/evVqhIeH49WrV/D390dISAiAjNEfK1euVKmvmGTx8PBQ6ePevXu4d+8eVq5ciVmzZuH777+HTCbT2L+NjQ3ev38PU1NTjeuaEBEREREREeWWFy9eIC0tDZaWlnotZZFXPpiEiGJCQh3FhEZCQkKut29qagp7e3u8e/dOp/bnzp2Lx48fK93Xo0cPbNmyRWlLXjnFhMiLFy9Qs2ZNdOvWDY6OjggODsZ///2Hu3fvIj09HVOnToWZmRkmT56ssf/3798jPT0d6enp0josRERERERERHnt/fv3hg4BQCFPiLx+/Vo6trGx0VpXsVzXhIg+7cvr6JoQUWfv3r3o168fNmzYgJIlSyqVKSZEpk6dCl9fX5iamkr3paamYsGCBfj++++lOn379kXFihXV9mVqaor09PRsxanIzs5O69oq+oqKispyelJ+Y0y6K2hxCSHw9OlTlCtXTuuIqfxW0J4ngDHpo6DFxde57hiT7gpaXHyd644x6a6gxcXXue4Yk+5yO66YmBjExsbmuB3Fa1lDKtQJEXNzc+k4Li5Oa913795JxxYWFrnevmIfurQfFhaGtLQ0PHnyBDdv3sTs2bNx+fJlHDp0CG3atMGFCxeUkjDe3t7o06cPnJyc8Pnnn6u0Z2ZmhilTpuDBgwfYsGEDUlNT4efnh19//VVt/yVLlsTTp09RpkyZHK07YmFhofPzqYtatWpJi8sWFIxJdwUtrpiYGNjb2+Pu3bu5mrjLqYL2PAGMSR8FLS6+znXHmHRX0OLi61x3jEl3BS0uvs51x5h0l9txJSUlISkpKdvn16hRA8+fP1cZAGAohTohYm1tLR1n3qY2M8VyXUZ76Nt+SkqKNAdK1/ZNTU1RsWJFVKxYEV26dEGnTp1w7Ngx3Lp1C5s2bcLo0aOlumPHjtWpzZkzZ2LDhg0AgOPHj2dZ38TEpED9wSUiIiIiIqKCKadfiJuYFKx9XQwWzdChQzF06FAMGzYs2204OjpKx1klLN6+fSsdZ97BxVDtKzIxMcFvv/0m/XzgwAG92wAAZ2dnlChRAkDGKBQiIiIiIiIiUmWwESIbN26U5satW7cuW21Uq1ZNOn727JnWus+fP5eOq1evrlP7pUuXhq2tLeLi4rLdfkhIiLRlrru7O+zs7DS2UbNmTVhZWSExMRFPnjzRKUZ1KlWqhOjoaCQmJma7DSIiIiIiIqIPmUHHqwghcnR+rVq1pONTp05prXvy5EkAGSMxdE2IyGQyqY/r169rHSUibz9zXCdOnICXlxe8vLxw9erVLPuTDyFSXEgpOjoaYWFhCAsLk7YB1ubp06cAUGDmZREREREREREVNAZLiEyfPh3Tp0/HtGnTst1GzZo14eTkBADw9/dHSkqK2npRUVEIDAwEAHz88cdaR2lk1q5dOwBAeno6/P39NdY7duyYdNy+fXvpuEqVKtLxo0ePtPYVHh4urUNSvnx56f6//voLlSpVQqVKlbB//36tbbx+/VpKiDRs2FBrXSIiIiIiIiJjZfCEyPTp07PdhkwmQ/fu3QFkrMp86NAhtfV27NghHffo0UOvPhTrb9u2TW2dZ8+eSSNUateujapVq0pligmR9evXax0V4+fnJx3LEzEA0KtXL2lbosWLFyMtLU1jG3PmzJGOu3btqrFeQeXj42PoEFQwJt0V1LgKmoL4PDEm3RXUuAqagvg8MSbdFdS4CpqC+DwxJt0V1LgKmoL4PDEm3RXUuAoKmcjpvBUDCwkJQfXq1ZGeno4KFSrg33//RYUKFaTya9euwdPTEzExMShWrBgeP36s964qnp6eOH36NABgw4YN8Pb2lsoSExPRo0cP/PPPPwCALVu2YNCgQVK5EAJ169bF7du3AWTsAvPDDz8o7bsshMDmzZsxbNgwpKWlwd7eHo8ePVJanLV79+7S6JDx48fjl19+UdoWOD09HatWrcLYsWORlpaG8uXL48GDB7C0tFT7mJycnKR9ziMjI/V6PogKC/n2de/eveNuSvTB4uucjAFf52QM+DonY1DQrkMLfUIEAH766SfMnj0bAFCsWDF88cUXcHZ2xu3bt7Fjxw5pn+TMyQwgY3HXIUOGAABat24tJT4U3bx5E82aNZMWKe3atSvc3d3x9u1b7Ny5E6GhoQCANm3a4NixYzAzU16r9uDBg0qjNerWrYuWLVvCxcUFEREROH/+PK5cuSKVb9++Hf369VNq4+nTp2jUqJG0uGuVKlXQuXNnODk5ISwsDAEBAbhx4wYAoEiRIjh58iRatGih8TkraC9EorzADxZkDPg6J2PA1zkZA77OyRgUtOtQg+0yk5tmzJiBp0+fYv369Xj79i2WLl2qVC6TyTB79myVZIiuPvroI+zcuRMDBw5EbGwsDhw4oLItbvPmzbFz506VZAgAdOnSBcuXL8f48eORlpaGoKAgBAUFqdSztbXF6tWrVZIhAFCuXDns2bMHffv2RXh4OEJCQlQeJ5CxM86OHTu0JkOIiIiIiIiIjJ3OCZGZM2fmqKOiRYvCyckJbdq0QYkSJXLUVmampqZYt24devXqhd9//x1Xr15FdHQ0SpcujRYtWmDs2LH4+OOPc9RH165dcePGDSxZsgSHDh1CREQErK2tUbNmTXz++ecYNmwYihQpovF8Hx8ftGvXDqtXr0ZQUBCCg4MRGRkJe3t71KxZE15eXhg5cqTW56Zp06Z48OABVq9ejX379iE0NBQRERGws7ODq6srevTogZEjR8LW1jZHj5WIiIiIiIjoQ6fzlBkTExOlrWCzy8TEBJ999hnmz58v7RBD+a+gDVUiygscekrGgK9zMgZ8nZMx4OucjEFBuw7Va5cZIUSOb2lpadi+fTuaNGkiLTRKRERERERERJSfdJ4ys2HDhhx19PLlSwQGBuLYsWOIjo7Gs2fP0L17dwQGBnKKBxERERERERHlK50TIoMHD86VDp8/f47PP/8cJ06cQGhoKH755Zccr09CRERERERERKQPvabM5IYyZcpg//79KFeuHIQQ+P3335Genp7fYRg9+XowubEuDFFBZWFhgenTp8PCwsLQoRDlGb7OyRjwdU7GgK9zMgYF7TpU50VVc9uaNWswcuRIyGQyXLlyBQ0aNDBEGEbL2dkZkZGRcHJyQkREhKHDISIiIiIiog9cQbsOzfcRInIeHh7ScWBgoKHCICIiIiIiIiIjZLCESMWKFWFiktF9dHS0ocIgIiIiIiIiIiOk86Kqud6xmRnMzMyQkpKC1NRUQ4Vh9KKiolCrVi21ZT4+PvDx8cnniIiIiIiIiKiw8vPzg5+fn9qyqKiofI5GO4MlRJ4+fYrk5GTIZDI4ODgYKgyjV7p0ady5c8fQYRAREREREdEHQNsX6/I1RAoKg02ZuXTpknRcs2ZNQ4VBREREREREREbIIAkRIQRmzZoFIGN7qSZNmhgiDCIiIiIiIiIyUvmeEElOTsaYMWMQGBgImUyGgQMHwtLSMr/DICIiIiIiIiIjpvMaImfPns1RRy9fvsSNGzewb98+3Lp1CwBgZ2eHH3/8MUftEhERERERERHpS+eEiIeHB2QyWa50KoSAubk5tmzZAhcXl1xpk4iIiMjYPXv2DKtWrcLIkSNRtmxZQ4dDRArSUoDADRnH9YcApkUMGw8R6TllRgiRK7f69evj5MmT6Nq1a149LiIiIiKj8+zZM/j6+uLZs2eGDoWIiKjA03mEyODBg3PUka2tLcqVK4e2bduicePGuTbahIiIiIiIiIhIXzonRDZs2JCXcRARERERERER5RuDbLtLRERERKTN6dOnIZPJtN7Mzc3h4uKCDh06YNWqVXj37p2hwyb64F2+fFl6DxYtWhRpaWla6z948EDpfXvjxg2t9YUQKF26tFT/+PHjuRk+kRImRIiIiIioUEpJSUF4eDiOHz+Or776CjVr1sSePXvytM/AwEDMmDEDM2bMwNu3b/O0L6KCqEGDBrCzswMAxMbG4vbt21rr+/v7K/2cVYIjLCwML168AACYmZmhefPmOYhWmWKitWLFirnWrqKNGzdixowZ2LhxY560T7lL5ykzRERERESG0KRJE3z++edK9wkh8PbtWzx8+BCHDh1CdHQ0nj9/jl69emH16tX48ssv8ySWwMBA+Pr6AgC8vb1RrFixPOmHqKAyMzNDixYtcOTIEQDA+fPn8dFHH2msry4hMmnSJI31L1y4IB03atQINjY2OYw4f23cuBFnzpxB69at4e3tbehwKAsGS4iEh4dLxxUqVDBUGERERERUwLm6umLMmDEay5OSkjBnzhzMmjULADBixAjUqlUL7u7u+RUikVHx8PCQEiIBAQEYOXKk2nppaWk4efKk0n1nz57F+/fvYWlpqfYcxYRI69atcyliIvUMNmWmYsWKqFSpEipXrmyoEIiIiIjoA2BhYYGZM2diyZIl0n0jR47Mcm0DIsoeDw8P6fj8+fMa6129elVa26dp06YAgPfv3+O///7TeE5eJkQ8PDwghIAQAmFhYbnaNhVOBl1DRP5iJCIiIiLKqbFjx6Jly5YAgNu3b+PYsWMGjojow9SwYUPY2toCAIKDg/Hy5Uu19RSny/z888/S8T///KO2/vv373H9+nUAgImJCUd5UZ7joqpERERE9EGQyWT49ttvpZ83bNigtt69e/cwcuRING7cGGXKlIGlpSUqVaqEli1bYv78+Xj9+rXKOd7e3pDJZBgyZIh0X6VKlSCTyZS+LZdLTk7Ghg0b0L59e9SoUQPW1tZwdHREvXr10K9fP5w5c4ZfDFKhJV9HRE5xVIcieUKkevXq8PDwQKVKlQBoXlj1+vXrSElJAZCRdClatGhuhg0gY6aCTCbTur7Hq1ev4Ovri8aNG8PBwQE2NjaoW7cuhgwZgmvXrqk9R75Y65kzZwAAZ86cke7LvMBqWloaduzYgc6dO6NmzZqwsrJChQoV4OnpiYULFyIxMTG3Hi5lwWBriKSnpxuqayIiIiL6QHXo0AHW1tZISEjA6dOnIYSATCYDkDE6edKkSVi0aJFKMiIsLAxhYWH477//MHv2bJw5cwYNGzbMVgy3b9+Gl5cXnjx5onR/YmIioqOjcfPmTezcuRODBg3C5s2bpfiIChMPDw8cPXoUQMa0ma5duyqVJyQk4Ny5cwCAtm3bAoC0RXZgYCBevHiBUqVKKZ2jOP3GUOuHHDx4EF988QXevHmjdP+tW7dw69YtbNy4EV9++SVWrFgBMzP9L6dfvHiBdu3aISgoSOn+J0+e4MmTJzh9+jQWL16Mc+fOca3NfMBdZoiIiIjog2FhYYGKFSvizp07ePXqFR4/fixtr7lz50789ttvUl0vLy+4ubmhaNGiePbsGfbv34+QkBDExcWhW7duCA0NRZEiRQAAgwYNQqNGjXDhwgVs27YNADBjxgyUKFECTk5OUptpaWno27evlAwpU6YMevfujfLlyyMhIQFBQUHYv38/UlNTsXXrVjRv3hyjRo3Kp2eHKPcoJiwCAgJUyv/77z8kJycDANq1awcAaN++PVatWgUgY/TIgAEDlM7Rd/2Q06dPw9PTEy4uLrmyJsiJEyfQo0cPaf0hT09PNGrUCLa2tggMDMThw4eRlJSENWvW4N27d9i5c6d07rJlywAAS5YswcOHD1G1alWMHz8ewP/WT0lNTUWfPn2kZEiFChXQs2dPODk54eXLl9izZw8ePnyIiIgIfPHFFzh58iRMTDipI08JA4mMjBSLFy8WH3/8saFCMGpOTk4CgHBycjJ0KERERJQLnj9/Lpo3by4AiObNm4vnz58bOqQcOXXqlAAgAIjBgwfrdW6HDh2kc0+fPi3d/+mnnwoAwsTERBw6dEjlvLS0NNG/f3/p3GvXrqnU2bBhg1QeGhqqUh4UFCSVt27dWiQmJqrUuXr1qrCyshIARLdu3fR6bJS30tOFSE3O+pYUr/8t8Z0QV1Zl3BLfZa8NXWJLT8+f5yo5OVnY2NgIAMLa2lokJycrlX/77bcCgJDJZCI6OloIIcTr16+FiYmJACC8vb1V2ixfvrx0zuvXr7OMQf53wsXFRee4XVxc1P5diY+PF87OzgKAcHBwEMePH1c59/79+6Jhw4bSe/zAgQMqdVq3bi29/zO7dOmSdG7nzp1VnrOUlBTh6ekp1Xn48KHOj6uwKGjXofk6QuTFixfYvXs3du7cqXVlYco/UVFRqFWrltoyHx8f+Pj45HNERERElB3e3t64ePEiAODixYvw9vaWtsU0Ns7OztKx4rD3mzdvAsj4lrpTp04q55mYmGDChAnYvn07gIwh8g0aNNCrb3kfQMYikuq2Fm3YsCHatGmDQ4cO4datW3q1T3krPRUIVL/0TK66vSPv2q4/BDAtknftyxUpUgQtWrTAsWPHkJCQgJs3b8LNzU0ql68f4ubmBgcHBwBA8eLF0bhxY1y8eBH//POP0pS2p0+fSiOr6tWrh+LFi+f9g1Dwxx9/ICIiAgCwadMmaVSLourVq+Pvv/9GvXr18O7dO/zyyy/o0qWLzn1cunRJOv7222+lEWhyZmZmGDlyJM6ePQsACAoKQpUqVbLzcAzKz88Pfn5+asuioqLyORrt8jwh8vr1a/z999/YsWMHzpw5I60dIv5/3ibnTBpW6dKlcefOHUOHQURERDl06dIlaZh3WloaLl++bOCIDKdkyZLScVxcnHS8du1apKenKyVMMrOzs5OOs7Ntb4sWLXDq1CkAQKNGjbLsh1sDU2HWunVraTen8+fPSwmRV69eSbvFyNcPkWvfvj0uXryIp0+f4u7du9KXs3m53a4udu3aBQCoUaOG1iSHi4sLevfujXXr1uHixYt4//692sSnOqamptJxZGSk2jqfffYZPvvsMz0iL3i0fbHu7Oys8bEbQp4kRN69e4e9e/di586d8Pf3l/7QC4XFq4oUKYJ27dqhd+/eeRECERERkVFp0qQJjh8/jrS0NJiamqJx48aGDslgXr16JR0rJjhatWql9bzIyEgsWrQoR31XqFBB60KIKSkp+PfffzXuskGGZWKWMcIiK2kp+rednvq/kSG1+2X0pS9dRn5kp93sUtxh6fz58xgzZgwASElBACojLTp06IDZs2cDyNhtpiAkRIQQUv92dnZYvny51vrykWfJyckIDg5G3bp1depH8e/yV199hdu3b2PYsGGoXLlyNiOnnMq1t0tcXBz279+PnTt34tixY9J2SYpJEHNzc3Ts2BG9e/dG165dUaxYsdzqnoiIiMiobdy4Eb169UJAQACaNm2qss2jMZEPeweg9vOmEAI3b95EUFAQgoODERwcjMDAQNy9ezdX43j79i3Onz8v9XH//n2cP39eadQKFSwymW5Jh+xMSVFMohSxyp9pLXmtUaNG0q5OiguryqfLWFhYwN3dXemcZs2awdbWFnFxcfjnn3+khUcVEyItW7ZU6UtdkiI4OBgAEBMTo7bcyckJPXv2zPJxxMbGIiYmBgBw5coVXLlyJctz5OTn6cLNzQ3jx4/HkiVLEBsbi7lz52Lu3Llo1KgRWrZsiVatWqF9+/awsbHRuU3KmRwlRBITE3Ho0CHs3LkThw4dQlJSEgCobGMmk8mwdetWdOnSRSlLT0RERES5o3Tp0li2bBnc3NywbNkylC5d2tAhGYxiQkS+wwyQ8W3u8uXLsXDhQjx9+lTlPFNTUzRq1EhaiyW7goKCMGXKFBw7dkztlBhnZ2eYmJggPDw8R/0QGVqRIkXg7u6O48ePIywsDM+ePUPZsmWlhIi7uzusrKxUzvHw8MDBgwdx5swZJCUlwcTEREpC1KlTB46Ojip9jR07VmMcb968UVveunVrnRIi+iQ1cnruokWL4O7ujmnTpuHevXsA/peEWbRoEaysrNCjRw/MmzcPLi4u2Y6LdKN3QiQ5ORlHjhzBzp07ceDAASQkJABQToLY2Niga9eueP/+Pfbu3QsA6N+/f+5ETERERESkQXJysrT9ZsmSJaXpK/LtcPft2wfgfwtCurm5oU6dOnB1dYWrqyuio6NRqVKlbPf/77//okOHDnj//j2AjISMu7s76tevL/VRsWJFDB06FJs2bcrZgyUqADw8PKQpYOfPn0eDBg3w6NEjAKrrh8h16NABBw8eRHx8PM6fPw87OzskJiYCMMz6IdbW1tLxl19+idWrV+dZXzKZDH369EHv3r1x79497Nu3D6dOnUJAQADi4uKQmJiI7du3Y//+/fD390ezZs3yLBbSIyFy+PBh7Ny5E/v27UNsbCwA5SSInZ0dunXrht69e6Njx46wtLTE/PnzpYQIEREREVFe++effxAfHw8g48JKvoD/7t27pWRI586dsWbNGpQtW1blfMX1R/SVnp6OkSNH4v3797CwsMC2bdvQs2dPmJiYqNTNPKKaqLDKvI5IdHS09LO6nVqAjIVV5Y4fP45y5cpJP2tKiKh7z5w+fRqenp5wcXGREqHZYW9vD3NzcyQnJ+Phw4fZbkcfMplMSpJOmTIFqampOHbsGFasWIHDhw8jPj4eo0aNkhanpbyhc0KkS5cukMlkSi/EYsWKoXv37ujduzfat28Pc3PzPAmSiIiIiCgrQgj88ssv0s9DhvxvdcwDBw5Ix1u2bNG4pef9+/ez3f+jR4+kdUhGjRqFTz/9VGPdnPRDVJA0atQIVlZWSExMREBAgDQVzN7eHg0bNlR7To0aNVC+fHk8efIEx48fR40aNaSyrBY/zgvy6XIBAQG4desWkpKSYGFhobH+jh07cO/ePdjZ2WHixIk69/P333/jxYsXsLe3V5lBYWZmhs6dO6Nz587w8vLC0aNHERgYiPj4eK4pkodU09VZkMlkaNOmDY4cOYKoqChs2LABnTt3ZjKEiIiIiAxq+fLl+PfffwEAtWvXRseOHaUy+a4QlpaWKFq0qNrzhRDYvHlztvuX9wEApUqV0ljvzp07Rr0tMn1YzM3NpYVTr169Kq0f4unpCTMz9d+/y2QyaZTIlStXpHNq1qxpsPWP5Fvtvnz5EkuXLtVY7+XLlxg6dCh8fX1x69YtvfrYvn07Ro0ahUGDBuH169ca68mfA8Vteilv6J0QATK2UZo5cybWrFmDly9f5nZMREREREQ6S0pKwowZM6TdKmQyGVavXq10MeHq6goASmvcKYqJicHXX3+N7du3S/c9f/5ca7+Zp9cofsv9119/SRsOKAoICED79u2Rnp4OICOJoq4eUWEinzaTlJQkXehrWj9ETp4QEUJI7zVDrB8iN3z4cGkDEF9fX+zYsUOlzrt379CzZ09pvZPBgwdrbE/d9Dv536H09HT8+OOPaqcBXb9+XfobVb9+fY4OyWM6T5nx8vLC8ePHkZqaCiBjW6QLFy5g/PjxaN++PQYMGIAePXrA1tY2z4IlIiIiIuNz9+5dlS01hRCIiYnBw4cPcfDgQaWLj1WrVqF58+ZK9bt06YKFCxcCAPr164eePXuifv36SE9PR3BwMPbv34+3b9+iTJkyePnyJdLS0rBo0SLExsZi8ODBqF69OoCMESZyvr6+GDBgAOzt7dGpUycULVoUnp6eOHXqFK5evYratWujV69eKFWqFJ4+fYpLly7h3LlzADJ2momIiEBMTAw+/fRT9OnTR+vFFVFBpi6RoWn9ELm2bduqLMlgyIRIyZIlsXz5cgwePBjx8fHo378/VqxYgSZNmqBkyZJ49OgRdu7ciXfv3gEAJkyYoLR+ipz8b8Tt27cxd+5cVKlSBfXr10eNGjXQu3dvzJ49G0IIrFy5EufOnUOnTp3g6OiImJgYBAYG4tChQ9LuVN9++22+PX6jJfQQHR0tVq9eLTw9PYWJiYmQyWRCJpMJExMTYWJiIqytrUW/fv3EgQMHRHJysvj555+lcipYnJycBADh5ORk6FCIiIgol1y9elUAEFevXjV0KDl26tQpAUCvW5kyZcTu3bs1tvn9999rPd/NzU2EhoaKnj17Kt2/Z88eqY2HDx8KMzMzpfLWrVtL5Y8fPxalS5fW2IeFhYX49ddfxdWrV4WJiYl0f7169fLuyaQCITVZiCurMm6pyYaOJne9f/9eWFlZSa/ncuXKifT09CzPa9iwodL7IzIyUq9+5X8nXFxcdD7HxcVFABCDBw9WW/77778LCwsLje9hmUwmRo4cKVJTU9WeP3PmTJVzNmzYIJX7+fkJc3NzrX+LzM3NxYIFC/R4JgqPgnYdqteUGQcHB3z55Zc4efIkIiIisGjRIjRt2hRCCAghkJiYiD///BPdu3dHmTJlsGXLFn2aJyIiIiLSmZmZGZydndG2bVv4+fnh7t27WhcynTt3Lk6fPo0uXbqgSpUqMDc3R5kyZdC1a1ds374dly5dQsWKFbFq1Sp069YNNjY2cHV1VVoPpEqVKti5cyfq1q0LS0tLODo6onLlylJ5hQoVcP/+fUydOhWNGzdG8eLFYWNjg9q1a2Py5Mm4f/8+Jk2ahIYNG2Lz5s0oX748HBwc0KBBgzx9rojykoWFhdKoLPnoj6x06NBBOq5atarSbjO68PDwgBAiRzvMZDZy5Ejcu3cPEydORO3atWFnZwc7Ozu4ubnB29sbN27cwO+//65xfY/Jkydj3LhxKFeuHMzNzVGhQgU4ODhI5aNHj8ajR48wfvx4NGvWDE5OTlK9li1bYvLkyQgNDdVrsVbKPpkQOd/zKzQ0FDt37sT27dsRFBT0v8YV3gQdOnRA37590aNHD42relP+cXZ2RmRkJJycnBAREWHocIiIiCgXXLt2DW5ubrh69arG3R2IyDDSUoDADRnH9YcApkUMG4+xqlixIh4/fozBgwdj48aNhg7H6BS069BsLaqaWaVKlTBlyhTcuHEDt2/fxo8//oiqVatKI0eAjD3hhw8fjjJlyqBTp07YuHEj3r59mxvdExERERERERHpJVcSIopcXV0xc+ZMPHjwAJcvX8aECRPg5OQkJUdSUlJw7NgxDBs2DKVLl5a2NyIiIiIiIiLKS8nJyYYOgQqQXE+IKHJzc8OCBQvw+PFjnD17FqNGjYKjo6NScuTIkSN5GQIRERERERERXr9+jRcvXgAAzM3NDRwNFQR5mhCRk8lkaNGiBfz8/PDs2TMcPXoU3t7eKFq0aH50T0RERGQUypYti+nTp6Ns2bKGDoWIMjEtAriNyLhx/ZD8dfv2bezatQt9+vSRtrStXbu2gaOigiBXFlXNrqSkJBw9ehTdu3c3VAhGq6AtZkNERERERJQXvL29sWnTJulnZ2dnXL9+HY6OjgaMyjgVtOvQfBkhoomFhQWTIURERERERJRnrKysYGlpiWrVqmHkyJH477//mAwhAAYeIUKGI8/MmZmZoVq1amrr+Pj4wMfHJ58jIyIiIiIiosLKz88Pfn5+asuCg4ORmppaYEaIMCFipAraUCUiIiIiIiL6sBW061CDTpkhIiIiIiIiIjIEJkSIiIiIiIiIyOgwIUJERERERERERocJESIiIiIiIiIyOkyIEBEREREREZHRYUKEiIiIiIiIiIwOEyJEREREREREZHSYECEiIiIiIiIio2Nm6ACIiIiIiIiIKPv27NmDyMhIjeU1a9ZEu3bt8jGiwoEJESIiIqIPQXwCYNso4zjuCmBjbdh4iMho8eI8/y1ZsgRnzpzRWD548GA+52owIUJERERERES5hhfnVFgwIUJERERERERUiJ0+fdrQIRRKTIgQERERERFRruHFORUW3GWGiIiIiD4YGzduhEwmg0wmQ1hYmKHDIfqftDTgzJWMW1qaoaMhInCECBEREREVMIGBgdi7dy8A4Ouvv0axYsWUyhcvXoy3b9+ifv366NGjR77HR0REHwaOECEiIiKiAiUwMBC+vr7w9fXF27dvVcoXL14MX19fKWlCRIXPjBkzpNFcGzdu1Pm806dPS+d5e3vnWXx5JTdGsXEkXO7hCBEiIiIiIiLSS1YjubIqJyoImBAxclFRUahVq5baMh8fH/j4+ORzREREREREVNDJR3IBgLe3t9qEiLZy+nD5+fnBz89PbVlUVFQ+R6MdEyJGrnTp0rhz546hwyAiIiIiIqIPgLYv1p2dnREZGZnPEWnGNUSIiIiIqEDw9vaGTCbDkCFDpPsqVaoEmUyGihUrSnPmHz9+DADYtGmTdJ+mbT5TUlKwZMkSNGnSBMWLF4e1tTVq1KiBMWPG4MGDB1nGdO/ePYwcORKNGzdGmTJlYGlpiUqVKqFly5aYP38+Xr9+rfFceczLly8HAJw/fx7t2rWDnZ0d6tevr/sTQ0REeYIjRIiIiIjog/Tu3Tv0798fFy5cULr/wYMHePDgAVavXo2lS5fiq6++UjlXCIFJkyZh0aJFEEIolYWFhSEsLAz//fcfZs+ejTNnzqBhw4ZaY9m7dy8+++wzJCcn5/yBERFRrmBChIiIiIgKhEGDBqFRo0a4cOECtm3bBiBjJ4oSJUrAzs4OsbGxAIBp06bhzZs3aNKkCT7//HMAQLVq1VTaGzZsGK5evQobGxu0bdsWjRs3xsOHD3Hq1CmEh4cjJSUFo0aNgoODA/r27at07s6dO/Hbb79JP3t5ecHNzQ1FixbFs2fPsH//foSEhCAuLg7dunVDaGgoihQpovZx3blzB9999x2Sk5PRrFkzuLq64uOPP86V54wov3l7e2PTpk1K91WqVAkA0Lp1a1SsWFFruabRXMYqJSUFK1aswLZt2xAcHIykpCSUL18e7du3x7hx41C9evV8acNYMSFCRERERAVCu3bt0K5dO9ja2koJkcGDB6NixYpK9RYsWIA3b97A1dUVY8aM0dje1atXUaFCBRw+fBi1a9eW7n///j2GDx8u9eHj44MuXbrA2tpaqrN7924AgImJCQ4cOIBOnTqpxDBo0CBs374dkZGRuHXrFho0aKA2jpUrV8LBwQH//PMP3N3ddX9CiKhAiomJwfPnz3OcaMjJKLbcbMOYMSFCRERElF+EABIStdeJz6Jcl/NevAZsstGOjVXWdaytAJlM/7YN5MCBA0rJEACwtLTEli1bEBERgTNnzuDVq1fYsWMHhg4dKtW5efMmAKB9+/YqyRAgI1EyYcIEbN++HQC0JkQAwNfXl8kQ+iBoG8nl5OQEOzs7reWF3f3799G5c2fIZDJcu3YNdnZ22W4rJ6PYcrMNY8aECBEREVF+SUgEbBvlfT+VO+Rd23FXABvrrOsVAF26dMFHH32ktkwmk2H69Olo06YNAODo0aNKCZG1a9ciPT0dzs7OGttXvBBKS0vTWK9YsWJKbRMVZrqM5NJlpFdhVaZMGaSnpyM0NBQ+Pj7YvHlzttvKySi23GzDmHGXGSIiIiL6IPXo0UNruYeHB4oXLw4g46JCUatWreDh4YGqVauqPTcyMhKLFi3SKY5q1arxIoRIiyFDhkg7RmV18/T0NGis9vb22L59O8zMzLBlyxZs2bIlR+1pG8XWunVrAJBGseVlG8bqgxohcvjwYfz++++4du0aXr58iTJlyqB58+bw8fFBixYtctx+aGgoli1bhkOHDuHJkyfStm0DBw7E8OHDYW5urvX8+Ph4rFmzBvv27cOtW7fw7t07lC9fHjVq1IC7uzu+/vpr2NjY5HkcREREZCDWVhkjLLTJyZQZ+ciQR//oNv0lM12nzBQS8oUcNZHJZKhSpQquXLmCly9fqq0jhMDNmzcRFBSE4OBgBAcHIzAwEHfv3tU5jrJly+oVNxmQEEB6etb1tIwI0nyOQrvJKYBpNtowNc26jolJoZrWVhg1bdoUc+bMwXfffYdRo0ahadOm2VpPJCej2HKzDWP2QSRE0tLSMGrUKKxZs0bp/vDwcISHh2PHjh2YNm0afH19s93HoUOHMGDAAMTExEj3JSYmIiAgAAEBAdi0aRP279+P0qVLqz3/9u3b6Ny5Mx4/fqx0/6NHj/Do0SMcOXIEK1euxMqVK9G1a9c8i4OIiIgMSCbLerpJdqejxCf877iUQ6GZ1pKXdElEyOskJionopKTk7F8+XIsXLgQT58+VTnP1NQUjRo1wsWLF7Pso1ixYroFTIaXng78dz3v+7l0K+/abtFAt8RJATJw4EA0a9ZMp7rBwcFYunRpHkeUtUmTJuH48ePw9/dHv379cP78eVhYWOjVhq6j2N68eaMyii032zBmH0RCZMaMGVIypGjRohg0aBBcXFxw584d7NixA0lJSZg5cyacnZ3x5Zdf6t1+UFAQ+vTpI/2j9PLyQsuWLREbG4vt27cjLCwMly5dQt++feHv76+y5dq7d++UkiEuLi7o2LEjKleujKdPn+Kff/7BvXv3EBkZiU8//RTnzp1D48aNcz0OIiIiImPy4sULuLq6aq0TGRkJANLUGSDjy7a+ffti3759AIAiRYqgRYsWcHNzQ506deDq6gpXV1dER0dnOQoFyPiWlog0a9euHby9vXWqe/r06QKREDExMcHmzZtRr149XL9+HVOmTNF5Gp1cboxiy402jFmhT4iEhIRg7ty5AIAKFSrgzJkzSgv2jB07Fp6enoiNjcWkSZPQt29f2Nvb69XHuHHjpCTE+vXrMWTIEKnsxx9/RPfu3eHv74+zZ8/ijz/+wODBg5XOX7FihZQM6d27NzZs2ABbW1upPCUlBRMmTMDy5cuRkpKCH3/8EceOHcv1OIiIiIiMSWhoqDR/Xh0hBB4+fAgg43Ok3O7du6VkSOfOnbFmzRq1o01evXqVyxGTwZmYZIywyEp2p8zIR4Y0qQOYZmM5R12nzJBGNWvWxP3793O93cWLF6Ndu3bo3LmzzufkZBRbbrZhzAr9u2XRokVI//95fsuXL1dZvdjNzQ2zZs0CkLFf9Nq1a/Vq/8qVKzh9+jQAoFevXkpJCACwtrbG5s2bYWWVMZ92wYIFKm3I/6FaW1vDz89PKRkCZHzrsGDBAim7d+7cOekx5WYcRERERMbkwIEDWsuPHz8uTUNWHK6veN6WLVs0XnDkxUUVGZhMlpF0yOpmbp6Nm8LobfMi2WtDl9g4Islg3r59q1f9Fy9eZFlH3Si23G7DmBXqhIgQAnv37gWQMTfTy8tLbb3+/ftLx/v379erjz179kjHAwcOVFunbNmy0kI1t27dwqNHj5TK5d88eHp6olSpUmrbsLCwQKtWrQBkLL4aGhqa63EQERERGZO///4bt2/fVluWnp6OGTNmSD/37dtXOn7z5g2AjF0aihYtqvZ8IUSOttskIsP4999/8ezZs1y53b17FyVLlgSQsbWwpus0TTJf82WmaRRbbrdhzAp1QuTBgwdStqtDhw4wM1M/A6hUqVLSmhwBAQGIj4/XuY+TJ08CAMzMzNCuXTuN9Tp16iQd+/v7S8dv375FdHQ0gIy1Q7QpUaKEdCz/R5xbcRAREREVRtqmpegyZaVLly4qO8IkJCSgf//+OH/+PACgcePGaNmypVQuX3fk/fv30pdvimJiYvD1119j+/bt0n3Pnz/PMhYiMrySJUuiTJkyOb6VLl0a06ZNw8uXL1GtWjUsX75c71iyO4ott9swZoV6DZHw8HDpOKv9qD09PXH58mWkpqbi4cOHqFevnl59uLm5afyGIHP/iv90LS0tcfnyZQBZz++6c+cOgIyFbypXrpyrcRAREREVFpaWltKxr68vBgwYAHt7e+mLH3n5mTNnsGjRIpQpUwatWrWCk5OTdJ6DgwNKly6Nu3fvokmTJmjXrh3c3NwQEhKCEydO4MmTJwAyph2vXbtWaeHTLl26YOHChQCAfv36oWfPnqhfvz7S09MRHByM/fv34+3btyhTpgxevnyJtLQ0LFq0CLGxsRg8eHC2tt8kosJl7dq12LVrF8zNzbFz506VZRF0IR/FVrt2bZUybaPYcrsNY1aoR4hERUVJx1ltM6s4VUU+ZCgr6enp0pys7LZvaWmJRo0aoVGjRkr/pBUJIbBlyxYcPXoUANC9e3c4ODjkahxEREREhUXjxo2lkb8HDx7EgAED8Msvv0jl7u7uAIC4uDhMmDABAwYMQHBwsFIbVlZW2LdvH6pUqYK4uDjs3bsXP/30EzZu3CglQxwdHXH48GF89NFHSud6eHjg+++/BwCkpqZi165dmDp1Kn766Sds3rwZb9++hZubG86fP49u3boByJjHP3fuXOkLLiJjktVorQ9tAeI7d+5g/PjxAIBffvkFDRrosBCvBtkZxZYXbRirQj1CRDEhktUCMYoJBl0WngEypq2kpqbq1L7i/vK6tL969WqEh4fj1atX8Pf3R0hICACgWrVqWLlyZb7FQURERFTQVKlSBTt37sSMGTMQHBwMW1tbpdGzv/76K1JSUnD06FHExsaiXLlysLOzU2mnWrVquHbtGhYvXoxdu3YhNDRUGonbo0cPjBs3TmnKsqK5c+eiY8eOWLBgAe7evYsnT57AwcEBjRs3xoABA9C3b1+YmJhg1apVSEtLw4kTJ1ChQgWN68URfWh0Hcmlqbywev/+Pfr164fExER06dIF48aNy1Y7ORnFlpttGLsPJiGimAhQRzGRkJCQkOvtm5qawt7eHu/evdOp/blz50pb8cr16NEDW7ZsURlulZdxCCGkOWXZYWFhAQsLi2yfT0RERKROr1690KtXL7VlDg4OGhc09fb2hre3t/Rz0aJFMW3aNEybNk3vGFq3bq11214gYz0C+Y6CmYWFhendJ1FhIR/JlZqaioMHD+LgwYNo3bq1lPDIqrywCg4ORlRUFMqVK4cNGzZkO8kgH8Xm5eWFkJAQ7N27V2XNIkdHR+zevVtlFFtutqGvpKQkJCUlZft8IUSuxJFbCvWUmdevX0vHNjY2WusqluuaENGnfcU6uraf2d69e9GvXz+8fPky3+J4+vQp7O3ts32bN2+eno+SiIiIiIgKO/lIrrp168LS0hKOjo5KI7myKi+s6tatixs3bmDfvn1wdHTMUVvyUWy+vr6oU6cObGxsYGtri48++gjTpk3DvXv3skzK5kYb+pg3b16Orh+fPn2aa7HkBpkoaCkaPYwePVqaXnLt2jWtc7d2796NPn36AADmz5+PyZMnZ9n+pUuX0LRpUwDAuHHjsGTJEq31bW1tER8fD1dXV53mj6alpeHJkye4efMmZs+eLS2+WqdOHVy4cEFKbORFHM7OzoiMjES5cuVytPgqR4gQEREVEPEJgG2jjOO4K4CNtWHjISJlaWnAf9czjls0AExNDRsPUTbkdISIq6srnj59CicnJ0RERORiZNlTqKfMWFv/7x995m1qM1Ms12WUhb7tp6SkSNv56tq+qakpKlasiIoVK6JLly7o1KkTjh07hlu3bmHTpk0YPXp0nschk8m07lpDREREREREBOT8C/GCto5JoZ4yozhEKatEwdu3b6VjxQVWDdm+IhMTE/z222/Sz4r7SednHERERFRI2VgD4k7GjaNDiIiIslSoR4hUq1ZNOn727JnWus+fP5eOdd0bvnTp0rC1tUVcXFy22w8JCZG2gXN3d1e7ArpczZo1YWVlhcTERGlF4NyKg4iIiIiIiIj+p1CPEKlVq5Z0fOrUKa11T548CSBjJIauiQKZTCb1cf36da2jM+TtZ47rxIkT8PLygpeXF65evZplfyYmJtJxbsZBRERERERERP9TqBMiNWvWhJOTEwDA398fKSkpautFRUUhMDAQAPDxxx9rHaWRWbt27QAA6enp8Pf311jv2LFj0nH79u2l4ypVqkjHjx490tpXeHi4tP5H+fLlczUOIiIiIiIyIFNToHWjjBsXVCUqEAp1QkQmk6F79+4AgJiYGBw6dEhtvR07dkjHPXr00KsPxfrbtm1TW+fZs2fSCJXatWujatWqUpliQmT9+vVa91328/OTjuUJkNyKg4iIiIiIiIj+p1AnRABgwoQJ0jST8ePHIzw8XKn82rVrmDZtGgCgWLFiGDFihF7tN27cGB4eHgCAffv2YePGjUrliYmJ8Pb2xvv37wEAU6ZMUSp3cXFB7dq1AQDnzp3D7NmzkZaWplRHCIFNmzZJi6ra29vD29s7V+MgIiIiIiIiov+RCW1DFgqJn376CbNnzwaQkfT44osv4OzsjNu3b2PHjh3SPskbNmxQSTRs3LgRQ4YMAQC0bt0ap0+fVmn/5s2baNasGRITEwEAXbt2hbu7O96+fYudO3ciNDQUANCmTRscO3YMZmbKa9UePHgQXbt2lX6uW7cuWrZsCRcXF0REROD8+fO4cuWKVL59+3b069cv1+NQ5OzsjMjIyAKz/zMRERERERF92AradegHkRBJS0vDiBEjsH79erXlMpkMs2fPxg8//KBSpktCBMjYBnfgwIGIjY1VW968eXPs27dPaYtcRX5+fhg/frzK6BBFtra2WL16Nfr376+xTk7jkCtoL0QiIiIiIiL6sBW069BCP2UGAExNTbFu3TocPHgQXbp0QdmyZWFubo7y5cujf//+OHfunNpkiD66du2KGzduYPz48ahatSosLS3h4OCA5s2bY+XKlTh9+rTWJISPjw9u376NCRMmoH379qhYsSKKFCkCR0dHtGjRAnPmzEFYWJjWZEhuxEFEREREREREH8gIEdJfQcvMERERERER0YetoF2HfhAjRIiIiIiIiIiI9MGECBEREREREREZHSZEiIiIiIiIiMjoMCFCREREREREREaHCREiIiIiIiIiMjpMiBARERF9CJKSgJEjM25JSYaOhoiIqMBjQoSIiIiIiIiIjI6ZoQMgw4qKikKtWrXUlvn4+MDHxyefIyIiIiIiIqLCys/PD35+fmrLoqKi8jka7ZgQMXKlS5fGnTt3DB0GERERkUbp6em4ffs2rl69ipcvXyItLQ3FixdHrVq14ObmBmtra0OHSERE/0/bF+vOzs6IjIzM54g0Y0KEiIiIiAqktLQ0+Pn5YeHChQgPD1dbx8rKCgMHDoSvry/KlSuXzxHmHm9vb2zatAkuLi4ICwszdDhEREaBa4gQERERUYETFxeHdu3aYfz48UrJEDMzM5iZ/e87vcTERKxduxa1a9fG2bNn1bbl4eEBmUwGmUyGjRs35nXohdbixYsxY8YM7N2719ChEBHlCyZEiIiIiKjA+eKLL3D69GkAQNGiRTFnzhzcu3cPCQkJeP/+PcLCwrBr1y7Uq1cPAPD27Vt069YNT548MWDUhdvixYvh6+vLhAgRGQ0mRIiIiIioQDl16hT27NkDAHBwcEBgYCB++OEH1KhRA0WKFIGpqSlcXFzQu3dvXLt2DcOGDQMAvHv3DjNmzDBg5EREVJgwIUJEREREBcr27dul499++w2VKlXSWNfExARLly5FxYoVAQB//fUXUlJSlOqcPn0aQggIIeDt7Z0XIRMRUSHEhAgRERERFSjXr1+Xjtu2bZtlfWtra3h6egLIGCUSGhqaZ7EREdGHgwkRIiIiIipQYmJipGMLCwudzunTpw+GDRuGYcOGwdTUVKls48aN0qKqmXdwkS+4+vXXXwPISKjMnj0bderUga2tLcqUKYPWrVtj9erVSE1N1RrD8+fP8d1336FWrVqwtraGo6MjOnTogP379wPIGKkij+PevXs6PS5F6enp2LFjB7p16wYnJydYWFigYsWKaN++PbZu3Yrk5GS92wwLC5Nievz4MQBg06ZN0n3ydVyIiD5E3HaXiIiIiAqUChUq4MGDBwCArVu34ptvvsnyHC8vL3h5eeWo38ePH8PLywt3796V7ouPj0dUVBTOnj2LLVu24OTJkyhSpIjKuUePHkX//v3x9u1b6b7ExEQcP34cx48fx5gxY9CrV69sx/bixQv07NkTAQEBKjE/fvwY/v7+mDlzJg4fPoyqVatmux8iImPChAgRERERFSjNmjWDv78/AGDy5Ml48+YNJk6cCHt7+zzrMzk5GT179sTdu3dRp04deHp6olSpUrh8+bI0wuO///7DnDlzVBZuvXLlCnr06IGkpCQAQIMGDdCqVSvY2toiICAAp06dwvLlyxESEpKt2BISEtCmTRvcvn0bAKRRIZUrV0ZISAj8/f0RFhaG4OBgfPzxx7hy5QpcXFx0atvBwQHLli0DAEybNg1v3rxBkyZN8PnnnwMAqlWrlq2YiYgKAyZEiIiIiKhA+eabb7B8+XK8ffsWqampmDVrFubPnw8vLy907twZHTp00PmCX1ebNm1CQkICpk6dCl9fX6VpN3v37kXPnj0BAAcOHFBKiKSnp2P48OFSMmT27Nn44YcfIJPJpDq7du3CoEGDcOTIkWzFNm3aNCkZ8t1332HGjBmwtLSUyt+/f4+ffvoJCxYswKtXrzBx4kTs3r1bp7aLFi2KMWPGAAAWLFiAN2/ewNXVVbqPiOhDxoQIERERUX4RAshqnYf/v7DWm2K7sbHZa0eX9TrMzQGFi/284ODggFOnTqFr166IiIgAkDGCY9++fdi3bx8AoEaNGujYsSM6duwIDw8PWFtb56jPhIQE9OzZE7Nnz1Yp69GjB9q1awd/f38EBQUplZ04cQI3btwAAAwaNAhTp05VOb9Pnz4ICQnB999/r3dcb9++xcqVKwEAn376KebNm6eUbAEAS0tL/PLLLwgJCcGePXvw119/ISQkBFWqVNG7PyIiY8KECBEREVF+SU4Gxo3L+37UXJTnmqVLdUuc5FD9+vVx69YtbNu2DevWrcO1a9eUyu/fv4/79+9j6dKlsLe3x5AhQzBhwgSUL18+231mngqjqEGDBvD391fZ0vevv/6SjidPnqzx/BEjRmDWrFlISEjQK6YjR45I50yaNEklGSInk8kwYcIE7NmzBwDw77//MiFCRJQFJkSIiIiIqECyt7fH6NGjMXr0aDx//hzHjx/HP//8g+PHjyMqKkqq9+7dOyxevBjbtm3Dvn378PHHH+vdl62tLerWrauxXNMIlAsXLgAAypYtq/V8BwcHNGnSRO9dW86fP6/U15UrVzTWVUy2ZB7JQkREqpgQISIiIsov5uYZIyy0ycmUGfnIkDlzMvrSl65TZgygTJky+Pzzz/H5558jPT0dQUFB2LNnD7Zu3SotVvry5Ut07NgRISEhKFmypF7tV6lSRePoC22ePHkCADqtaVKhQgW925dPGQKg0247copbFxMRkXpMiBARERHlF5ks66RDdqejKCZS7OzyZVqLoZiYmKBevXqoV68epk2bhjVr1mDChAlISEhAbGws5syZg8WLF+vVZrFixbIVy7t37wAApUuXzrJu2bJl9W4/u4kNJkSIiLLGhAgRERERFRhXr17F5cuXAQC9e/eGo6Oj1vomJiYYOXIkLC0t4e3tDQB6T0vJCWtra8TGxuLFixdZ1n358mW22gcACwsLJCQkwMTERO82iIhIPf5FJSIiIqICIyAgAKNGjcKoUaNw7tw5nc/r378/zP9/Os+DBw/yKjwVZcqUAQCEh4dnWffx48d6ty8feZKUlKQ0fYaIiHKOCREiIiIiKjAUd4mRb2erCxMTE5iZZQx+trGxyfW4NGnSpAkAIDIyEnfu3NFYLy4uDlevXs12+wCyPP/evXuYMWMGZsyYIa2rQkREmjEhYuSioqJQq1YttTc/Pz9Dh0dERERGxsPDA6ampgAAPz8/naeZBAUFSbusfPTRR3kWX2bdu3eXjn/55ReN9dauXYu3b9/q3f4nn3wiTZOZPn06UlNTNdb96aef4OvriwULFkgjV4iI8pufn5/Ga0zFHcIKAiZEjFzp0qVx584dtTcfHx9Dh0dERERGplixYujfvz8A4MWLF/D29sabN2+0npOQkIDhw4dLPw8aNChPY1TUo0cPVKpUCQCwadMmzJ8/H0IIpToHDhzAjz/+mK32y5cvj759+wLISPp8+eWXiIuLU6ojhMDChQuxe/duAECfPn1yNErm1atX2T6XiMjHx0fjNaYuC1DnJy6qSkREREQFyty5c3Hs2DG8fPkShw8fRrVq1TB16lS0bt0aVapUgb29PRISEhAZGYkjR45g8eLFCA0NBQB8/PHH+OKLL/It1iJFimDt2rVo37490tPTMWXKFOzatQstW7aEnZ0dLl68CH9/f6Snp2P48OFYu3YtAMDS0lLnPhYvXozTp0/j+fPn2LhxI06cOIF27dqhRo0aePPmDY4cOYKbN28CAKpWrYoFCxZk67HIYzpz5gwWLVqEMmXKoFWrVnBycspWe0REBR0TIkRERERUoJQvXx7Hjx9H165d8eTJE0RHR2PChAlSuY2NDeLj41XOa968OQ4cOCBNuckvbdq0wbZt2zBkyBC8f/8eV69eVVrvw9zcHCtWrICTk5OUEClVqpTO7ZcuXRpnzpxBly5dEBwcjCdPnmDDhg0q9T766CP8+eefKFGiRLYeh7u7O+7fv4+4uDjp+T516hQTIkT0weKUGSIiIiIqcOrVq4egoCB89913KlvvZk6G1K5dGytXrsTZs2fh4OCQn2FK+vXrh1u3buGrr76Ci4sLzM3NUaZMGfTr1w8XL17EsGHD8PTpUwCAra2ttJ2urqpXr46goCCsXLkSbdq0QcmSJWFubo6qVauic+fO2LRpE65du4YaNWpk+zH8+uuv+Pzzz1GyZElYWlqicuXKsLOzy3Z7REQFnUxknuRIRsHZ2RmRkZFwcnLiFm5EREQfgqQkYNy4jOOlSwELC8PGk4tSUlJw69YtBAYGIjo6Gu/fv4e9vT3Kli2LRo0awcXFBTKZzNBhZmnmzJmYPn06qlSpgocPHxo6HCKifFfQrkM5ZYaIiIiICrQiRYqgQYMGaNCggaFDUXHnzh1cunQJANCtWzetI1SuXbsGAAVuUUEiImPFKTNERERERNn07NkzDBkyBEOGDMHff/+tsV5wcDD2798PAGjRokV+hUdERFowIUJERERElE3NmzeXdmeZP38+oqOjVeq8efMGo0ePlrbj7dOnT77GSERE6nHKDBEREdGHwMICWLXK0FEYHSsrK/z6668YO3YsHj58iIYNG2LcuHGoV68ekpOTERQUhFWrVknbAvfp0weNGjUycNRERAQwIUJERERElCM+Pj4ICQnBkiVLEB4ejkmTJqmt17JlS2nbXSIiMjxOmSEiIiIiygGZTIZFixbh5s2bGDx4MNzc3GBvbw8LCwuUK1cOXbt2xZYtW3Dq1CkULVrU0OESEdH/4wgRIiIiIqJcUKdOHWzcuNHQYRARkY44QoSIiIiIiIiIjA4TIkRERERERERkdJgQISIiIiIiIiKjw4QIERERERERERkdJkSIiIiIiIiIyOgwIUJERERERERERofb7hq5qKgo1KpVS22Zj48PfHx88jkiIiIiIiIiKqz8/Pzg5+entiwqKiqfo9FOJoQQhg6C8p+zszMiIyPh5OSEiIgIQ4dDREREREREH7iCdh3KKTNEREREREREZHSYECEiIiIiIiIio8OECBEREREREREZHSZEiIiIiIiIiMjoMCFCREREREREREaHCREiIiIiIiIiMjpMiBARERERERGR0WFChIiIiIiIiIiMDhMiRERERERERGR0mBAhIiIiIiIiIqPDhAgRERERERERGR0mRIiIiIiIiIjI6DAhQkRERERERERGhwkRIiIiIiIiIjI6TIgQERERERERkdFhQoSIiIiIiIiIjA4TIkRERERERERkdJgQISIiIiIiIiKjY2boAMiwoqKiUKtWLbVlPj4+8PHxyeeIiIiIiIiIqLDy8/ODn5+f2rKoqKh8jkY7mRBCGDoIyn/Ozs6IjIyEk5MTIiIiDB0OERERERERfeAK2nUop8wQERERERERkdFhQoSIiIiIiIiIjA4TIkRERERERERkdJgQISIiIiIiIiKjw4QIERERERERERkdJkSIiIiIiIiIyOgwIUJERERERERERueDSogcPnwY3bp1g7OzMywsLODi4oL+/fvjv//+y5X2Q0NDMWHCBNSoUQPW1tZwdHSEu7s7VqxYgeTkZJ3befHiBQ4ePIj169djw4YN8Pf3R0JCQq7ESERERERERERZkwkhhKGDyKm0tDSMGjUKa9as0Vhn2rRp8PX1zXYfhw4dwoABAxATE6O2vEmTJti/fz9Kly6tsY07d+7g22+/xeHDh1XKLCwsMGzYMPj6+sLR0VHt+evWrcPw4cN1itfFxQVhYWEay52dnREZGQknJydERETo1CYRERERERFRdhW061AzQweQG2bMmCElQ4oWLYpBgwbBxcUFd+7cwY4dO5CUlISZM2fC2dkZX375pd7tBwUFoU+fPkhMTAQAeHl5oWXLloiNjcX27dsRFhaGS5cuoW/fvvD390eRIkVU2ggICEDHjh0RFxento+kpCSsWLECBw8ehL+/P6pVq6ZS5+HDh3rHTkRERERERESqCv0IkZCQEFSvXh3p6emoUKECzpw5g4oVK0rlV69ehaenJ2JjY1G0aFGEh4fD3t5erz48PT1x+vRpAMD69esxZMgQqSwhIQHdu3eHv78/AGDjxo0YPHiw0vkJCQmoWbMmnjx5AgDo2LEjfvjhB9SpUwdxcXG4cOECpk6dKiU8atasicDAQFhYWCi106dPH+zevRvlypXD999/rzVmOzs7lTgUFbTMHBEREREREX3YCtp1aKEfIbJo0SKkp6cDAJYvX66UDAEANzc3zJo1C19//TViYmKwdu1aTJw4Uef2r1y5IiVDevXqpZQMAQBra2ts3rwZVapUQWJiIhYsWKCSiNi2bZuUDPnss8/wxx9/wMQkY/kWBwcHVKhQAV27doWnpycuXryIe/fuYd26dRg9erRSO8HBwQCABg0aYMyYMTo/BiIiIiIiIiJSVqgXVRVCYO/evQCAYsWKwcvLS229/v37S8f79+/Xq489e/ZIxwMHDlRbp2zZsmjTpg0A4NatW3j06JFS+YEDBwAAMpkMM2fOlJIhiqysrLB+/Xrp5507dyqVCyGkESTVq1fX6zEQERERERERkbJCnRB58OABIiMjAQAdOnSAmZn6AS+lSpVC48aNAWSs5REfH69zHydPngQAmJmZoV27dhrrderUSTqWT5+Ru3r1KoCMRIa2ZEatWrVQrlw5ABmJFUVRUVFS3OrWFyEiIiIiIiIi3RXqhEh4eLh07OnpqbWuvDw1NVWvxUnlfbi5uaFo0aJZtg8Ad+/elY6FEHj58iUAoHz58ln2J9+l5v3790r3K8bMhAgRERERERFRzhTqNUSioqKkY23b3QIZo0TkHj58iHr16mXZfnp6Ol68eJGt9hXbmDt3LoCMxVK1SUhIwIMHDwAAVapUUSqTrx8CAE5OTpg3bx4OHDiA+/fvIykpCeXLl0fbtm0xduxY1KhRI8vHRkRERERERGTMPpiESPHixbXWdXBwkI7lSY6svHnzBqmpqTq1X6xYMbXtm5qaYtKkSTr1t3LlSmlaTPPmzZXKFJMsHh4eKo/h3r17uHfvHlauXIlZs2bh+++/h0wm06lfIiIiIiIiImPzwSREFBMS6igmNBISEnK9fVNTU9jb2+Pdu3c6t6/oyJEjmDJlCgDAxMREZSccxYTIixcvULNmTXTr1g2Ojo4IDg7Gf//9h7t37yI9PR1Tp06FmZkZJk+enGW/QgjExMToHa+chYWFyvbARERERERE9OFJSkpCUlJSts8XQuRiNDlXqBMir1+/lo5tbGy01lUs1zVhoU/78jr6JkQSExMxa9Ys/Pzzz9KL46efflJZJ0QxITJ16lT4+vrC1NRUui81NRULFizA999/L9Xp27evyjbEmT19+hT29vY6x5vZ9OnTMWPGjGyfT0RERERERIXDvHnz4Ovra+gwck2hToiYm5tLx3FxcVrrvnv3TjrWdUSDPu0r9qFL+0II/Pnnn5g8ebLS4rDDhw/H9OnTVep7e3ujT58+cHJywueff65SbmZmhilTpuDBgwfYsGEDUlNT4efnh19//VVrHOXKlVNaBFZfHB1CRERERERkHL7//ntMmDAh2+e7urri6dOnuRhRzhTqhIi1tbV0/ObNG611Fct1Ge2hb/spKSnS+h9Ztf/w4UMMGzYMZ8+ele6ztbXFkiVLMGTIELVrf4wdO1anmGfOnIkNGzYAAI4fP55lfZlMpnX3HCIiIiIiIiIg50smFLR1Lgv1truOjo7ScVYJi7dv30rHigus5mf7QgisXLkS9erVU0qG9O3bF0FBQRg6dGiOXyDOzs4oUaIEACAsLCxHbRERERERERF9qAr1CBHFdTaePXumte7z58+l4+rVq+vUfunSpWFra4u4uLgct5+WloaBAwdi586d0n1NmjTBokWLVHaUyalKlSohOjoaiYmJudouERERERER0YeiUI8QqVWrlnR86tQprXVPnjwJIGMHF10TIjKZTOrj+vXrWkeJyNvPHBeQMTJk4sSJUjLEwsICCxYsQEBAgE7JkOjoaISFhSEsLEzaBlgb+ZyskiVLZlmXiIiIiIiIyBgV6oRIzZo14eTkBADw9/dHSkqK2npRUVEIDAwEAHz88cews7PTuY927doBANLT0+Hv76+x3rFjx6Tj9u3bK5X9/fffWLJkCYCM7X/PnDmDiRMnKu0So81ff/2FSpUqoVKlSti/f7/Wuq9fv5YSIg0bNtSpfSIiIiIiIiJjU6gTIjKZDN27dwcAxMTE4NChQ2rr7dixQzru0aOHXn0o1t+2bZvaOs+ePZNGqNSuXRtVq1ZVKl+5cqV0vHfvXjRt2lSvGHr16iUlTxYvXoy0tDSNdefMmSMdd+3aVa9+iIiIiIiIiIxFoU6IAMCECRNgYpLxMMaPH6+0hS0AXLt2DdOmTQMAFCtWDCNGjNCr/caNG8PDwwMAsG/fPmzcuFGpPDExEd7e3nj//j0AYMqUKUrl4eHhOHHiBACgS5cuaNWqlV79AxmLu3bu3BkA8O+//2LixIlITk5WqpOeno6VK1dKI1HKly+vdnteIiIiIiIiIgJkQghh6CBy6qeffsLs2bMBZCQ9vvjiCzg7O+P27dvYsWMHkpKSAAAbNmyAt7e30rkbN27EkCFDAACtW7fG6dOnVdq/efMmmjVrJi1S2rVrV7i7u+Pt27fYuXMnQkNDAQBt2rTBsWPHYGb2v7Vqjxw5gk6dOknndejQQafH5OTkhJ49e0o/P336FI0aNZIWd61SpQo6d+4MJycnhIWFISAgADdu3AAAFClSBCdPnkSLFi00tu/s7IzIyEg4OTkhIiJCp5iIiIiIiIiIsqugXYd+EAmRtLQ0jBgxAuvXr1dbLpPJMHv2bPzwww8qZbokRADgwIEDGDhwIGJjY9WWN2/eHPv27VPaqhcANm3apJKE0YW6WC5evIi+ffuqjIJRVLp0aezYsUMa1aJJQXshEhERERER0YetoF2HFvopMwBgamqKdevW4eDBg+jSpQvKli0Lc3NzlC9fHv3798e5c+fUJkP00bVrV9y4cQPjx49H1apVYWlpCQcHBzRv3hwrV67E6dOnVZIhAPDixYsc9auoadOmePDgAZYuXYq2bduicuXKMDc3R4kSJdCiRQssWLAADx8+zDIZQkRERERERGTsPogRIqS/gpaZIyIiIiIiog9bQbsO/SBGiBARERERERER6YMJESIiIiIiIiIyOkyIEBEREREREZHRYUKEiIiIiIiIiIwOEyJEREREREREZHSYECEiIiIiIiIio8OECBEREREREREZHTNDB0CGFRUVhVq1aqkt8/HxgY+PTz5HRERERERERIWVn58f/Pz81JZFRUXlczTayYQQwtBBUP5zdnZGZGQknJycEBERYehwiIiIiIiI6ANX0K5DOWWGiIiIiIiIiIwOEyJEREREREREZHSYECEiIiIiIiIio8OECBEREREREREZHSZEiIiIiIiIiMjoMCFCREREREREREaHCREiIiIiIiIiMjpMiBARERERERGR0WFChIiIiIiIiIiMDhMiRERERERERGR0mBAhIiIiIiIiIqPDhAgRERERERERGR0mRIiIiIiIiIjI6DAhQkRERERERERGhwkRIiIiIiIiIjI6TIgQERERERERkdFhQoSIiIiIiIiIjI6ZoQMgw4qKikKtWrXUlvn4+MDHxyefIyIiIiIiIqLCys/PD35+fmrLoqKi8jka7WRCCGHoICj/OTs7IzIyEk5OToiIiDB0OERERERERPSBK2jXoZwyQ0RERERERERGhwkRIiIiIiIiIjI6TIgQERERERERkdFhQoSIiIiIiIiIjA4TIkRERERERERkdJgQISIiIiIiIiKjw4QIERERERERERkdJkSIiIiIiIiIyOgwIUJERERERERERocJESIiIiIiIiIyOkyIEBEREREREZHRYUKEiIiIiIiIiIwOEyJEREREREREZHSYECEiIiIiIiIio8OECBEREREREREZHSZEiIiIiIiIiMjoMCFCREREREREREaHCREiIiIiIiIiMjpmhg6ADCsqKgq1atVSW+bj4wMfH598joiIiIiIiIgKKz8/P/j5+akti4qKyudotJMJIYShg6D85+zsjMjISDg5OSEiIsLQ4RAREREREdEHrqBdh3LKDBEREREREREZHSZEiIiIiIiIiMjoMCFCREREREREREaHCREiIiIiIiIiMjpMiBARERERERGR0WFChIiIiIiIiIiMDhMiRERERERERGR0mBAhIiIiIiIiIqPDhAgRERERERERGR0mRIiIiIiIiIjI6DAhQkRERERERERGhwkRIiIiIiIiIjI6TIgQERERERERkdFhQoSIiIiIiIiIjA4TIkRERERERERkdJgQISIiIiIiIiKjw4QIERERERERERkdJkSIiIiIiIiIyOiYGToAMqyoqCjUqlVLbZmPjw98fHzyOSIiIiIiIiIqrPz8/ODn56e2LCoqKp+j0U4mhBCGDoLyn7OzMyIjI+Hk5ISIiAhDh0NEREREREQfuIJ2HcopM0RERERERERkdJgQISIiIiIiIiKjw4QIERERERERERkdJkSIiIiIiIiIyOgwIUJERERERERERocJESIiIiIiIiIyOkyIEBEREREREZHR+aASIocPH0a3bt3g7OwMCwsLuLi4oH///vjvv/9ypf3Q0FBMmDABNWrUgLW1NRwdHeHu7o4VK1YgOTlZ53ZevHiBgwcPYv369diwYQP8/f2RkJCQ73EQERERERERGSuZEEIYOoicSktLw6hRo7BmzRqNdaZNmwZfX99s93Ho0CEMGDAAMTExasubNGmC/fv3o3Tp0hrbuHPnDr799lscPnxYpczCwgLDhg2Dr68vHB0d8zQOAHB2dkZkZCScnJwQERGhtS4RERERERFRThW069APIiHy008/Yfbs2QCAokWLYtCgQXBxccGdO3ewY8cOJCUlAQBWr16NL7/8Uu/2g4KC0LRpUyQmJgIAvLy80LJlS8TGxmL79u0ICwsDALRq1Qr+/v4oUqSIShsBAQHo2LEj4uLitPZVoUIF+Pv7o1q1ankSh1xBeyESERERERHRh62gXYcW+oRISEgIqlevjvT0dFSoUAFnzpxBxYoVpfKrV6/C09MTsbGxKFq0KMLDw2Fvb69XH56enjh9+jQAYP369RgyZIhUlpCQgO7du8Pf3x8AsHHjRgwePFjp/ISEBNSsWRNPnjwBAHTs2BE//PAD6tSpg7i4OFy4cAFTp07Fw4cPAQA1a9ZEYGAgLCwscjUORQXthUhEREREREQftoJ2HVro1xBZtGgR0tPTAQDLly9XSoYAgJubG2bNmgUAiImJwdq1a/Vq/8qVK1ISolevXkpJCACwtrbG5s2bYWVlBQBYsGCBShvbtm2TkiGfffYZDh8+jFatWsHBwQEVKlRA3759cfPmTTRt2hQAcO/ePaxbty7X4yAiIiIiIiKiDIU6ISKEwN69ewEAxYoVg5eXl9p6/fv3l47379+vVx979uyRjgcOHKi2TtmyZdGmTRsAwK1bt/Do0SOl8gMHDgAAZDIZZs6cCRMT1afdysoK69evl37euXNnrsdBRERERERERBkKdULkwYMHiIyMBAB06NABZmZmauuVKlUKjRs3BpCxlkd8fLzOfZw8eRIAYGZmhnbt2mms16lTp/9r787DoyrP/49/ZiYLCRACQQZIZJFFCApBCCqCAiXWqAjaglJcghW0RrRFrei3Clgs/VlaRU3RWiHWDdAKghg1KaK12IZ9l0VBJIFBWRIIIcvM+f0Rc0zIZDJJJslM5v26rrl8kvOc+9wTD5OZO89itsunrZTbsGGDJKl3797q3bt3tTHi4+PVuXNnSWUFDV/nAQAAAAAAygR0QeTgwYNme+TIkR77lh8vLS011+qozTUGDRqkqKioGuNL0q5du8y2YRj67rvvJEnnn39+jdcr3x3m7NmzPs0DAAAAAAD8yP2QigDhcDjMdk3bzHbo0MFs79u3TwMGDKgxvsvl0tGjR+sUv2KMP/zhD5LKFkv15MyZM9qzZ48kqUePHj7NAwAAAAAA/KjZFETatm3rsW+7du3MdnlxoSYnTpxQaWmpV/Gjo6PdxrfZbHrooYe8ut6CBQvM6TxDhw71aR4AAAAAAOBHzaYgUrEQ4E7FQsKZM2d8Ht9ms6lNmzbKy8vzOn5FGRkZmjFjhiTJarXqwQcfbJQ8DMNQfn5+rfMtFx4eXmV7YAAAAABA81NUVKSioqI6n28Yhg+zqb+ALogcP37cbLds2dJj34rHvS1Y1CZ+eZ/aFkQKCwv1+9//Xn/84x/Nm+Pxxx9Xr169GiWP3NxctWnTxut8zzVz5kzNmjWrzucDAAAAAALD3LlzNXv27KZOw2cCuiASFhZmtk+fPu2xb15entn2dkRDbeJXvIY38Q3D0NKlS/Xb3/620uKwd911l2bOnNloeXTu3Llei68yOgQAAAAAgsOjjz6q6dOn1/n8vn37Kjc314cZ1U9AF0QiIyPN9okTJzz2rXjcm1EWtY1fUlJirv9RU/x9+/bpl7/8pT777DPze61atdL8+fM1efJkWSyWRslDkiwWi8ddawAAAAAAkOq/ZMK5n3WbWkBvu9u+fXuzXVOh4OTJk2a74gKrjRnfMAwtWLBAAwYMqFQMmTBhgrZt26Y777zT7Q3S0M8TAAAAAIBgE9AjRCqus3H48GGPfY8cOWK2e/fu7VV8u92uVq1a6fTp0/WO73Q6NWnSJC1ZssT83pAhQ/TMM89U2lGmofMAAAAAAAABPkIkPj7ebH/yySce+65evVpS2Q4u3hYKLBaLeY1NmzZ5HJ1RHv/cvKSykSEPPvigWQwJDw/XvHnztHbt2hqLIb7MAwAAAAAAlAnogkifPn0UGxsrScrKylJJSYnbfg6HQ5s3b5YkXX755WrdurXX1xg9erQkyeVyKSsrq9p+H330kdlOSkqqdOzdd9/V/PnzJZVt//vpp5/qwQcflM1ma9Q8AAAAAABAmYAuiFgsFo0dO1aSlJ+fr1WrVrntt3jxYrM9bty4Wl2jYv833njDbZ/Dhw+bI1T69eunnj17Vjq+YMECs718+XJdeumltcrBV3kAAAAAAIAyAV0QkaTp06fLai17Gg888EClLWwlaePGjXriiSckSdHR0Zo6dWqt4icmJmrEiBGSpPfee0/p6emVjhcWFiolJUVnz56VJM2YMaPS8YMHD+pf//qXJOn666/XlVdeWavr+yoPAAAAAADwI4thGEZTJ1Ffjz/+uObMmSOprOhx++23Ky4uTjt27NDixYtVVFQkSVq0aJFSUlIqnZuenq7JkydLkq666iqtWbOmSvytW7fqsssuU2FhoSRpzJgxuuKKK3Ty5EktWbJE+/fvlySNGjVKH330kUJCflyrNiMjQ9dee6153tVXX+3Vc4qNjdWNN97oszzOFRcXp5ycHMXGxurQoUNe5QQAAAAAQF352+fQZlEQcTqdmjp1qhYuXOj2uMVi0Zw5c/TYY49VOeZNQUSSVq5cqUmTJunUqVNujw8dOlTvvfdepS1yJenVV1+tUoTxRnW51DWPc/nbjQgAAAAAaN787XNowE+ZkSSbzaZXXnlF77//vq6//np16tRJYWFhOv/88zVx4kT95z//cVsMqY0xY8Zoy5YteuCBB9SzZ0+1aNFC7dq109ChQ7VgwQKtWbPGbRHi6NGj9bqur/IAAAAAAAA/ahYjRFB7/laZAwAAAAA0b/72ObRZjBABAAAAAACoDQoiAAAAAAAg6FAQAQAAAAAAQYeCCAAAAAAACDoURAAAAAAAQNChIAIAAAAAAIJOSFMngKblcDgUHx/v9lhqaqpSU1MbOSMAAAAAQKBKS0tTWlqa22MOh6ORs/HMYhiG0dRJoPH52/7PAAAAAIDmzd8+hzJlBgAAAAAABB0KIgAAAAAAIOhQEAEAAAAAAEGHgggAAAAAAAg6FEQAAAAAAEDQoSACAAAAAACCDgURAAAAAAAQdCiIAAAAAACAoENBBAAAAAAABB0KIgAAAAAAIOhQEAEAAAAAAEGHgggAAAAAAAg6FEQAAAAAAEDQoSACAAAAAACCDgURAAAAAAAQdCiIAAAAAACAoENBBAAAAAAABB0KIgAAAAAAIOiENHUCaFoOh0Px8fFuj6Wmpio1NbWRMwIAAAAABKq0tDSlpaW5PeZwOBo5G88shmEYTZ0EGl9cXJxycnIUGxurQ4cONXU6AAAAAIBmzt8+hzJlBgAAAAAABB0KIgAAAAAAIOhQEAEAAAAAAEGHgggAAAAAAAg6FEQAAAAAAEDQoSCCoORwOJScnKyYmBglJyf73fZPAAAAAICGRUEEQSklJUWZmZk6fvy4MjMzlZKS0tQpAQAAAAAaEQURBKXs7Gw5nU5JktPp1Lp165o4IwAAAABAY6IggqA0ZMgQ2Ww2SZLNZlNiYmITZwQAAAAAaEwURBCU0tPTlZSUpJiYGCUlJSk9Pb2pUwIAAAAANKKQpk4AaAp2u10ZGRlNnQYAAAAAoIkwQgQAAAAAAAQdCiIAAAAAACDoUBABAAAAAABBh4IIAAAAAAAIOhREgHpwOBxKTk5WTEyMkpOT5XA4mjolAAAAAIAX2GUGzY9hSGcKG+VSKbfdpszVq+V0OpWZmamU225TxrLlnk+KjJAslkbJDwAAAADgHgURND9nCqVWgxvlUtnaLadckiSn06l1matrvvbp9VLLyEbIDgAAAABQHQoiQc7hcCg+Pt7tsdTUVKWmpjZyRoFliCKUqQI5JdkkJapFU6cEAAAAAE0mLS1NaWlpbo/52xIDFsMwjKZOAo0vLi5OOTk5io2N1aFDh5o6Hd8qOPPjKA3Hv6WWEQ12KYfDoZR77ta6DRuVOOgSpb/4kux2u5ucCiX78LI2I0QAAAAABCF/+xzKCBE0by0jGrT4YL+guzI+/rjB4gMAAAAAGga7zAAAAAAAgKBDQQQAAAAAAAQdCiIAAAAAACDoUBABAAAAAABBh4IIAAAAAAAIOhREAAAAAABA0KEgAgAAAAAAgg4FEQAAAAAAEHQoiAAAAAAAgKBDQQQAAAAAAAQdCiIAAAAAACDoUBABAAAAAABBh4IIAAAAAAAIOhREAAAAAABA0KEgAgAAAAAAgg4FEQAAAAAAEHQoiAAAAAAAgKAT0tQJoGk5HA7Fx8e7PZaamqrU1NRGzggAAAAAEKjS0tKUlpbm9pjD4WjkbDyjIBLk7Ha7du7c2dRpAAAAAACaAU9/WI+Li1NOTk4jZ1Q9pswAAAAAAICgQ0EEAAAAAAAEHQoiAAAAAAAg6FAQAQAAAAAAQYeCCAAAAAAACDoURAAAAAAAQNBpVgWRDz74QDfccIPi4uIUHh6url27auLEifr88899En///v2aPn26LrzwQkVGRqp9+/a64oor9Ne//lXFxcU+uQYAAAAAAGh4zaIg4nQ6NXXqVF133XVauXKlcnJyVFxcrIMHD2rx4sUaPny4Zs6cWa9rrFq1SgkJCXrmmWe0Z88eFRYW6tixY1q7dq1SU1M1fPhwORyOWsXMz89XixYt1LFjR6/6P/7447JYLF49RowYUYdnCQAAAABAcAhp6gR8YdasWXr55ZclSVFRUbr11lvVtWtX7dy5U4sXL1ZRUZGefPJJxcXFacqUKbWOv23bNo0fP16FhYWSpOTkZA0fPlynTp3SW2+9pQMHDig7O1sTJkxQVlaWQkNDvYq7bNkyFRUVeZ3Hvn37ap07AAAAAACoKuALIl999ZX+8Ic/SJK6dOmiTz/9VN26dTOPT5s2TSNHjtSpU6f00EMPacKECWrTpk2trnH//febxZCFCxdq8uTJ5rHf/e53Gjt2rLKysvTZZ5/pzTff1B133FFjzLy8PM2ZM6dWeZQXRC666CLdfffdHvvGxsbWKjbqxlkibV5U1k6YLNm8q4UBAAAAAJpYwBdEnnnmGblcLknSCy+8UKkYIkmDBg3S73//e/36179Wfn6+/v73v+vBBx/0Ov769eu1Zs0aSdJNN91UqRgiSZGRkfrHP/6hHj16qLCwUPPmzfNYEHE6nfroo480a9asWo34MAxDe/fulSRdddVVuu+++7w+F3VjGJKr1HMfZ4n7dhWlksIiJElWQ7LUOzsAAAAAQH0EdEHEMAwtX75ckhQdHa3k5GS3/SZOnKhf//rXkqQVK1bUqiCybNkysz1p0iS3fTp16qRRo0Zp1apV2r59u77++mtdcMEFlfosWrRIzz//vHbt2qWzZ896ff1yx44dU15eniSpd+/etT4ftecq/XH0hze2ve7paKT0/AZJUoLzjGz1ygwAAAAAUF8Bvajqnj17lJOTI0m6+uqrFRLivr7ToUMHJSYmSpLWrl2rgoICr6+xevVqSVJISIhGjx5dbb9rr73WbGdlZVU5vmXLFm3atKlOxRCp8vohvXr1qlMMAAAAAABQJqBHiBw8eNBsjxw50mPfkSNHat26dSotLdW+ffs0YMCAWl1j0KBBioqK8hi/3K5du6ocT0lJ0bBhwyp9b+bMmdq5c6dXeVAQaVr9b5Osbv61OEt+HBly8a3VryHiyj+jrf+MbLgEAQAAAAC1EtAFkYrb3Nrtdo99O3ToYLa9LYi4XC4dPXq0TvHPlZCQoISEhErfe+GFF2rMoVz5+iEhISGKiorSjBkz9K9//Ut79uyRJHXv3l3XXHONpk2bxoKqDcAa4r7YYQuVBk31IkBA/0sDAAAAgOYnoD+mVSyItG3b1mPfdu3ame3yIkdNTpw4odLSUq/iR0dH1zp+bZQXWaxWq3r37m2uJ1Juy5Yt2rJli+bPn68FCxYoJSXF5zkAAAAAANBcNJuCSMWChDsVCxpnzpzxeXybzaY2bdooLy/P6/i1UV4QKS4uVnFxsQYPHqyf/vSnat26tb788kt98skn+uabb3T27FlNnjxZkZGRmjBhQo1xDcNQfn5+nfMKDw9XeHh4nc/3a4Yhcz+YoiLJVY9YRUWSIivEBQAAAIDAUlRUpKKiojqfb/jZZ6GALogcP37cbLds2dJj34rHvS1Y1CZ+eZ+GLohYLBalpaXpnnvukcXy4+athYWFmjFjhp577jlJ0j333KNrrrnG47onkpSbm6s2bdrUOa+ZM2dq1qxZdT7frxUXS/qh2PPwQ5KruO6xrGHSwOcrxK35fgIAAAAAfzJ37lzNnj27qdPwmYAuiISFhZnt06dPe+xbcYqJtyMaahO/4jV8PWKitLRUDz/8sCQpPj5eN9xwQ5U+ERERevbZZ7Vt2zZ98sknOnHihF577TWlpqZ6jN25c2e3i8B6q9mODgEAAAAAVPLoo49q+vTpdT6/b9++ys3N9WFG9RPQBZHIyB937Thx4oTHvhWPezPao7bxS0pKzO18vY3vrZCQEM2YMaPGfhaLRU8++aSGDx8uScrMzKyxIGKxWGocRRJwDEMK+WFH6aIiKcRWtzjFRTJHiDz1lNSyHsWf705KH9T9dAAAAABoavVdMqHiLAd/ENAFkfbt25vtmgoWJ0+eNNsVF1htyvgNoeLuOQcOHGiyPJpUcbF05xVl7UdrLiRVq+I0l7BwqT6jYSqMNgIAAAAAND1rUydQH7169TLbhw8f9tj3yJEjZrt3795exbfb7WrVqlWDxW8IrVu3Ngs5hYWFTZZHc2G1OGW1OCWnS3I66/5wuX6M5WcLCQEAAABAMAroESLx8fFm+5NPPtF9991Xbd/Vq1dL+nHbWm9YLBbFx8crOztbmzZt0okTJ6rdfrc8/rl5+YLD4TCLG926dfPY9+zZszp27Jgk6bzzzvNpHgFp9pNS2+i6nXvWpYGbN5W1N9cvDZukgT/cdk6je/2CAQAAAADqLaBHiPTp00exsbGSpKysLJWUlLjt53A4tHnzZknS5ZdfrtatW3t9jdGjR0uSXC6XsrKyqu330Ucfme2kpCSv43tj/vz56t69u7p3766NGzd67Ltr1y5zK6NLLrnEp3kEpLCwsqku5zyc1nBteLXs4bRWPV72YJoLAAAAADRXAV0QsVgsGjt2rCQpPz9fq1atcttv8eLFZnvcuHG1ukbF/m+88YbbPocPH9Ynn3wiSerXr5969uxZq2vU5Oabbzbbf/nLXzz2nTNnjtkeM2aMT/MIFIYhOa1hZY9SyVni/lGuuuOu0gp9Bg+Qhg2s88PZq2vj/yAAAAAAANUK6CkzkjR9+nS9+OKLcrlceuCBB3TJJZeoS5cu5vGNGzfqiSeekCRFR0dr6tSptYqfmJioESNGaM2aNXrvvfeUnp6ulJQU83hhYaFSUlJ09uxZSfJqN5ja6t+/v/r376+tW7fqjTfeUEJCgqZPny6r9cd6VnFxsf7whz/o3XfflSQNGTLEHN0SbFxOaXP5YqjLa+6/7XX337dafpzmIptVstVxtxpJsgZ07REAAAAAmp2AL4j06NFDjz32mObMmaODBw9qwIABuv322xUXF6cdO3Zo8eLFKioqkiQ988wzVbaYTU9P1+TJkyVJV111ldasWVPlGvPnz9dll12mwsJCTZ48We+++66uuOIKnTx5UkuWLNH+/fslSaNGjdItt9zi8+dosVj0xhtv6LLLLlNBQYEefvhhvf766xo9erTOO+887d27V5999pn27t0rSYqKitJrr73md1saNRrDKFu81HMXGSorcFjklLsfldXqaojsAAAAAAB+IOALIpI0a9Ys5ebmauHChTp58qSee+65SsctFovmzJlTaWRHbfTv319LlizRpEmTdOrUKa1cuVIrV66s1Gfo0KFasmSJQkIa5kd60UUXafHixUpJSdGxY8e0ZcsWbdmypUq/nj176t13323SnW6anGFoYO9NHrs4XRbZrEaVdnWszeJfCgAAAACgXLP4mGez2fTKK6/opptu0osvvqgNGzbo2LFjstvtGjZsmKZNm6bLL7+8XtcYM2aMtmzZovnz52vVqlU6dOiQIiMj1adPH91222365S9/qdDQUB89I/euv/56ff3113ruueeUlZWl/fv36/Dhw2rbtq0GDBign//850pJSVFYGIuB1qRiAaSmYogktyNI6uxMkVRwpv5xIiN8nBgAAAAABA+LUb4lCYJKXFyccnJyFBsbq0OHDjV1Oj7lPHJMtt1l05icvbrKZm/nppNT+mJrWfvy/jWvD2K11qv4UCmnGx+Q7cSJOscynV4vtYysfxwAAAAAaAT+9jm0WYwQAaplrWYxVJtNumpw4+cDAAAAAPALFESAxtAi4sf2zhVS64gqXRwOh1LuuVvZGzZoyKBBSn/xJdnt9sqdCgol+/AGThYAAAAAmj8KIkBjqDjdJiJSalm1IJKSeq8yV6+W0+lU5urVSkm9VxkZGY2YJAAAAAAED2tTJwCgTHZ2tpzOsu2CnU6n1q1b18QZAQAAAEDzRUEE8BNDhgyR7Yf1Tmw2mxITE5s4IwAAAABoviiIAH4iPT1dSUlJiomJUVJSktLT05s6JQAAAABotlhDBPATdrudNUMAAAAAoJFQEAlyDodD8fHxbo+lpqYqNTW1kTMCAAAAAASqtLQ0paWluT3mcDgaORvPKIgEObvdrp07dzZ1GgAAAACAZsDTH9bj4uKUk5PTyBlVjzVEAAAAAABA0KEgAgAAAAAAgg4FEQAAAAAAEHQoiAAAAAAAgKBDQQQAAAAAAAQdCiIAAAAAACDoUBABAAAAAABBh4IIAAAAAAAIOhREAAAAAABA0KEgAgAAAAAAgg4FEQAAAAAAEHQoiAAAAAAAgKBDQQQAAAAAAAQdCiIAAAAAACDoUBABAAAAAABBh4IIAAAAAAAIOhREAAAAAABA0Alp6gSAYOMqlVRS9fvOEmnb62Xti2+VbKFuTi6VFBYhSbIakqWhkgQAAACAZo6CSJBzOByKj493eyw1NVWpqamNnFHzt3N5iFwuZ5XvG4Yk2SRJ2193yuK22hEuvZAtSepfevaH3gAAAADgH9LS0pSWlub2mMPhaORsPLMYRtnHMASXuLg45eTkKDY2VocOHWrqdHzKeeSYbLv3l7Uv7C5bx5gmzkhy5hXKtnmH5z4ui2xWo0q72v4X95GtXSuf5QgAAAAADcnfPoeyhgjQCKwNMRaLWiYAAAAA1BlTZoBGYLFZpCWLPPaxGYb0w1Qam9Umd3NmnGGRst14c9kXJcU+zxMAAAAAggUFEaAxWCySs9T7/m7WGJEkldYiBgAAAACgWhREgMYQFiY991z94ziOS/tz6h8HAAAAAIIcBRGgMVgsUnh4/eOEhdU/BgAAAACARVUBAAAAAEDwoSACAAAAAACCDgURAAAAAAAQdCiIAAAAAACAoENBBAAAAAAABB0KIgAAAAAAIOhQEAEAAAAAAEGHgggAAAAAAAg6FEQAAAAAAEDQoSACAAAAAACCDgURAAAAAAAQdCiIAAAAAACAoENBBAAAAAAABJ2Qpk4ATcvhcCg+Pt7tsdTUVKWmpjZyRgAAAACAQJWWlqa0tDS3xxwORyNn4xkFkSBnt9u1c+fOpk4DAAAAANAMePrDelxcnHJycho5o+oxZQYAAAAAAAQdCiIAAAAAACDoUBABAAAAAABBhzVEgEB1pkgqOOObWJERksXim1gAAAAAEAAoiACBavB46cQJ38Q6vV5qGembWAAAAAAQAJgyAwAAAAAAgg4jRIBA0iLix/bOFVLriOr71qSgULIPr39OAAAAABCAKIgAgaTiOh8RkVLLehREAAAAACCIMWUGAAAAAAAEHQoiQDPkcDiUnJysmJgYJScny+FwNHVKAAAAAOBXKIgAzVBKSooyMzN1/PhxZWZmKiUlpalTAgAAAAC/QkEEaIays7PldDolSU6nU+vWrWvijAAAAADAv1AQAZqhIUOGyGazSZJsNpsSExObOCMAAAAA8C8URIBmKD09XUlJSYqJiVFSUpLS09ObOiUAAAAA8Ctsuws0Q3a7XRkZGU2dBgAAAAD4LUaIAAAAAACAoENBBAAAAAAABB2mzAQ5h8Oh+Ph4t8dSU1OVmprayBkBAAAAAAJVWlqa0tLS3B5zOByNnI1nFESCnN1u186dO5s6DdSFyyX9sLVunThdUouwsrZh+CYnAAAAAEHN0x/W4+LilJOT08gZVY+CCBCgbFt31T/Ih38v+6+LgggAAACA4MIaIgAAAAAAIOgwQgQIJFaLNu0ZKEnqP6FYtlZhdY91qkDassdHiQEAAABAYKEgAgQSi0Uuw1bWtlklm63usawMEAMAAAAQvPhEBAAAAAAAgg4jRIAA5TpTXO0xZ6m0bWm4JOniCUWyufuXfqZI5eNLDJchi+9TBAAAAAC/RUEECFBbl7f2ql95YeRcVkuIBvYua7vOFqsek28AAAAAIOA0qykzH3zwgW644QbFxcUpPDxcXbt21cSJE/X555/7JP7+/fs1ffp0XXjhhYqMjFT79u11xRVX6K9//auKi6v/a72vbdu2TVOnTlWPHj3UokULdezYUaNHj9Ybb7whl8vVaHnAf1mcRW7bAAAAAIAyFsMwjKZOor6cTqd+9atf6eWXX662zxNPPKHZs2fX+RqrVq3SL37xC+Xn57s9PmTIEK1YsUJ2u93rmPn5+erQoYOio6N15MgRr8555ZVXdO+991ZbgLn22mu1dOlStWzZ0mOcuLg45eTkKDY2VocOHfI650DgPHJMtt37y9oXdpetY0wTZ+Q7hsvwOFWmnDdTZlzfnVDowbL/983t5wQAAADA//jb59BmMWVm1qxZZjEkKipKt956q7p27aqdO3dq8eLFKioq0pNPPqm4uDhNmTKl1vG3bdum8ePHq7CwUJKUnJys4cOH69SpU3rrrbd04MABZWdna8KECcrKylJoaKhXcZctW6aiIu//ep+ZmakpU6bIMAzZbDbddNNNGjRokBwOh9544w0dPXpUH3zwgaZOnarXX39dFgurQjQ3FqtFtlbup8BUZJM0aGr5V9X0P+3dfQoAAAAAzVHAjxD56quv1Lt3b7lcLnXp0kWffvqpunXrZh7fsGGDRo4cqVOnTikqKkoHDx5UmzZtanWNkSNHas2aNZKkhQsXavLkyeaxM2fOaOzYscrKypIkpaen64477qgxZl5engYPHqx9+/bJbrfXOEKktLRUffr00VdffaWQkBCtWrVKV199tXn8+++/109+8hNt3bpVkrRmzRpdddVV1cbzt8qcLzXnESK+xM8JAAAAQGPyt8+hAb+GyDPPPGOum/HCCy9UKoZI0qBBg/T73/9eUtkUlb///e+1ir9+/XqzGHLTTTdVKoZIUmRkpP7xj38oIiJCkjRv3jyP8ZxOpz744AMlJSVp3759XuexfPlyffXVV5Kk+++/v1IxRJLat2+vV1991fy6pjwAAAAAAAhmAV0QMQxDy5cvlyRFR0crOTnZbb+JEyea7RUrVtTqGsuWLTPbkyZNctunU6dOGjVqlCRp+/bt+vrrr6v0WbRokS655BK1atVK1113ndatW+fzPBISEtSvXz9JZdNrzpw5U6trAAAAAAAQLAK6ILJnzx7l5ORIkq6++mqFhLhfEqVDhw5KTEyUJK1du1YFBQVeX2P16tWSpJCQEI0ePbraftdee63ZLp8+U9GWLVu0adMmnT171utru8vDbrcrISGhxjyKiop8trsOAAAAAADNTUAXRA4ePGi2R44c6bFv+fHS0tJaTVUpv8agQYMUFRVVY3xJ2rVrV5XjKSkpevvttys94uPjvcqhuLjYXGNkxIgRslqr/99WUx4AAAAAACDAd5lxOBxmu6btbjt06GC29+3bpwEDBtQY3+Vy6ejRo3WKf66EhIQqIzteeOGFGnOQZObgizwAAAAAAECAjxCpWBBp27atx77t2rUz2xULDJ6cOHFCpaWlXsWPjo6udXxvNfTzBAAAAAAg2DSbESIVCxLuVCwkeLvYaG3i22w2tWnTRnl5eT5fzLQhn6dhGMrPz69zbuHh4QoPD6/z+QAAAACAwFBUVKSioqI6n28Yhg+zqb+ALogcP37cbLds2dJj34rHvS1Y1CZ+eZ+GKIg05PPMzc1VmzZt6pzbzJkzNWvWrDqfDwAAAAAIDHPnztXs2bObOg2fCeiCSFhYmNk+ffq0x755eXlm29sRDbWJX/Eavh4x0ZDPs3PnzvVafJXRIQAAAAAQHB599FFNnz69zuf37dtXubm5PsyofgK6IBIZGWm2T5w44bFvxePejPaobfySkhJzO19v43urIZ+nxWLxuHsOAAAAAABS/ZdMsFgsPsym/gJ6UdX27dub7ZoKBSdPnjTbFRcebcr43vKXPAAAAAAAaC4CuiDSq1cvs3348GGPfY8cOWK2e/fu7VV8u92uVq1aNVh8bzX08wQAAAAAINgEdEEkPj7ebH/yySce+65evVqSZLVavS4UWCwW8xqbNm3yODqjPP65eflCTEyMOnToIEn69NNP5XK5miQPAAAAAACai4AuiPTp00exsbGSpKysLJWUlLjt53A4tHnzZknS5ZdfrtatW3t9jdGjR0uSXC6XsrKyqu330Ucfme2kpCSv49c2j++//14bNmyoMY+wsDANHz7c53kAAAAAANAcBHRBxGKxaOzYsZKk/Px8rVq1ym2/xYsXm+1x48bV6hoV+7/xxhtu+xw+fNgcodKvXz/17NmzVtfwVR6bN282d4xJSkoyp/sAAAAAAIDKArogIknTp0+X1Vr2NB544AEdPHiw0vGNGzfqiSeekCRFR0dr6tSptYqfmJioESNGSJLee+89paenVzpeWFiolJQUnT17VpI0Y8aMOjyLmt14443q0aOHJCktLU2ZmZmVjh87dkwpKSnm14888kiD5AEAAAAAQHMQ0NvuSlKPHj302GOPac6cOTp48KAGDBig22+/XXFxcdqxY4cWL16soqIiSdIzzzxTZYvZ9PR0TZ48WZJ01VVXac2aNVWuMX/+fF122WUqLCzU5MmT9e677+qKK67QyZMntWTJEu3fv1+SNGrUKN1yyy0N8jxDQkL017/+Vddcc41KS0uVnJysm2++WQkJCTp8+LDeeOMNHT16VJJ0xx13MF0GAAAAAAAPAr4gIkmzZs1Sbm6uFi5cqJMnT+q5556rdNxisWjOnDmVRlDURv/+/bVkyRJNmjRJp06d0sqVK7Vy5cpKfYYOHaolS5YoJKThfqRXX321XnrpJaWmpqqkpERvvvmm3nzzzUp9xo4dqwULFjRYDgAAAAAANAcBP2VGkmw2m1555RW9//77uv7669WpUyeFhYXp/PPP18SJE/Wf//xHjz32WL2uMWbMGG3ZskUPPPCAevbsqRYtWqhdu3YaOnSoFixYoDVr1qh9+/Y+ekbVmzJlitavX69f/vKX6tatm8LCwnTeeefpJz/5id58800tW7ZMERERDZ4HAAAAAACBzGIYhtHUSaDxxcXFKScnR7GxsTp06FBTp+NTziPHZNtdNo3JeWF32TrGNHFG/omfEwAAAIDG5G+fQ5vFCBEAAAAAAIDaoCACAAAAAACCDgURAAAAAAAQdCiIAAAAAACAoNMstt0FUE9niqSCM76JFRkhWSy+iQUAAAAADYSCCABp8HjpxAnfxDq9XmoZ6ZtYAAAAANBAmDIDAAAAAACCDiNEgpzD4VB8fLzbY6mpqUpNTW3kjNBoWkT82N6+XGoVUaWL4+hRpfzqbmVv2Kghgy5R+oKXZO/QoWqsM4VS96SytmE0TL4AAAAA/F5aWprS0tLcHnM4HI2cjWcWw+DTSzCKi4tTTk6OYmNjdejQoaZOx6ecR47Jtnt/WfvC7rJ1jGnijPyTM69Qts07PPZJ/u39ylyfLafLKZvVpqTBQ5Tx9HOeAw/sI0W18mGmAAAAAJoDf/scypQZANXK/nKnnC6nJMnpcmrdlzubOCMAAAAA8A2mzADBymrRpj0DJUn9JxTL1iqsSpchl1+mzKwsOZ1O2Ww2JV5+mTRsYNVYpwqkLXsaOmMAAAAA8BlGiADBymKRy7DJZdgkm1Wy2ao80l99VUlJSYqJiVFSUpLSX33VbT9ZeSkBAAAAEFgYIQKgWna7XRkZGU2dBgAAAAD4HH/WBQAAAAAAQYcRIgDkKpVUUvX7zhJp2+tl7YtvlWyh1QQolWw/NA1DsjRAjgAAAADgSxREAGjr0vAa+5QXRtyxWiI0sHdZ2+X8sTgCAAAAAP6KKTMAfMswmjoDAAAAAKgRI0SAIGUNkRI2TfPYx2kJ1baEv0iSLt48XTbDzbwaSa7QSKn3+LIvSop9micAAAAANAQKIkCQslgkm8tz8cKmYg3acHfNwVy8lAAAAAAILHyKAYJVWJj03HO+ieU4Lu3P8U0sAAAAAGgEFESAYGWxSOE1L6bqlbAw38QBAAAAgEbCoqoAAAAAACDoUBABAAAAAABBh4IIAAAAAAAIOhREAAAAAABA0KEgAgAAAAAAgg4FEQAAAAAAEHTYdjfIORwOxcfHuz2Wmpqq1NTURs4IAAAAABCo0tLSlJaW5vaYw+Fo5Gw8oyAS5Ox2u3bu3NnUaQAAAAAAmgFPf1iPi4tTTk5OI2dUPabMAAAAAACAoENBBAAAAAAABB0KIgAAAAAAIOhQEAEAAAAAAEGHgggAAAAAAAg6FEQAAAAAAEDQoSACAAAAAACCDgURAAAAAAAQdCiIAAAAAACAoENBBAAAAAAABB0KIgAAAAAAIOiENHUCAJoZl0tyOusfx2qVLJb6xwEAAAAANyiIAPAp295vpL3f1D/QsIGSzVb/OAAAAADgBlNmAAAAAABA0GGECID6s1i0ac9ASVL/nzhkax9Vtzgul7RlT1nbMHyUHAAAAABURUEEQP1ZLHIZP0xvuXisdKagbnFahEkf/r2sfeasFNXKN/kBAAAAwDmYMgMAAAAAAIIOI0SCnMPhUHx8vNtjqampSk1NbeSMEJAiIn5s7/9YahletzinCqTdPliQFQAAAECTSEtLU1pamttjDoejkbPxjIJIkLPb7dq5c2dTp4FAV3F73BBb2eMcDodDKVOmKHv9eg0ZPFjpL78su91euVNIhUFrrCECAAAABBxPf1iPi4tTTk5OI2dUPQoiAHzK9fiTkquoyvfvWLVCWYe+ldMwlJmZqTuGDdeq626o3MkWItv4SZIko7hYlipRAAAAAMA3KIgA8KmtA+a5/f5/X3tTzh9GfTgNQ/89XqDNA5+v1MdqcWqgNkmSXE6p6jgTAAAAAPANFlUFUH9hYTV26ddtiGzWshKHzWpTv26JDZ0VAAAAAFSLESIA6s0aalHCZM99Fiel65YxKdpxYJ0uHZqoRQvTde4SIi5HnvRVw+UJAAAAAOUoiACoN4tFsoV67nN+d7v+sz3Dc6cQFlIFAAAA0DiYMgMAAAAAAIIOBREAAAAAABB0KIgAAAAAAICgQ0EEAAAAAAAEHQoiAAAAAAAg6FAQAQAAAAAAQYeCCAAAAAAACDoURAAAAAAAQNChIAIAAAAAAIIOBREAAAAAABB0KIgAAAAAAICgQ0EEAAAAAAAEHQoiAAAAAAAg6IQ0dQJoWg6HQ/Hx8W6PpaamKjU1tZEzAgAAAAAEqrS0NKWlpbk95nA4GjkbzyiIBDm73a6dO3c2dRoAAAAAgGbA0x/W4+LilJOT08gZVY8pMwAAAAAAIOhQEAEAAAAAAEGHKTMA/JPLJTmdvolltUoWi29iAQAAAGgWKIgA8Eu2vd9Ie7/xTbBhAyWbzTexAAAAADQLTJkBAAAAAABBhxEiAPyHxaJNewZKkvqPOSnbedF1j+V0SV9s8U1eAAAAAJodCiIA/IfFIpdRNrXF5bJJrnpMc3FJ5WcbhsQKIgAAAAAqalYFkQ8++EAvvviiNm7cqO+++04dO3bU0KFDlZqaqmHDhtU7/v79+/X8889r1apV+vbbbxUZGakLL7xQkyZN0l133aWwsLBGiQEEg63vR9frfKtFGti7rO0qlWzN6tUOAAAAQH01izVEnE6npk6dquuuu04rV65UTk6OiouLdfDgQS1evFjDhw/XzJkz63WNVatWKSEhQc8884z27NmjwsJCHTt2TGvXrlVqaqqGDx8uh8PRoDFeeeUVWSwWrx7dunWr1/MFmhXDaOoMAAAAAPiZZvE301mzZunll1+WJEVFRenWW29V165dtXPnTi1evFhFRUV68sknFRcXpylTptQ6/rZt2zR+/HgVFhZKkpKTkzV8+HCdOnVKb731lg4cOKDs7GxNmDBBWVlZCg0NbZAY+/btq3XuQCCx2qSETdM89nFaQrUt4S+SpIs3T5fNKHHbzxUaKfUeX/ZFcYkU0Sxe7gAAAAD4SMB/Qvjqq6/0hz/8QZLUpUsXffrpp5VGR0ybNk0jR47UqVOn9NBDD2nChAlq06ZNra5x//33m4WMhQsXavLkyeax3/3udxo7dqyysrL02Wef6c0339Qdd9zRIDHKCyKdO3fWo48+6jHn1q1b1+o5Av7AYpFsrmKPfb4/c1K/m9NF2UePakiHDkq/6irZIyOrdnRVeHljhAgAAACAc1gMI7A/Kdx3331KS0uTJK1YsUJjxoyp0mf+/Pn69a9/LUmaN2+eHnzwQa/jr1+/XomJiZKkm266Sf/85z+r9Dl8+LB69OihwsJCXXTRRdq2bZvPY0hSQkKCtmzZouuuu07vv/++18/Bnbi4OOXk5Cg2NlaHDh2qVyx/4zxyTLbd+8vaF3aXrWNME2cEr50ukNpe6rFLcukBZapATpUtmpqkVsoI6Vqln7NtO9neLhtJwn0AAAAAND1/+xwa0GuIGIah5cuXS5Kio6OVnJzstt/EiRPN9ooVK2p1jWXLlpntSZMmue3TqVMnjRo1SpK0fft2ff311z6PYRiGOUKkd+/etXoOQMCwWKRSl8dHtgrl/KG7U9I6FVbT1+npSgAAAACCXEAXRPbs2aOcnBxJ0tVXX62QEPczgDp06GCO0Fi7dq0KCgq8vsbq1aslSSEhIRo9enS1/a699lqznZWV5fMYDofDzLtXr15eZg8EmMgI6fR6j48hST+RzVa2oa7NZlNi0ij3fde/3cRPBgAAAIA/C+iCyMGDB832yJEjPfYtP15aWlqrxUnLrzFo0CBFRUXVGF+Sdu3a5fMYFXOmIIJmy2KRWkZ6fKS/9pqSkpIUExOjpKQkpb/2mvu+keFN/WwAAAAA+LGALohU3KLWbrd77NuhQwez7W1BxOVy6ejRo/WK74sYkrR3716zHRsbq7lz52ro0KGKiYlRq1at1LdvX913333avXt3Dc8KCGx2u10ZGRn6/vvvlZGRUeO/KwAAAABwJ6B3malYEGnbtq3Hvu3atTPb5QWKmpw4cUKlpaVexY+OjnYb3xcxpMoFkhEjRlQ5/uWXX+rLL7/UggUL9Pvf/16PPvqoLBaLx+sBAAAAABCsmk1BpGIxwZ2KxYgzZ874PL7NZlObNm2Ul5dXKb4vYkiVCyJHjx5Vnz59dMMNN6h9+/bau3evPv/8c+3atUsul0v/93//p5CQEP32t7+t8TkahqH8/Pwa+1UnPDxc4eFMTQAAAACA5q6oqEhFRUV1Pt/fNrkN6ILI8ePHzXbLli099q143NuCSG3il/c5t5jhixhS5YLI//3f/2n27NnmwpJS2doo8+bN06OPPmr2mTBhgrp16+bxerm5uWrTpk2NeVVn5syZmjVrVp3PBwAAAAAEhrlz52r27NlNnYbPBHRBJCwszGyfPn3aY9+8vDyz7e2IhtrEr3iNivF9EUOSUlJSNH78eMXGxuq2226rcl5ISIhmzJihPXv2aNGiRSotLVVaWpr+9Kc/ebxe586dqyzgWhuMDkFAcLkkpw+24bVayxZ+BQAAAILQo48+qunTp9f5/L59+yo3N9eHGdVPQBdEIiMjzfaJEyc89q143JuRGrWNX1JSYm6LWzG+L2JI0rRp07zK+cknn9SiRYskSZmZmTX2t1gsHne+AZoD295vpL3f1D/QsIFShZFZAAAAQDCp75IJ/rbOZUDvMtO+fXuzXVOx4eTJk2a74gKrDR2/oXM8V1xcnGJiYiRJBw4cqFMMAAAAAACau4AeIdKrVy+zffjwYY99jxw5YrZ79+7tVXy73a5WrVrp9OnTdY7vixi11b17dx07dkyFhYV1jgEEPItFm/YMlCT1H3NStvOi6xbH6ZK+2OK7vAAAAAD4hYAeIRIfH2+2P/nkE499V69eLUmyWq1eFxssFot5jU2bNnkc4VEe/9y8fBHj2LFjOnDggA4cOGBu4etJ+Zys8847r8a+QLNlschl2OQybGVrf9hsdXwE9MskAAAAgGoE9Dv9Pn36KDY2VpKUlZWlkpISt/0cDoc2b94sSbr88svVunVrr68xevRoSZLL5VJWVla1/T766COznZSU5NMY//znP9W9e3d1795dK1as8Jjv8ePHzYLIJZdc4rEvAAAAAADBKqALIhaLRWPHjpUk5efna9WqVW77LV682GyPGzeuVteo2P+NN95w2+fw4cPmCJV+/fqpZ8+ePo1x0003mVvsPvvss3J62C3jqaeeMttjxoypth8QVIqLpaKiOj6Kf4zjZ/umAwAAAKg7i2EE9jv8r776Sr1795bL5VKXLl3073//W126dDGPb9y4USNHjlR+fr6io6P1zTff1HpXlZEjR2rNmjWSpEWLFiklJcU8VlhYqHHjxunjjz+WJL322mu69dZbfR5j7Nix5uiQBx54QE8//XSlLX1dLpdeeuklTZs2TU6nU+eff7727NmjFi1auH1OcXFxysnJUWxsrA4dOlSrn4e/cx45Jtvu/WXtC7vL1jGmiTNCU3AePaHNy9tKkhI2TZPNVVzDGdWwhUg3Ty5rJ/aTIiN8lCEAAAAQXPztc2jAF0Qk6fHHH9ecOXMkSdHR0br99tsVFxenHTt2aPHixSoqKpJUtRAhSenp6Zo8uezDzlVXXWUWLSraunWrLrvsMnOR0jFjxuiKK67QyZMntWTJEu3fX/bhe9SoUfroo48UElJ1rdr6xsjNzdXgwYPNhVl79Oih6667TrGxsTpw4IDWrl2rLVvKFn4MDQ3V6tWrNWzYsGp/Zv52I/oSBRFIFEQAAAAAf+Nvn0ObRUHE6XRq6tSpWrhwodvjFotFc+bM0WOPPVblmDcFEUlauXKlJk2apFOnTrk9PnToUL333nuVttn1dYz//e9/mjBhgg4ePFjtNex2uxYvXqwRI0ZU20fyvxvRlyiIQJKcJwu0eWlLSVL/60/KGlXHQsbZQtl27JMkGYP7ydKSgggAAABQF/72OTSgt90tZ7PZ9Morr+imm27Siy++qA0bNujYsWOy2+0aNmyYpk2bpssvv7xe1xgzZoy2bNmi+fPna9WqVTp06JAiIyPVp08f3XbbbfrlL3+p0NDQBo1x6aWXas+ePfrb3/6m9957T/v379ehQ4fUunVr9e3bV+PGjdPdd9+tVq1a1eu5As2CxWI2t74fXecwVkuIBv6wMZWrVLLVMy0AAAAA/qFZjBBB7flbZc6XGCECSXLmndHmJZH1jmO1ODWw96aymAn9ZGvDCBEAAACgLvztc2izGCECAOey2qSEaYPKvjj6bymybsURV36xtN2HiQEAAADwCxREADRLFotkKy5bxFhFhXV/tSsp/LHNgDoAAACg2aAgAqD5sw+v+7lt20rL5pe1zxZKqv80HAAAAABNz9rUCQAAAAAAADQ2RogAaJ4iI6TT6z12cTgcSrnnbmVv2KAhgwYp/cWXZLfbz+l0Uvo2t+HyBAAAANAkKIgAaJ4sFqml5+ktKan3KnP1ajmdTmWuXq2U1HuVkZFRuVNkofuTAQAAAAQ0pswACFrZ2dlyOp2SJKfTqXXr1jVxRgAAAAAaCyNEgpzD4VB8fLzbY6mpqUpNTW3kjIDGM2TIEGVmZsrpdMpmsykxMdHzCS6X9EMBpd6s1rJRLAAAAEAzkpaWprS0NLfHHA5HI2fjmcUw2EcyGMXFxSknJ0exsbE6dOhQU6fjU84jx2Tbvb+sfWF32TrGNHFG8FcOh0MpKSlat26dEhMTlZ6eXmUNkYr3k08NGyjZbL6PCwAAAPgpf/scyggRAEHLbrdXXTMEAAAAQFCgIAIAnlgs2rRnoCSp/5iTsp0XXfdYTpf0xRbf5AUAAACgXiiIAIAnFotcxg9TW6xWprkAAAAAzQQFEQDwVnGxVFRU9/Odrh/bLN8EAAAANCkKIgDgJdfcP0muagoihiGbUSJJclpC3e8gYwuRbfyksu5FJbKE8BIMAAAANBXejQOAl7YOmFev860WpwZqkyTJVSox+QYAAABoOtamTgAA/FpYWFNnAAAAAKABMEIEADywhliUMG1Q2RdH/y1FRtY5liu/WNruo8QAAAAA1AsFEQDwwGKRbMWFZV+ESAqtRzBecQEAAAC/wZQZAAAAAAAQdCiIAAAAAACAoMMAbgDwVkFh/c4vrHC+YdQvFgAAAIB6oSACAN6yD6/f+W3bSsvml7XPFkqq+wKtAAAAAOqHKTMA4AMOlSpZBxWj3UrWQTlU6vkEl0tyOn3zYLQJAAAAUGuMEAEATyIjpNPra+yWcuM4Za7+Wk6nS5m2s0oZ1U0Zy5ZX7uQ4KX2bK0my7f1G2vuNb3IcNlCy2XwTCwAAAAgSFEQAwBOLRWpZ89SW7A0b5HQ6JUlOp1PrNm6sel5kPdcgAQAAAOAzFEQAwAeGDBmizMxMOZ1O2Ww2JSYmVu1ksWjTnoGSpP5jTsp2XnTdL+h0SV9sqfv5AAAAQJCjIBLkHA6H4uPj3R5LTU1VampqI2cEBKb09HSlpKRo3bp1SkxMVHp6etVOFotcRtnUFleRUyqsYZ0RT5wulU+SMVyGLMyYAQAAgB9IS0tTWlqa22MOh6ORs/HMYhisxheM4uLilJOTo9jYWB06dKip0/Ep55Fjsu3eX9a+sLtsHWOaOCOgjPPoCW1e3tZjH4uzSIYtvEr7XFaLUwN7byqLm9BPtjYRvk0WAAAA8DF/+xzKLjMA4EcqFkCqK4YAAAAAqD+mzABAI7FGhCnhNz+sLbL/Yymy5sVaq+M6fVba7aPEAAAAgCBEQQQAGonFapHtTEHZFy3Dyx515XT5JikAAAAgSDFlBgAAAAAABB0KIgAAAAAAIOhQEAEAAAAAAEGHgggAAAAAAAg6LKoKAE2hoLB+5xdWON/pLHvUl9UqWSz1jwMAAAAEAAoiANAU7MPdftuhUqUoV9kq1BBFKF2dZXf3Ut22rbRsviTJtu1L3+R0RYIUwq8FAAAABAemzACAH0lRrjJVoONyKVMFSlFu3YOVlkhvvlz2KC2puX+xF30AAACAZoI/BQJAY4mMkE6v99glu8v5ch4vkCQ5Ja1r10I66Oaco3nalNVBknTRtsdkdRW7DxgaWfbfZUvdHw8Jke3GmyVJhiExYQYAAADBgoIIADQWi0VqGemxy5AhQ5SZmSmn0ymbzabEIYnuz2lryGXYJElbL/p/dU7JanFqoDZJklylkq3OkQAAAIDAwpQZAPAj6enpSkpKUkxMjJKSkpSenu6+I4ufAgAAAPXCCBEA8CN2u10ZGRk19rPapIRpg8q+OPpvKdLzyJPquPKLpe11OhUAAAAIaBREACAAWSySrfiHrXdDJIXWMRC/BQAAABCkmDIDAAAAAACCDn8bBABIklzFLums0yexrGFWWayscwIAAAD/RUEEACBJCt25y+33nS6LbFajStsT55AE2SL4FQMAAAD/xbvVIOdwOBQfH+/2WGpqqlJTUxs5IwC1VlBY93MLvTi3tFQb9l8qSUro/j8pzIvNeYtLJAoiAAAAQSctLU1paWlujzkcjkbOxjOLYRg1/6kPzU5cXJxycnIUGxurQ4cONXU6PuU8cky23fvL2hd2l61jTBNnBDSAgjNSq8EeuzhUqhTlKluFGqIIpauz7OfUwY0Qq1x3J/kkJVdYpELH3ihJcib0k61NhE/iAgAAoHnwt8+h/PkOAJqpFOUqUwVySspUgVKUqwx1qdTHUuqS7aXMsi8c/5Za1m37XknSqUJpx766nw8AAAA0IgoiABCIIiOk0+s9dsnucr6cxwskSU5J69q1kA6ec05BoWQfXtYODy971NVZV93PBQAAABoZBREACEQWS42jOYYMGaLMzEw5nU7ZbDYlDkms3wgQAAAAoBmhIAIAzVR6erpSUlK0bt06JSYmKj09vfEuXlIkFVnrHycsrKz4AwAAAPgYBREAaKbsdrsyMjKa5NquP/xJKj5T7zjWP82VJaKFDzICAAAAKqMgAgDwufLdZurLWWzIxmY1AAAAaAA+GM8MAICksNAauzhdFrdtAAAAoLExQgQAUKag0O23HQ6HUu65W9kbNmjIoEFKf/El2e32Kv2sLkPOi/uUfRHRotq1P5zVtMu5Tp1V6M5dtUweAAAAqB0KIgCAMuXb754jRQeVqQI5JWVmZiqlx8XKUJcq/SySbOVfnF5f9x1tfLEYKwAAAFADCiIAAI+yVWiO5HBKWqezjXZtV2GxZPNNgcQaGSaLlWk6AAAAKENBBACCWWRE2WgOD4bcOE6Zq1fL6XTKZrMpcdQoadnyqh0LCqsdZVJXO1dFyuXyTUGk/y1FsrVmxxoAAACUoSACAMHMYqlxakv6a68pJSVF69atU2JiotLT0+s+HaaWBvTcUu0xZ7FTtjBblXa1/V39fJobAAAAAhsFEQCAR3a7XRkZGY12PWtkzbvVSKpUAKmpGAIAAACci4IIAMD36rFjjcUwpIE/7FYTWf1uNd5w5p+VbWvZjjWuUkkldQ5ViTWkXmkBAADAD1AQAQD4Xj13rDHVZ7caSbL+uP7I9nfD5DLqHqqihBRDtjAqIgAAAIGMgggAoNE05Y41VqtLcrn5vrNIAzb9RpK0ZeAzctnCaw5WVCKFsUArAABAIKMgAgDwDV/tWOPD3WqsFX7LeVqgVX2nlPXRTq/iskArAABA4KMgAgDwDT/cscYS7t0CrbXlKiyWbPXfDtgaGSaLlak3AAAATYGCSJBzOByKj493eyw1NVWpqamNnBGA5qzWO9ZUszir5N0CrWqgBVp3roqUy1W1IGIYkqGyHW8sctZ4uf63FMnWmqk3AACg+UhLS1NaWprbYw6Ho5Gz8cxiGIaPlphDIImLi1NOTo5iY2N16NChpk7Hp5xHjsm2e39Z+8LusnWMaeKMANRKwRmp1eAauyVXWKDVJilJLRt0gVZnXqFsm3fU+Xy3MRP6ydYmwqcxAQAA/JW/fQ5lhAgAICA19gKt1kjfT7/x1dQbiek3AAAAtUVBBECzVVRUpLlz5+rRRx9VeLgXO4fAP3ixOKvkuwVaHQ6HUlJSlJ2drSFDhig9Pb3q1BtJlhCbNGxgbZ6JWxWn3mxf2Uouw1b1Ws4iGT/sdlOx7U5xSZEWfThXz6ZPV2RMVL3zA/wRr+cIBtznQONjykyQio2NVW5urjp37qycnJymTsenmDKDcvn5+WrTpo3y8vIUFcUHxeamvJBRcYHWKoWMitNvHP+WWladnpJ8TmEladQoZZxbWDlXZESd1yOpOPVmy74BbtciqY3Thfm68oF2+n7vt4rueF69YkmMNIF/4vUcwYD7HMHA3z6HMkIEABCQar1AazUjRbK1W065JElOp1PrMlfXvIZJPdYjqTj1xuNWwF7KLzgtSdr5QUtFtqj/XxQTflEkWyv+MgkAAJo/30xcBgAgQA1RhMonrdgkJaruu744HA4lJycrJiZGycnJbldSb6jRF1arS1aLs8rD5jpj9rG5zrjtU/GhorNSUZFvHgxCBQAAfowRIgCA5suL9UjSf9i+d92GjUocdInSX3xJcrOGSKX1SKrZDjjlttvM6TeZmZlKue22qtNvfLgVsFHilFavlSRdfME2RbVsVedY5Upmvy2VnKm5oxesz8yTxQejVgAAABoCBREAQPNlsdQ4tcV+QXdlfPxx7eL6avpNPbcCboixJjsHzKl2XRPDkIwfxtNY5KyxlnNRXoGspb7Ji7VNAACArzWrgsgHH3ygF198URs3btR3332njh07aujQoUpNTdWwYcPqHX///v16/vnntWrVKn377beKjIzUhRdeqEmTJumuu+5SWFhYwMQAAPjeEEUoUwVyysvpN9WMNHH8MGole8MGDRk0SOkvvuR25xsZhtS/d1n7sv5SmzZ1ytt51inb+q2SfLOuSblNKwa63UWnLhJ+ni9bSx+MNgkLq9eoHAAA0Hw0i11mnE6nfvWrX+nll1+uts8TTzyh2bNn1/kaq1at0i9+8Qvl5+e7PT5kyBCtWLHC/RtWP4sh+d/qvr7ELjMox2rt8CnDkM64L2CUc7iZflN155uatwJO1sFKhZUktVSGurjtmy+n2miP8nIPK6pTR/c51bCtsFHqlOU/mzzmVBe+2EWn3EWbH5HVVVTvOEzjCUy8niMYcJ8jGPjb59BmURB5/PHHNWfOHElSVFSUbr31VnXt2lU7d+7U4sWLVVRU9gbqb3/7m6ZMmVLr+Nu2bdOll16qwsKyN8LJyckaPny4Tp06pbfeeksHDhyQJF155ZXKyspSaGio38Yo5283oi9REEE53ljAL1XcCrgaMdqt4z9MvSn72qbv1dttX7Mgsm+/ojp2qHLcq22FDUNy/fB2wAfrmlj+t7XO51enuuJKrafx3FAgqy9GmkiyhvhosAmjVmrE6zmCAfc5goG/fQ4N+ILIV199pd69e8vlcqlLly769NNP1a1bN/P4hg0bNHLkSJ06dUpRUVE6ePCg2tRySPHIkSO1Zs0aSdLChQs1efJk89iZM2c0duxYZWVlSZLS09N1xx13+G2Mcv52I5ZLS0tTampqvWL4uiDii5x8zR9zkvwvL399Y+FvPyeJnGqj3nl5MdLEqyKGJBUUKt8+tKwgot6KUtXpKbUprkiSHP+WWka4P+TNVB6nS9r0pdKWLVXqjRM8Ps/GlrZsqYZd/JRfjVr56/atuu/9lb4bteKj4oq//fvj9dx75OQ9f8uL+9x75OQ9f8vL3z6HBnxB5L777lNaWpokacWKFRozZkyVPvPnz9evf/1rSdK8efP04IMPeh1//fr1SkxMlCTddNNN+uc//1mlz+HDh9WjRw8VFhbqoosu0rZt2/wyRkX+diOWi4+P186dO+sVw9cFEV/k5Gv+mJPkf3n56xsLf/s5SeRUG42RV/k0l3Xr1ikxMdHtNBdJUsEZ5bca6LEgUpvpNzXxOlaLMMUXfamdud+W7fRz7vM7elQpv7pb2Rs2asigS5S+4CXZO1Qd3WI4XbJs3VOnXN2Jv2OCdr661GfxNu1xv0aK1VmkgZvvL+uT8JxctuqLHeNnxWv3jdf6ZDqQJOmpp6Sw+hdXLh6coB07d/rNQra8nnuPnLznb3lxn3uPnLznb3n52+fQgF5U1TAMLV++XJIUHR2t5ORkt/0mTpxoFkRWrFhRq4LIsmXLzPakSZPc9unUqZNGjRqlVatWafv27fr66691wQUX+F0MAEBgsNvtysjIqLljZISU+6nUuVPZf928gfZqW2Ev1jWRpGwVyvlD2ylpnc6673i2WJIhdbrK7eGUCoWVzKwspfTq77awYpGkFj8sFL4/s87FFaPUKcu2vR6fm+P4MaX8cbayv9ypIX3ilT5jpuztPBfUrVaXKgy++VFIiDYN/uuP/cyfmnvbE/5ftcdqOyXI9Y5Vvth/6Gy+RaXfn5Y10j8WaneeLisYOYsNOUvqH89n050AAAEtoAsie/bsMatKV199tUJC3D+dDh06KDExUevWrdPatWtVUFCgli1benWN1atXS5JCQkI0evToavtde+21WrVqlSQpKytLU6dO9bsYAIBmpuK2wi0j3W7h69W2wpERZVsA12DIOVN5EkeNks6dyuNFccXrwor0Q3FF9SqumIWVolzpwq5uCyspP7tRmRuy5XQ6lbkhWyl/naeMfy6r0q/iqJXqduSpTXGlRdhZDexd/YK2tS3U+HIh2+3vud8SutZFGqP+RZrThWWjXra+YVEr9zO6aqX/hCJZffEu2GWYxRpfYHtpAGhcAV0QOXjwoNkeOXKkx74jR47UunXrVFpaqn379mnAgAG1usagQYM8Dl2reP1du3b5ZQwAANyqWFjxIP2116pM5alyXnlxZdAgaYP7IotXhRXJt8WVGkatZGu3nD8M93A6nVqX9YnUZkiVfpYWYdKHf/eYU8ofZytzfbacLqcy12cr5Y+zlfH0cx7P8VUsXxRpJM+FGl8VaY7lOzRz0Z3acWCd+nVL1OzJCxUT5X6XPKvFaf63vF2RxVkkp7XsXrS5zsjwME1Jkra/7Zu3wGfzLdr6lu/eTl90w6n6L/rr4yKNT/hjTlJZXsWGT4YLMeoICEwBXRBxOBxmu6ZtZjtUGD7rbUHE5XLp6NGjdYrvbzEAAKgvr6bylBdXrNUXWbwqrEhejVzx1aiVIYqotD5Kolq473i2WLrmLo+xss9ul/OHMo3T5dS67OzqzynK9RjPq1gtwqXlaR5z8sciTfJv79f/dpXF+d+uLP156c+rjZNfcNqMFdWyVZXjdZnyVB1fjfDJdRzV+Cef144D2bqsb2+9+tisGnPa8r774tHxEwf1xD/u1Y4D2erXdZBm35lebfHIU5GmNkWomtQmVk2FI1/lVds4Z/Mt2vqqu3lvtY91UXKerCFVl2Z0fHdUdz5wn9Zt3qTEhIFaOP8F2c+rumaSJDlPnSr7r+O4nGeqzg2rTSxJUouIaqs0jqMO3XnvVK3bsEGJgwZp4V//JnuHap6fy5Azz/1i4LWKU4PmnFOT8mVeVku9K3+Gy7+WMG02BZG2bdt67NuuXTuzXV5cqMmJEydUWlrqVfzo6Gi38f0lRnUMp0vOI8eqfL/WL7ge1CpWqdNtPrWJ4zp+2s2yggAAf+H1GilejFzx1agVr9Za8VLtijTGj9OC3MVSi6qFmnP7+7pII3ks1PiqSJP95U45XRXifFn3Rf+asuBTnV/+eY5Z8MnauM6rOF4Vj75c7bF45KlIU5siVE1qE6umqWG+yqu2cTzldc1D0/S/Xeu8z+kr99/+5W/vV9YP91PWp5/ql3f9sto4th8Kf7a9B2RzU/irTayaVIq1erV+eesvqo91tki2zTvqHyeIc5J8V7itdRwPeTXFiL9SP6sZBfQuM7/97W/1pz/9SZK0adMmJSQkVNt3+fLluvHGGyV5v9PMzp071a9fP0nSAw88oGeffdZj/+joaOXl5VXa4cVfYpwrLCxMJSUlslqs6lihWFTuWH6eikp+rEyHh4YqJqrqdsUWi0U1zQv+Pu+kikp+fPMWHhqm9m2i3fZ1nDgme1v3/whrE8cUapOs9ZtL7XA4ahyZ09j8MSfJ//IyDMNcxdriR+NY/e3nJJFTbfhbXtzn3musnFwul44fP66SkhKFhoaqXbt2srr7XWQYchw96naHnUqxTpxQSXGJQsNC1a5tW/exavD9sWMqKvpxykJ4eLjax1T/ptdTXl7FMgzp8Peec1KpivTj29BwWdS+mr/VGTKUq1J1Vogsbt535KpEFd/QWiV1UqjH61enNrEcKpG9mmNex7FIivH8B6/cY9+p4lt2q8WiTjHnuc/Jw3up2sSpia9y8mVetY3TGD+r2sQxDJdyj32vzjHtZbFU/Xfuj///yMm7nKQ6fpbxQRyff76SoXNLCN5+dpSkI8ePy2W4FBoaquLi6v8g0FgCeoTI8ePHzXZNi6RWPH7mzBmfxy/vk5eXVym+v8Q4l9NZ9hcZ1w8vvDUpKinxqp83ikqKlfN99aNXPB2rTRxf8octoc7ljzlJ/plXbm5uU6dQhT/+nMjJe/6YF/e5dxo7p6KiIh0+fNhjnxwv/98VFRXp8JEjvkhLRUVFNV63Nnl529djHBnKkectZHJV6lUsl1RjLG/VFMvb61Qbx5BUy/czLsPwyXupmuI0RU7exPJlnMb+WXkTx9v33P74/4+cvL+Orz7LeBOnsT9fefPZsfzzaFML6IJIWNiPW8GdPn3aY9+8vDyzHR7u3WJVtYlf8RoV4/tLjHO1aNFCZ8+elc1m03nn1a1iKsmv/hoJAAAAAGhY9Zlk8t1338npdKpFi2rW6mpkAV0QiYz8cY7wiRMnPPateNzbLXdrE7+kpEQFBQVV4vtLjHOV9wEAAAAAIBj5ZqP6JtK+fXuzXVOh4OTJk2a7nZs1Mxoqvr/EAAAAAAAAPwrogkivXr3Mdk3zc49UmHPbu3dvr+Lb7Xa1atWqXvH9JQYAAAAAAPhRQBdE4uPjzfYnn3zise/q1aslSVar1etCgcViMa+xadMmj6MzyuOfm5e/xAAAAAAAAD8K6IJInz59FBsbK0nKyspSSYn7Vb4dDoc2b94sSbr88svVunVrr68xevRoSWXb3mVlZVXb76OPPjLbSUlJfhkDAAAAAACUCeiCiMVi0dixYyVJ+fn5WrVqldt+ixcvNtvjxo2r1TUq9n/jjTfc9jl8+LA5QqVfv37q2bOnX8YAAAAAAABlArogIknTp0+X1Vr2NB544AEdPHiw0vGNGzfqiSeekCRFR0dr6tSptYqfmJioESNGSJLee+89paenVzpeWFiolJQUnT17VpI0Y8YMv40hSR988IFuuOEGxcXFKTw8XF27dtXEiRP1+eefV/cjAAKCy+XSm2++qaSkJHXs2FEtWrRQjx49NGXKFG3durXRYgA1cblc2rFjh5YuXaqXXnpJixcv1pYtW7zews4Xr+P8LkBD+vLLL3XfffepX79+ioqKUqtWrXTJJZfolltuqfaPV+fiPkew4F5Hc+f397jRDPzud78zJBmSjOjoaOP+++83nn76aeOOO+4wwsPDzWOLFi2qcu6iRYvM41dddZXb+Fu2bDEiIiLMfmPGjDH++Mc/GjNmzDC6d+9ufn/UqFFGSUmJX8YoLS01pkyZYvZx93jiiSdq9XMHGtLf/vY3Q5LxyCOP1Ni3oKDAuP7666u9t0NDQ42XXnqpwWMAnrhcLmPRokVG165d3d5j3bp1MxYuXGi4XC635/vidZzfBWho8+fPN6xWq8d77JprrjFyc3Pdns99jkDncrmMCRMmGJKMm2++udp+3Ovwd8OGDfN4b1V8zJw5s8r5gXKPN4uCSGlpqXHnnXdW+0OyWCzGU0895fZcbwoihmEYK1asMFq3bl3tNYYOHWp89913HvNsyhgVi0ZRUVHGvffea/y///f/qhSN/va3v3m8PtBYRowY4VVBxOVyGbfeeqt5D9vtdmP69OnGH//4R2P8+PHmG3OLxWJkZGQ0WAygJg8++KBXbyomTZpkOJ3OKuf74nWc3wVoSMuXL690L48cOdJ4+OGHjaeeesq47bbbjMjISPPY4MGD3f4BiPscge7vf/+7eY95Kohwr8PfdezYsV4FkUC5x5tFQaTc+++/b1x//fVGp06djLCwMOP88883Jk6caKxdu7bac7wtiBiGYXz99dfGAw88YPTs2dNo0aKF0a5dO2Po0KHGggULjOLiYq9ybIoY+/btMz/QdenSxdi/f3+l4+vXrzeLLFFRUcbJkye9ygNoKCtXrjT/XdZUEFmzZo3Zd+DAgcaxY8cqHc/IyDBsNpshyejRo4fbN+C+iAF4UvGeDg0NNZ566ilj69atxqlTp4xNmzYZM2fONMLCwsw+Tz75ZKXzffE6zu8CNCSn02lceOGF5j381ltvVelz4MABo3fv3mafN998s9Jx7nMEui+//LJS4a+6ggj3OvzdqVOnzPv4xhtvNJ5//nmPj//973+Vzg+ke7xZFUTgXmpqqnlDr1ixwm2fZ5991uwzb968Rs4QKHPs2DHj6aefNqKiorwuiFx33XVm3y1btrjt8+tf/9rs88477zRIDMCToUOHmvfPBx984LbP//73PyMkJMSQZERERBhHjx41j/nidZzfBWhIu3btMu+d8ePHV9svMzPT7HfvvfdWOsZ9jkB29uxZIyEhodJfzasriHCvw99t2rTJvHfefvvtWp8fSPc4BZFmzuVyGbGxsYZUtr5KdX/Zdjgc5s105ZVXNnKWCHYTJkyotA5OxYengsipU6fMv6pffPHF1fZbt26dGe/222/3eQzAk++//968d6644opq1wgxDMN4+OGHzb4LFy40DMM3r+P8LkBDqzgKytOb56KiIrPwN2zYMPP73OcIdOV/OImOjvZYEOFeRyB4++23a/xjYXUC7R4P+F1m4NmePXuUk5MjSbr66qsVEhLitl+HDh2UmJgoSVq7dq0KCgoaLUfgo48+0v79+2t93n/+8x8VFxdLkpKTk6vtd8kll6hDhw6SpMzMTJ/HADzZuHGj2b7++utlsViq7ZuUlGS2t2/fLsk3r+P8LkBD27dvn9nu2rVrtf3CwsIUFRUlSTpx4oT5fe5zBLKMjAw9++yzkqSXX37ZY1/udQSCiq/pPXv2rNW5gXaPUxBp5ipuQzxy5EiPfcuPl5aWVvpHADS0V199VW+//bb5SEtL8+o8b+9vq9Vqblt9+PBhnTx50qcxAE++++47s33++ed77Gu32812+Tbqvngd53cBGtr48eO1bt06rVu3ThdffHG1/RwOh44fPy6p8pts7nMEqiNHjuiOO+6QJN111136+c9/7rE/9zoCQfm9Ehsbq8jIyFqdG2j3OAWRZs7hcJjtim+03Sn/67ckXjDRqMaOHauf//zn5uPaa6/16ry63t9fffWVT2MAnlx00UX605/+pD/96U+64oorPPbdsmWL2e7Ro4ck37yO87sADS02NlaDBw/W4MGD1aJFC7d9Tp8+rSlTpphfT5482WxznyMQuVwu3XHHHfruu+/Uu3dvc5SIJ9zrCAR79+6VJPXq1Utffvmlbr/9dvXr108RERE677zzdNVVV+nZZ5/VmTNnqpwbaPe4+7EnaDYq3kxt27b12Lddu3Zm++jRow2WE+Arvri/+TeChta/f3/179+/xn4lJSX6y1/+Yn49dOhQSdznCFyHDh3Sa6+9puPHj+ubb77RqlWrzDfP999/v2644QazL/c5AtFf/vIXffzxxwoNDdVbb72lli1b1ngO9zoCQXlhYevWrerXr59cLpd57OzZs/rss8/02Wef6c9//rOWLVumwYMHm8cD7R6nINLMVbyZoqOjPfateLO5q/YB/sYX9zf/RuAPSktLNWXKFG3evFmSdOWVV+qyyy6TxH2OwLVv3z499thjlb5ntVq1aNEi3XbbbZXW0+E+R6DZsGGDeX/PnTtXl1xyiVfnca/D3xUUFCg3N1eSdPz4cVmtVl1//fW69NJL5XK5tG3bNn388cfKz8/XoUOH9JOf/ETr169Xr169JAXePU5BpJkrn6crqcaqdcXjvGAiEPji/ubfCJra7t27NXnyZH3xxReSpNatW+u5554zj3OfozlxuVy67777dOTIET388MNmUYT7HIHk1KlTmjhxokpKSpSUlKTf/OY3Xp/LvQ5/9/XXX5vtmJgYvffee1Wm/B46dEi33367PvnkE+Xn5+vee+81Nx0ItHucNUSaubCwMLN9+vRpj33z8vLMdnh4eIPlBPiKL+5v/o2gqZw8eVLTp0/XRRddZBZDWrRooX/+858aMGCA2Y/7HIFqxIgRMgxDp0+f1pYtW/SnP/1J0dHROnXqlB555BH9/ve/N/tynyOQTJs2TXv37lX79u316quvymr1/iMV9zr8XcuWLTV37lzNnTtXWVlZbtc/i4uL0zvvvGNOV8nKytKOHTskBd49TkGkmau4KnDF7e3cqXjcmzmQQFPzxf3NvxE0NsMw9NZbb6lXr1565plnVFpaKqlsa+eNGzdW2npX4j5H4GvZsqX69++vhx56SOvWrTPvx7lz5+r777+XxH2OwPHWW2/p1VdflSQtWrRInTp1qtX53OvwdxdccIFmzJihGTNmKCEhodp+7dq1qzQ6qnyESKDd4xREmrn27dub7ZpuporbiFZcnAbwV764v/k3gsb0/fffa8KECfrFL35hfhBs06aN5s2bpy+++EJ9+/atcg73OZqTnj17KjU1VVLZwnz/+te/JHGfIzCcOHFC99xzjyQpNTVV119/fa1jcK+jOalYMDlw4ICkwLvHKYg0c+WL20jS4cOHPfY9cuSI2e7du3eD5QT4ii/ub/6NoLHs27dPF198sd555x1Jks1m03333ad9+/bpwQcfrDQ8tCLucwSCzz77TB9++KHWrl1bY99BgwaZ7W+//VYS9zkCQ15envLz8yVJaWlpslgsbh/llixZYn6vW7dukrjX0bx0797dbBcWFkoKvHucgkgzFx8fb7Y/+eQTj31Xr14tqWwFeF4wEQi8vb+dTqfWrFkjqWyv8piYGJ/GAGry3XffKTk52fyl3adPH33xxRd6/vnnK/0VxB1fvI7zuwANbcaMGUpOTtYvfvGLGvtWXG+h/MMj9zmCBfc6/N0333yjAwcOVCo0VKd8NxpJOu+88yQF3j3OLjPNXJ8+fRQbG6ucnBxlZWWppKREoaGhVfo5HA5zu8fLL79crVu3buRMgdobPny4wsLCVFxcrA8//FB//vOf3fbbsGGDuVr1uesz+CIGUJM777xT+/btk1R2/yxbtszrea6+eB3ndwEaWo8ePfTFF1/o22+/VXFxcbUjniRp586dZvv888+XxH2OwNCuXTs9//zzNfabNm2aJGngwIG68847Jcm8z7jX4e8mTpyoL774QjExMcrJyfG4UOn27dvNdvnW04F2jzNCpJmzWCwaO3asJCk/P1+rVq1y22/x4sVme9y4cY2RGlBvrVq10ujRoyWVvcHetGmT235vvfWW2T73/vZFDMCTgwcPmq+9ffv21YoVK2q16JcvXsf5XYCG1qNHD0ll2+r+4x//qLZfQUGBFi1aJKnsr3kjR46UxH2OwBAVFaX77ruvxke53r17m9+74447JHGvw//dfPPNkqRjx47ptddeq7ZfQUGBnnnmGUlli6COGjVKUgDe4waavX379hlWq9WQZHTp0sX45ptvKh3fsGGDERUVZUgyoqOjjby8vCbKFCizf/9+Q5IhyXjkkUc89l2zZo3ZNyEhwTh+/Hil4x9++KFhs9kMSUavXr2M0tLSBokBVOfJJ58076933nmnTjF88TrO7wI0pHXr1pn3ud1uN/773/9W6XP8+HFj/PjxZr/bb7+90nHuczQX5ff4zTff7PY49zr8WU5OjhEeHm5IMiIiIoxPPvmkSp+jR48aY8eONe/13/72t5WOB9I9bjEMw6hbKQWB5PHHH9ecOXMkSdHR0br99tsVFxenHTt2aPHixSoqKpJUtn1YSkpKE2YKlK1SXb5I0yOPPKI//vGP1fY1DEO33367Xn/9dUlSp06ddNtttykmJkbr16/Xu+++K6fTKavVqo8++sgcDeLrGEB1br75Zi1dulSS9NRTTykqKsqr837yk59U2nXGF6/j/C5AQxo/fry5aLDVatX111+vfv36qVWrVvryyy/14Ycf6rvvvpMkdenSRdnZ2bLb7ZVicJ+jOShfG+fmm2+u9BfsirjX4c/S09M1efJk8+trrrlGgwcPVnh4uHbu3KmPPvrInEp+ySWX6PPPP1dERESlGAFzj9epjIKAU1paatx5551mFe/ch8ViMZ566qmmThMwDKN2I0QMwzAKCgqMa6+9ttr7Ozw83Fi0aFGDxwDcGTFiRLX3lafHufebL17H+V2AhpSXl2dcffXVNd7bgwcPNr7++mu3MbjP0RyU32vVjRAxDO51+L/Zs2cboaGhHl/Pr7nmmiojq8sFyj1OQSTIvP/++8b1119vdOrUyQgLCzPOP/98Y+LEicbatWubOjXAVNuCiGEYhtPpNF577TVj5MiRxnnnnWeEhYUZ3bp1M6ZMmWJs37690WIA54qPj/dJQaScL17H+V2AhlJaWmq8++67xq233mpceumlRrt27Yzw8HDj/PPPN8aPH2+88847Xk075D5HIPOmIFKOex3+bP/+/cavfvUr49JLLzXfG8fFxRk333yz8cEHHxgul6vGGP5+jzNlBgAAAAAABB12mQEAAAAAAEGHgggAAAAAAAg6FEQAAAAAAEDQoSACAAAAAACCDgURAAAAAAAQdCiIAAAAAACAoENBBAAAAAAABB0KIgAAAAAAIOhQEAEAAAAAAEGHgggAAAAAAAg6FEQAAAAAAEDQoSACAAAAAACCDgURAAAAAAAQdEKaOgEAAAAAABpDRkaGFixYoA0bNqiwsFADBgzQAw88oHHjxjVJPoZhaOvWrdq9e7dyc3N19uxZxcTEqG/fvho8eLBatGjRJHkFC0aIAAAAAACavVmzZunaa6/VBx98oPPOO08dO3bUmjVrdOONN+p3v/tdneNaLJYqj5oKLAUFBZo9e7Z69OihhIQE3XzzzfrNb36jRx99VFOnTtXw4cPVrl07TZ06Vfv3769zbjVxOp3q3Lmzmfe+fftqdf7cuXPNcx955BFJ0po1a9z+TNLT0xvgGdQPBREAAAAAQLO2fv16zZ49W3369NH27du1efNm7dy5U//5z39kt9v11FNP6fPPP2+UXFavXq34+HjNmjWrUrEjJCREoaGh5teFhYV6+eWXdfHFF+vVV19tkFxsNptuvvlm8+u33367Vue/++67ZnvChAk+y6uxUBABAAAAADRrs2bNkiS98cYb6tOnj/n9oUOHav78+ZKkv/71r/W6RnJysp5//nk9//zzmjJlits+77//vpKTk3Xw4EFJUu/evfXCCy/om2++0dmzZ3XmzBnt3r1b//jHP9S7d29JZaNJUlJStGjRonrlV52JEyea7aVLl3p93rfffqv169dLki644AJdcsklkqRevXqZP4fyn7u/shiGYTR1EgAAAAAANJSOHTsqMjJSX3/9dZVjp0+fVlRUlC644IJaTxmRyqbMSNLMmTM9FgB27typSy65REVFRZKk6dOn6w9/+IPCw8Pd9i8pKdHMmTM1d+5cSVKLFi20adOmSgUdXzAMQz179jR/Nrt37zaLMZ48//zzuv/++yVJM2bMMPOs6MCBA+revbskadGiRUpJSfFd4j7ACBEAAAAAQLN16tQpORwO7d+/3+3aFq1bt5ZhGPr+++8bLAen06nJkyebxZCHHnpI8+bNq7YYIkmhoaF66qmnzCLC2bNnNXv2bJ/nZrFYKo0S8XbazLJly8x2IE6XkRghAgAAAABoxk6cOKF27dopOjpal156abX9bDabVq1aVev43owQWb58uW688UZJUkJCgrKzsyutF+LJiRMn1KlTJxUVFclms8nhcCgmJqbWeXqyY8cOXXTRRZKk/v37a8uWLR77Hzt2THa7XU6nUz179tSePXvMn0NFjBABAAAAAKCO0tPTZbFY1L59e0lScXGxXnjhBV166aWKjo5Wq1atdNFFF+mRRx7R4cOHq5zftm1btWvXTu3bt9eHH35Y7aMuxRBvpaWlme2nnnrK62KIVJb/TTfdJKlspMmaNWvc9nO5XFq8eLFuuOEGxcbGKjw8XN26dVNSUpJef/11FRcXV3uNfv366eKLL5Ykbd26VV9++aXHnFauXCmn0ympbHSIu2JIIKAgAgAAAAAICEePHtWVV16padOmKTs7W3l5eSooKNCOHTv09NNPq0+fPsrIyKhy3sUXX6yvv/5aX331VZVjO3bs0Lhx4/Tss882SM55eXn617/+JUnq0qWLfvrTn9Y6xptvvinDMGQYhn72s59VOX706FENHz5cEydO1MqVK5Wbm6vi4mJ98803ysrK0m233aaLLrrI4xoptZk2E+i7y5SjIAIAAAAA8HtOp1M333yz/ve//6lly5YaO3asfv/73+v2229XXFycJCk/P1/jxo3Thg0bKp372GOPyeVy6bbbbtO3335rfv/o0aO688479d577+mCCy5okLy/+OILla9UMWrUKNlsNp/GP3PmjEaNGqW1a9dKkrp166YpU6Zo7ty5uuuuu9StWzdJ0t69e3X55Zfrm2++cRvnlltuMduedps5ffq0Pv74Y0llu+T079/fR8+k8YU0dQIAAAAAANTk5MmTWrNmjc4//3x9+OGHio+PN4+dPn1at99+u5YtW6bi4mLdc889ys7ONqdyXH311br77rv10ksvqVevXurXr5/CwsK0adMmFRUVaerUqRozZkyD5F1xPY7ExESfx3/iiSe0Y8cOSdIjjzyiWbNmqUWLFubxs2fP6vHHH9e8efP0/fff68EHH9Q777xTJU737t112WWX6b///a+2b9+unTt3VvoZl/vwww/NxWEDebqMxAgRAAAAAEAAWblyZZUP6q1atdI777xjroOxfv16/fe//63U58UXX9Rbb72lK6+8Ut9++6327NmjwYMH66233tKCBQsa7IP9sWPHzLbdbvdp7JMnT2rBggWSpJ/97GeaO3dupWKIVLZd79NPP20u6vrPf/7T7dQhybtpM81hd5lyFEQAAAAAAAEhOTlZAwYMcHvMarXq//7v/8yvV6xYUaXPLbfcoo8//lhHjx7VsWPH9Pnnn+uWW26R1dpwH41PnDhhtqOiojz2feihh9xuDVzxMWLECLN/RkaGzpw5U+lcdywWi6ZPn25+/e9//9ttvwkTJpg/iyVLlujcTWmLi4vNxWcvvPBCc2eaQMWUGQAAAABAQCjfbaU6Y8eONdvr169v6HS8EhERYbbLixe+8sUXX5jt//73vx6fc8Vrb9u2zW2fjh07auTIkfrXv/6lXbt2VdqOV5I++eQT5eXlSQr86TISBREAAAAAQIDo3r27x+MtWrRQ586dlZubq9zc3EbKyrOYmBiz/f3333vsO27cOHMR1HPNnz+/yi4xhw4dMtu/+c1vvM4pPz+/2mMTJ040d8VZunRppYJIc9ldphwFEQAAAABAQOjcuXONfeLi4pSbm2uOZGhqXbt2NdubN2/22HfYsGEaNmyY22Ovvvpqle95Kmx44um8m266Sb/61a9UUlKipUuXavbs2bJYLHK5XHrvvfckSX379lW/fv3qdG1/whoiAAAAAICAUHGB0uocOXJEUtlCq5I0a9asGtflqG6NDl8YPny42V6zZk2VdTm8YRhGpdEg5SIjIyVJ4eHhcjqdMgzDq8eSJUuqvVbbtm2VnJwsSdq9e7c5veaLL76Qw+GQ1Dymy0iMEAEAAAAABIgDBw5UO4JCkoqKivTtt99Kkjp06CBJ6tmzp376059W6peTk6Pt27erc+fO5s405fr37+/TnC+44AJ1795d+/fv1/bt27V+/fpab7+7e/dus9BTUfmuNUVFRTp06JC6dOnik5wnTpxoLkq7dOlS9e/fv9LuMuPHj/fJdZoaI0QAAAAAAAGhfG2L6mRkZJgjMMqLDrfeeqs+/PDDSo8HH3xQkpSUlFTl2NNPP+3TnC0Wi1JTU82vn3jiiVqPEnn++efdfn/IkCFme8OGDR5jfPnll5o1a5ZmzZpV7ba75caMGWOOPlm6dKkMwzALIv369WsW02UkCiIAAAAAgADx+uuv68CBA26PuVwuzZ492/z6uuuua6SsanbXXXeZi6t++OGH1RY43Pn3v/+tv/3tb26PXXPNNeY2uTNnzlRpaWm1cR5//HHNnj1b8+bNU8eOHT1es2XLluaOPXv37tVrr72mr7/+WlLzWEy1HAURAAAAAEBAKC0t1Q033KBvvvmm0vcLCgo0YcIEc9HS/v37a+TIkU2QoXtt2rTR3//+d/PrBx54QP/v//0/OZ1Oj+dlZWVp7Nix1RY6zj//fLNAsW3bNk2ZMkWnT5+u1McwDP35z3/WO++8I6lsukvLli1rzHnixIlm+9e//rXZbi7TZSTWEAEAAAAABIj27dtr27ZtSkhI0E9/+lNdfPHF2rt3r1avXm2uHRIaGqq///3vfrfo57hx48wpK5I0Y8YMvfXWW7r33nt17bXXqlOnTrLZbDpz5ow+//xzvfLKK1q6dKkk6eqrr1ZkZKSWL19eJe6zzz6rNWvW6MiRI0pPT9e//vUvjR49WhdeeKFOnDihjIwMbd26VVLZeirz5s3zKt+f/vSnatu2rU6cOKETJ05Iki6++GL17du3/j8MP0FBBAAAAAAQEN555x1NmTJFe/fu1ZIlS6rslhIVFaXFixfXetHSxjJz5kzFxMTooYceUlFRkbZs2aK7775bkmSz2RQREVFlhMfkyZP14osvauHChW4LIna7XZ9++qmuv/567d27V99++60WLVpUpV///v21dOlSc+pOTcLCwvSzn/2s0siW5jRdRmLKDAAAAAAgQHTt2lWbN2/WU089pf79+6tVq1aKiIhQ37599fDDD2v37t3mlrH+6r777tOuXbs0adIkc+FSSXI6nWYxxGKx6Morr9Snn36qhQsXKiwsrNL2vefq3bu3tm3bpgULFmjUqFE677zzFBYWpp49e+q6667Tq6++qo0bN+rCCy+sVa6/+MUvKn3dnKbLSIwQAQAAAAAEkMjISD322GN67LHHmjqVOuvevbtef/11FRYW6rPPPtPBgwf13XffKSoqSp06ddLw4cPNbYPL9evXz+PuNOHh4brnnnt0zz33+CzPkSNH1npHnEBCQQQAAAAAgCYQERGhn/70p02dRtBiygwAAAAAAAg6FEQAAAAAAEDQYcoMAAAAAAD1lJ2drRdeeEFS2Roh1113XRNn1DRycnK0bNkySdKxY8eaOBvPKIgAAAAAAFBPGRkZysjIkCSNHTs2aAsie/fu1bRp05o6Da8wZQYAAAAAAAQdRogAAAAAAPxWSkqKUlJSmjqNajXnbWnrYsSIEQHzM7EYgZIpAAAAAACAjzBlBgAAAAAABB0KIgAAAAAAIOhQEAEAAAAAAEGHgggAAAAAAAg6FEQAAAAAAEDQoSACAAAAAACCDgURAAAAAAAQdCiIAAAAAACAoENBBAAAAAAABB0KIgAAAAAAIOhQEAEAAAAAAEGHgggAAAAAAAg6/x/xbsGZ02kt4QAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 1200x900 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "year = \"2018\"\n",
+    "shape.build_stacks(year, 'SingleEle_1b')\n",
+    "shape.plot_data(year)\n",
+    "shape.plot_mc()\n",
+    "plt.show()\n",
+    "plt.close()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "978aed30-052c-4bfe-844e-cbb572338b54",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.15"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/pocket_coffea/parameters/plotting.py b/pocket_coffea/parameters/plotting.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ab6c7b4e682bf65a51cfaa42d8e4dad7fdb8272
--- /dev/null
+++ b/pocket_coffea/parameters/plotting.py
@@ -0,0 +1,93 @@
+hatch_density = 4
+
+style_cfg = {
+    "fontsize" : 22,
+    "fontsize_legend_ratio" : 12,
+    "opts_figure" : {
+        "datamc" : {
+            'figsize' : (12,9),
+        },
+        "datamc_ratio" : {
+            'figsize' : (12,12),
+            'gridspec_kw' : {"height_ratios": (3, 1)},
+            'sharex' : True,
+        },
+        "partial" : {
+            'figsize' : (12,15),
+            'gridspec_kw' : {"height_ratios": (3, 1)},
+            'sharex' : True,
+        },
+    },
+    "opts_mc" : {
+        'histtype': 'fill',
+        'stack' : True
+    },
+    "opts_data" : {
+        'linestyle': 'solid',
+        'linewidth': 0,
+        'marker': '.',
+        'markersize': 5.0,
+        'color': 'black',
+        'elinewidth': 1,
+        'label': 'Data',
+    },
+    "opts_unc" : {
+        "total" : {
+            "step": "post",
+            "color": (0, 0, 0, 0.4),
+            "facecolor": (0, 0, 0, 0.0),
+            "linewidth": 0,
+            "hatch": '/' * hatch_density,
+            "zorder": 2,
+        },
+        'Up': {
+            'linestyle': 'dashed',
+            'linewidth': 1,
+            'marker': '.',
+            'markersize': 1.0,
+            #'color': 'red',
+            'elinewidth': 1,
+        },
+        'Down': {
+            'linestyle': 'dotted',
+            'linewidth': 1,
+            'marker': '.',
+            'markersize': 1.0,
+            #'color': 'red',
+            'elinewidth': 1,
+        },
+    },
+    "opts_syst" : {
+        'nominal': {
+            'linestyle': 'solid',
+            'linewidth': 1,
+            'color': 'black',
+        },
+        'up': {
+            'linestyle': 'dashed',
+            'linewidth': 1,
+            'color': 'red',
+        },
+        'down': {
+            'linestyle': 'dotted',
+            'linewidth': 1,
+            'color': 'blue',
+        },
+    },
+    "samples_map": {},
+    "labels": {
+        "ttHTobb": "$t\\bar{t}H\\rightarrow b\\bar{b}$",
+        "TTToSemiLeptonic": "$t\\bar{t}$ semilep.",
+        "TTTo2L2Nu" : "$t\\bar{t}$ dilepton",
+        "SingleTop" : "Single t",
+        "WJetsToLNu_HT" : "W+jets",
+    },
+    "colors" : {
+        'ttHTobb': 'pink',
+        'TTTo2L2Nu': (0.51, 0.79, 1.0),  # blue
+        'TTToSemiLeptonic': (1.0, 0.71, 0.24),  # orange
+        'SingleTop' : (1.0, 0.4, 0.4), #red
+        'ST' : (1.0, 0.4, 0.4), #red
+        'WJetsToLNu_HT' : '#cc99ff', #violet
+    }
+}
diff --git a/pocket_coffea/utils/plot_utils.py b/pocket_coffea/utils/plot_utils.py
index 00c0d4ab1d0aba6f56830b1a7359126b9b88493d..de39bc9cd91c5efe24e177ca3d414a1d188db32f 100644
--- a/pocket_coffea/utils/plot_utils.py
+++ b/pocket_coffea/utils/plot_utils.py
@@ -1,11 +1,10 @@
 import os
-import sys
+from copy import deepcopy
 
 import math
 import numpy as np
 import awkward as ak
 import hist
-from coffea.util import load
 
 import matplotlib.pyplot as plt
 from matplotlib.pyplot import cm
@@ -13,888 +12,602 @@ from matplotlib.ticker import MultipleLocator, AutoMinorLocator
 import mplhep as hep
 
 from ..parameters.lumi import lumi, femtobarn
-
-fontsize = 22
-fontsize_legend_ratio = 12
-plt.style.use([hep.style.ROOT, {'font.size': fontsize}])
-plt.rcParams.update({'font.size': fontsize})
-
-opts_figure = {
-    "total" : {
-        'figsize' : (12,12),
-        'gridspec_kw' : {"height_ratios": (3, 1)},
-        'sharex' : True,
-    },
-    "partial" : {
-        'figsize' : (12,15),
-        'gridspec_kw' : {"height_ratios": (3, 1)},
-        'sharex' : True,
-    },
-}
-
-opts_data = {
-    'linestyle': 'solid',
-    'linewidth': 0,
-    'marker': '.',
-    'markersize': 5.0,
-    'color': 'black',
-    'elinewidth': 1,
-    'label': 'Data',
-}
-
-hatch_density = 4
-opts_unc = {
-    "total" : {
-        "step": "post",
-        "color": (0, 0, 0, 0.4),
-        "facecolor": (0, 0, 0, 0.0),
-        "linewidth": 0,
-        "hatch": '/' * hatch_density,
-        "zorder": 2,
-    },
-    'Up': {
-        'linestyle': 'dashed',
-        'linewidth': 1,
-        'marker': '.',
-        'markersize': 1.0,
-        #'color': 'red',
-        'elinewidth': 1,
-    },
-    'Down': {
-        'linestyle': 'dotted',
-        'linewidth': 1,
-        'marker': '.',
-        'markersize': 1.0,
-        #'color': 'red',
-        'elinewidth': 1,
-    },
-}
-
-opts_unc_total = {
-    'Up': {
-        'linestyle': 'dashed',
-        'linewidth': 1,
-        'marker': '.',
-        'markersize': 1.0,
-        'color': 'gray',
-        'elinewidth': 2,
-    },
-    'Down': {
-        'linestyle': 'dotted',
-        'linewidth': 1,
-        'marker': '.',
-        'markersize': 1.0,
-        'color': 'gray',
-        'elinewidth': 2,
-    },
-}
-
-opts_sf = {
-    'nominal': {
-        'linestyle': 'solid',
-        'linewidth': 1,
-        'marker': '.',
-        'markersize': 1.0,
-        'color': 'red',
-        'elinewidth': 1,
-    },
-    'Up': {
-        'linestyle': 'dashed',
-        'linewidth': 1,
-        'marker': '.',
-        'markersize': 1.0,
-        'color': 'red',
-        'elinewidth': 1,
-    },
-    'Down': {
-        'linestyle': 'dotted',
-        'linewidth': 1,
-        'marker': '.',
-        'markersize': 1.0,
-        'color': 'red',
-        'elinewidth': 1,
-    },
-}
-
-opts_errorbar = {
-    'nominal': {'linestyle': 'solid'},
-    'Up': {'linestyle': 'dashed'},
-    'Down': {'linestyle': 'dotted'},
-}
-
-# Flavor ordering by stats, dependent on plot scale
-flavors_order = {
-    'linear': ['l', 'bb', 'cc', 'b', 'c'],
-    'log': ['c', 'b', 'cc', 'bb', 'l'],
-}
-# Color scheme for l, c+cc, b+bb
-colors_bb = ['blue', 'magenta', 'cyan']
-colors_cc = ['blue', 'cyan', 'magenta']
-colors_5f = {
-    'l': (0.51, 0.79, 1.0),  # blue
-    'c': (1.0, 0.4, 0.4),  # red
-    'b': (1.0, 0.71, 0.24),  # orange
-    'cc': (0.96, 0.88, 0.40),  # yellow
-    'bb': (0.51, 0.91, 0.51),  # green
-}
-
-colors_tthbb = {
-    'ttHTobb': 'pink',
-    'TTTo2L2Nu': (0.51, 0.79, 1.0),  # blue
-    'TTToSemiLeptonic': (1.0, 0.71, 0.24),  # orange
-    'SingleTop' : (1.0, 0.4, 0.4), #red
-    'ST' : (1.0, 0.4, 0.4), #red
-    'WJetsToLNu_HT' : '#cc99ff', #violet
-}
-
-
-def slice_accumulator(accumulator, entrystart, entrystop):
-    '''Returns an accumulator containing only a reduced set of histograms, i.e. those between the positions `entrystart` and `entrystop`.'''
-    _accumulator = dict([(key, value) for key, value in accumulator.items()])
-    _accumulator['variables'] = dict(
-        [(key, value) for key, value in accumulator['variables'].items()][
-            entrystart:entrystop
-        ]
-    )
-    return _accumulator
-
-
-def dense_dim(h):
-    '''Returns the number of dense axes of a histogram.'''
-    dense_dim = 0
-    if type(h) == dict:
-        h = h[list(h.keys())[0]]
-    for ax in h.axes:
-        if not type(ax) in [hist.axis.StrCategory, hist.axis.IntCategory]:
-            dense_dim += 1
-    return dense_dim
-
-
-def dense_axes(h):
-    '''Returns the list of dense axes of a histogram.'''
-    dense_axes = []
-    if type(h) == dict:
-        h = h[list(h.keys())[0]]
-    for ax in h.axes:
-        if not type(ax) in [hist.axis.StrCategory, hist.axis.IntCategory]:
-            dense_axes.append(ax)
-    return dense_axes
-
-
-def stack_sum(stack):
-    '''Returns the sum histogram of a stack (`hist.stack.Stack`) of histograms.'''
-    if len(stack) == 1:
-        return stack[0]
-    else:
-        htot = stack[0]
-        for h in stack[1:]:
-            htot = htot + h
-        return htot
-
-
-def get_axis_items(h, axis_name):
-    axis = h.axes[axis_name]
-    return list(axis.value(range(axis.size)))
-
-
-def get_index(h, edges):
-    indices = []
-
-    for edge in edges:
-        indices.append(np.where(np.isclose(h.axes[-1].edges, edge, atol=0.01))[0][0])
-    return indices
-
-
-def rebin_histogram(h, index):
-    values = [
-        np.sum(h.values()[start:stop]) for start, stop in zip(index[:-1], index[1:])
-    ]
-    variances = [
-        np.sum(h.variances()[start:stop]) for start, stop in zip(index[:-1], index[1:])
-    ]
-    edges = [h.axes[-1].edges[i] for i in index]
-    nh = hist.new.Var(edges, name=h.axes[-1].name, label=h.axes[-1].label).Weight()
-    nh[...] = np.stack([values, variances], axis=-1)
-
-    return nh
-
-
-def rebin_stack(stack, index):
-    histos_rebinned = {}
-    for i, h in enumerate(stack):
-        # print(type(rebin(h, index)))
-        histos_rebinned[h.name] = rebin_histogram(h, index)
-
-    return hist.Stack.from_dict(histos_rebinned)
-
-
-def rebin(h, edges):
-    index = get_index(h, edges)
-    if type(h) == hist.stack.Stack:
-        return rebin_stack(h, index)
-    elif type(h) == hist.hist.Hist:
-        return rebin_histogram(h, index)
-
-
-def get_data_mc_ratio(h1, h2):
-    if type(h1) == hist.Stack:
-        h1 = stack_sum(h1)
-    if type(h2) == hist.Stack:
-        h2 = stack_sum(h2)
-    num = h1.values()
-    den = h2.values()
-    ratio = num / den
-    #ratio[ratio == 0] = np.nan
-    #ratio[np.isinf(ratio)] = np.nan
-    unc = np.sqrt(num) / den
-    unc[np.isnan(unc)] = np.inf
-
-    return ratio, unc
-
-
-def get_systematic_uncertainty(
-    stack_mc, variations, mcstat=True, stat_only=False, edges=None
-):
-    '''This function computes the total systematic uncertainty on the MC stack, by summing in quadrature the systematic uncertainties of the single MC samples.
-    For each MC sample, the systematic uncertainty is computed by summing in quadrature all the systematic uncertainties.
-    The asymmetric error band is constructed by summing in quadrature uncertainties that are moving the nominal value in the same direction, i.e. the total "up" uncertainty is obtained by summing in quadrature all the systematic effects that are pulling the nominal value up.'''
-    if stack_mc[0].ndim != 2:
-        raise Exception(
-            "Only histograms with a dense axis and the variation axis are allowed as input."
-        )
-    if type(variations) == str:
-        variations = [variations]
-
-    systematics = [s.split("Up")[0] for s in variations if 'Up' in s]
-
-    nom_template = stack_mc[0][{'variation': 'nominal'}]
-    if edges:
-        nom_template = rebin(nom_template, edges)
-
-    syst_err2_up_dict = {}
-    syst_err2_down_dict = {}
-    if not stat_only:
-        syst_err2_up_dict = {syst : 0.0 for syst in systematics}
-        syst_err2_down_dict = {syst : 0.0 for syst in systematics}
-        #syst_err2_tot_up = np.zeros_like(nom_template.values())
-        #syst_err2_tot_down = np.zeros_like(nom_template.values())
-    if mcstat:
-        syst_err2_up_dict.update({"mcstat" : 0.0})
-        syst_err2_down_dict.update({"mcstat" : 0.0})
-    for h in stack_mc:
-        sample = h.name
-        nom = h[{'variation': 'nominal'}]
-        if edges:
-            nom = rebin(nom, edges)
-        syst_err2_up = np.zeros_like(nom.values())
-        syst_err2_down = np.zeros_like(nom.values())
-        if not stat_only:
-            for syst in systematics:
-                systUp = f"{syst}Up"
-                systDown = f"{syst}Down"
-
-                # Compute the uncertainties corresponding to the up/down variations
-                varUp = h[{'variation': systUp}]
-                varDown = h[{'variation': systDown}]
-                if edges:
-                    varUp = rebin(varUp, edges)
-                    varDown = rebin(varDown, edges)
-                errUp = varUp.values() - nom.values()
-                errDown = varDown.values() - nom.values()
-
-                # Compute the flags to check which of the two variations (up and down) are pushing the nominal value up and down
-                up_is_up = errUp > 0
-                down_is_down = errDown < 0
-                # Compute the flag to check if the uncertainty is one-sided, i.e. when both variations are up or down
-                is_onesided = (up_is_up ^ down_is_down)
-
-                # Sum in quadrature of the systematic uncertainties
-                # N.B.: valid only for double sided uncertainties
-                syst_err2_up_twosided = np.where(up_is_up, errUp**2, errDown**2)
-                syst_err2_down_twosided = np.where(up_is_up, errDown**2, errUp**2)
-                syst_err2_max = np.maximum(syst_err2_up_twosided, syst_err2_down_twosided)
-                syst_err2_up_onesided = np.where(is_onesided & up_is_up, syst_err2_max, 0)
-                syst_err2_down_onesided = np.where(is_onesided & down_is_down, syst_err2_max, 0)
-                syst_err2_up_combined = np.where(is_onesided, syst_err2_up_onesided, syst_err2_up_twosided)
-                syst_err2_down_combined = np.where(is_onesided, syst_err2_down_onesided, syst_err2_down_twosided)
-
-                syst_err2_up_dict[syst] += syst_err2_up_combined
-                syst_err2_down_dict[syst] += syst_err2_down_combined
-
-        # Add in quadrature the MC statistical uncertainty
-        if mcstat:
-            mcstat_err2 = nom.variances()
-            #syst_err2_up += mcstat_err2
-            #syst_err2_down += mcstat_err2
-            syst_err2_up_dict["mcstat"] += mcstat_err2
-            syst_err2_down_dict["mcstat"] += mcstat_err2
-
-        # Sum in quadrature of the systematic uncertainties for each MC sample
-        #syst_err2_tot_up += syst_err2_up
-        #syst_err2_tot_down += syst_err2_down
-
-    #return np.sqrt(syst_err2_tot_up), np.sqrt(syst_err2_tot_down)
-    return syst_err2_up_dict,  syst_err2_down_dict
-
-
-def plot_uncertainty_band(h_mc_sum, syst_err2_up, syst_err2_down, ax, ratio=False):
-    '''This function computes and plots the uncertainty band as a hashed gray area.
-    To plot the systematic uncertainty in a ratio plot, `ratio` has to be set to True and the uncertainty band will be plotted around 1 in the ratio plot.'''
-    nom = h_mc_sum.values()
-    # Sum in quadrature of the systematic uncertainties for each variation
-    up = nom + np.sqrt(sum(syst_err2_up.values()))
-    down = nom - np.sqrt(sum(syst_err2_down.values()))
-
-    if ratio:
-        # In order to get a consistent uncertainty band, the up/down variations of the ratio are set to 1 where the nominal value is 0
-        up = np.where(nom != 0, up / nom, 1)
-        down = np.where(nom!=0, down / nom, 1)
-
-    unc_band = np.array([down, up])
-
-    ax.fill_between(
-        h_mc_sum.axes[0].edges,
-        np.r_[unc_band[0], unc_band[0, -1]],
-        np.r_[unc_band[1], unc_band[1, -1]],
-        **opts_unc['total'],
-        label="syst. unc.",
-    )
-    if ratio:
-        ax.hlines(1.0, *ak.Array(h_mc_sum.axes[0].edges)[[0,-1]], colors='gray', linestyles='dashed')
-
-def plot_systematic_uncertainty(
-    stack_mc_nominal, syst_err2_up, syst_err2_down, ax, ratio=False, split_systematics=False, only_syst=[], partial_unc_band=False,
-):
-    '''This function plots the asymmetric systematic uncertainty band on top of the MC stack, if `ratio` is set to False.
-    To plot the systematic uncertainty in a ratio plot, `ratio` has to be set to True and the uncertainty band will be plotted around 1 in the ratio plot.'''
-    if (not type(syst_err2_up) == dict) or (not type(syst_err2_down) == dict):
-        raise Exception("`syst_err2_up` and `syst_err2_down` must be dictionaries")
-
-    h_mc_sum = stack_sum(stack_mc_nominal)
-    nom = h_mc_sum.values()
-
-    if only_syst:
-        syst_err2_up_filtered = { syst : unc for syst, unc in syst_err2_up.items() if any(key in syst for key in only_syst)}
-        syst_err2_down_filtered = { syst : unc for syst, unc in syst_err2_down.items() if any(key in syst for key in only_syst)}
-    else:
-        syst_err2_up_filtered = syst_err2_up
-        syst_err2_down_filtered = syst_err2_down
-
-    if not split_systematics:
-        plot_uncertainty_band(h_mc_sum, syst_err2_up_filtered, syst_err2_down_filtered, ax, ratio)
-    else:
-        if syst_err2_up_filtered.keys() != syst_err2_down_filtered.keys():
-            raise Exception("The up and down uncertainties comes from different systematics. `syst_err2_up_filtered` and `syst_err2_down_filtered` must have the same keys.")
-
-        axis_x = h_mc_sum.axes[0]
-        edges_x = axis_x.edges
-        binwidth_x = np.ediff1d(edges_x)
-        x = edges_x[:-1] + 0.5 * binwidth_x
-        xerr = 0.5 * binwidth_x
-
-        if partial_unc_band:
-            # Sum in quadrature of the systematic uncertainties for each variation
-            up_tot = nom + np.sqrt(sum(syst_err2_up_filtered.values()))
-            down_tot = nom - np.sqrt(sum(syst_err2_down_filtered.values()))
-            label = "partial"
+from ..parameters.plotting import style_cfg
+
+
+class Style:
+    '''This class manages all the style options for Data/MC plots.'''
+    def __init__(self, style_cfg=style_cfg) -> None:
+        required_keys = ["opts_figure", "opts_mc", "opts_data", "opts_unc"]
+        for key in required_keys:
+            assert key in style_cfg, f"The key `{key}` is not defined in the style dictionary."
+        for key, item in style_cfg.items():
+            setattr(self, key, item)
+        self.has_labels = False
+        self.has_samples_map = False
+        if "labels" in style_cfg:
+            self.has_labels = True
+        if "samples_map" in style_cfg:
+            self.has_samples_map = True
+        self.set_defaults()
+
+    def set_defaults(self):
+        if not "stack" in self.opts_mc:
+            self.opts_mc["stack"] = True
+        if not hasattr(self, "fontsize"):
+            self.fontsize = 22
+
+
+class PlotManager:
+    '''This class manages multiple Shape objects and their plotting.'''
+    def __init__(self, hist_cfg, plot_dir, only_cat=[], style_cfg=style_cfg, data_key="DATA", log=False, density=False, save=True) -> None:
+        self.shape_objects = {}
+        self.plot_dir = plot_dir
+        self.only_cat = only_cat
+        self.data_key = data_key
+        self.log = log
+        self.density = density
+        self.save = save
+        for name, h_dict in hist_cfg.items():
+            self.shape_objects[name] = Shape(h_dict, name, plot_dir, only_cat=self.only_cat, style_cfg=style_cfg, data_key=self.data_key, log=self.log, density=self.density)
+
+    def plot_datamc_all(self, ratio=True, syst=True, spliteras=False):
+        '''Plots all the histograms contained in the dictionary, for all years and categories.'''
+        for name, datamc in self.shape_objects.items():
+            datamc.plot_datamc_all(ratio, syst, spliteras, save=self.save)
+
+
+class Shape:
+    '''This class handles the plotting of 1D data/MC histograms.
+    The constructor requires as arguments:
+    - h_dict: dictionary of histograms, with each entry corresponding to a different MC sample.
+    - name: name that identifies the Shape object.
+    - style_cfg: dictionary with style and plotting options.
+    - data_key: prefix for data samples (e.g. default in PocketCoffea: "DATA_SingleEle")'''
+    def __init__(self, h_dict, name, plot_dir, only_cat=[], style_cfg=style_cfg, data_key="DATA", log=False, density=False) -> None:
+        self.h_dict = h_dict
+        self.name = name
+        self.plot_dir = plot_dir
+        self.only_cat = only_cat
+        self.style = Style(style_cfg)
+        self.data_key = data_key
+        self.log = log
+        self.density = density
+        assert type(h_dict) == dict, "The Shape object receives a dictionary of hist.Hist objects as argument."
+        self.group_samples()
+        assert self.dense_dim == 1, f"The dimension of the histogram '{self.name}' is {self.dense_dim}. Only 1D histograms are supported."
+        self.load_attributes()
+
+    @property
+    def dense_axes(self):
+        '''Returns the list of dense axes of a histogram, defined as the axes that are not categorical axes.'''
+        dense_axes_dict = {s : [] for s in self.h_dict.keys()}
+
+        for s, h in self.h_dict.items():
+            for ax in h.axes:
+                if not type(ax) in [hist.axis.StrCategory, hist.axis.IntCategory]:
+                    dense_axes_dict[s].append(ax)
+        dense_axes = list(dense_axes_dict.values())
+        assert all(v == dense_axes[0] for v in dense_axes), "Not all the histograms in the dictionary have the same dense dimension."
+        dense_axes = dense_axes[0]
+
+        return dense_axes
+
+    def _categorical_axes(self, mc=True):
+        '''Returns the list of categorical axes of a histogram.'''
+        # Since MC and data have different categorical axes, the argument mc needs to specified
+        if mc:
+            d = {s : v for s, v in self.h_dict.items() if s in self.samples_mc}
         else:
-            # Sum in quadrature of the systematic uncertainties for each variation
-            up_tot = nom + np.sqrt(sum(syst_err2_up.values()))
-            down_tot = nom - np.sqrt(sum(syst_err2_down.values()))
-            label = "total"
-        if ratio:
-            up_tot = up_tot / nom
-            down_tot = down_tot / nom
-        linesUp_tot = ax.errorbar(x, up_tot, yerr=0, xerr=xerr, label=f"{label}Up", **opts_unc_total['Up'], fmt='none')
-        linesDown_tot = ax.errorbar(x, down_tot, yerr=0, xerr=xerr, label=f"{label}Down", **opts_unc_total['Down'], fmt='none')
-        for lines, var in zip([linesDown_tot, linesUp_tot], ['Down', 'Up']):
-            errorbar_x = lines[-1][0]
-            errorbar_y = lines[-1][1]
-            errorbar_x.set_linestyle(opts_errorbar[var]['linestyle'])
-            errorbar_y.set_linewidth(0)
-
-        color = iter(cm.gist_rainbow(np.linspace(0, 1, len(syst_err2_up_filtered.keys()))))
-        for i, syst in enumerate(syst_err2_up_filtered.keys()):
-            up = nom + np.sqrt(syst_err2_up_filtered[syst])
-            down = nom - np.sqrt(syst_err2_down_filtered[syst])
-            if ratio:
-                up = up / nom
-                down = down / nom
-            c = next(color)
-            linesUp = ax.errorbar(x, up, yerr=0, xerr=xerr, label=f"{syst}Up", **opts_unc['Up'], fmt='none', color=c)
-            linesDown = ax.errorbar(x, down, yerr=0, xerr=xerr, label=f"{syst}Down", **opts_unc['Down'], fmt='none', color=c)
-
-            for lines, var in zip([linesDown, linesUp], ['Down', 'Up']):
-                errorbar_x = lines[-1][0]
-                errorbar_y = lines[-1][1]
-                errorbar_x.set_linestyle(opts_errorbar[var]['linestyle'])
-                errorbar_y.set_linewidth(0)
-        if ratio:
-            ax.hlines(1.0, *ak.Array(edges_x)[[0,-1]], colors='gray', linestyles='dashed')
-            ax.legend(fontsize=fontsize_legend_ratio, ncols=2)
+            d = {s : v for s, v in self.h_dict.items() if s in self.samples_data}
+        categorical_axes_dict = {s : [] for s in d.keys()}
+
+        for s, h in d.items():
+            for ax in h.axes:
+                if type(ax) in [hist.axis.StrCategory, hist.axis.IntCategory]:
+                    categorical_axes_dict[s].append(ax)
+        categorical_axes = list(categorical_axes_dict.values())
+        assert all(v == categorical_axes[0] for v in categorical_axes), "Not all the histograms in the dictionary have the same categorical dimension."
+        categorical_axes = categorical_axes[0]
+
+        return categorical_axes
+
+    @property
+    def categorical_axes_mc(self):
+        '''Returns the list of categorical axes of a MC histogram.'''
+        return self._categorical_axes(mc=True)
+
+    @property
+    def categorical_axes_data(self):
+        '''Returns the list of categorical axes of a data histogram.'''
+        return self._categorical_axes(mc=False)
+
+    @property
+    def dense_dim(self):
+        '''Returns the number of dense axes of a histogram.'''
+        return len(self.dense_axes)
+    
+    def get_axis_items(self, axis_name, mc=True):
+        '''Returns the list of values contained in a Hist axis.'''
+        if mc:
+            axis = [ax for ax in self.categorical_axes_mc if ax.name == axis_name][0]
         else:
-            ax.legend(fontsize=fontsize, ncols=2)
-
-
-def plot_data_mc_hist1D(
-    h,
-    histname,
-    config=None,
-    plot_dir=None,
-    save=True,
-    only_cat=None,
-    mcstat=True,
-    stat_only=False,
-    reweighting_function=None,
-    flavorsplit=None,
-    split_systematics=False,
-    only_syst=False,
-    partial_unc_band=False,
-    log=False,
-):
-    '''This function plots 1D histograms in all the categories contained in the `cat` axis, for each data-taking year in the `year` axis.
-    The data/MC ratio is also shown in the bottom subplot
-    The MC systematic uncertainty is plotted on top of the MC stack in the histogram plot and around 1 in the ratio plot.
-    The uncertainty on data corresponds to the statistical uncertainty only.
-    The plots are saved in `plot_dir` if no config argument is passed. If `save` is False, the plots are not saved but just shown.
-    The argument `only_cat` can be a string or a list of strings to plot only a subset of categories.
-    To reweight the histograms, one can additionally pass the `reweighting_function` argument which is a 1D function of the variable on the x-axis that modifies the histogram weights.'''
-    for sample in h.keys():
-        if dense_dim(h[sample]) != 1:
-            print(
-                f"Histograms with dense dimension {dense_dim(h[sample])} cannot be plotted. Only 1D histograms are supported."
-            )
+            axis = [ax for ax in self.categorical_axes_data if ax.name == axis_name][0]
+        return list(axis.value(range(axis.size)))
+
+    def _stack_sum(self, mc=None, stack=None):
+        '''Returns the sum histogram of a stack (`hist.stack.Stack`) of histograms.'''
+        if not stack:
+            if mc:
+                stack = self.stack_mc_nominal
+            else:
+                stack = self.stack_data
+        if len(stack) == 1:
+            return stack[0]
+        else:
+            htot = stack[0]
+            for h in stack[1:]:
+                htot = htot + h
+            return htot
+
+    @property
+    def stack_sum_data(self):
+        '''Returns the sum histogram of a stack (`hist.stack.Stack`) of data histograms.'''
+        return self._stack_sum(mc=False)
+
+    @property
+    def stack_sum_mc_nominal(self):
+        '''Returns the sum histogram of a stack (`hist.stack.Stack`) of MC histograms.'''
+        return self._stack_sum(mc=True)
+
+    @property
+    def samples(self):
+        return list(self.h_dict.keys())
+
+    @property
+    def samples_data(self):
+        return list(filter(lambda d : self.data_key in d, self.samples))
+
+    @property
+    def samples_mc(self):
+        return list(filter(lambda d : self.data_key not in d, self.samples))
+
+    def group_samples(self):
+        '''Groups samples according to the dictionary self.style.samples_map'''
+        if not self.style.has_samples_map:
             return
-    samples = h.keys()
-    samples_data = list(filter(lambda d: 'DATA' in d, samples))
-    samples_mc = list(filter(lambda d: 'DATA' not in d, samples))
-
-    h_mc = h[samples_mc[0]]
-
-    years = get_axis_items(h_mc, 'year')
-    categories = get_axis_items(h_mc, 'cat')
-    variations = get_axis_items(h_mc, 'variation')
-
-    axis_x = dense_axes(h_mc)[0]
-    edges_x = axis_x.edges
-    binwidth_x = np.ediff1d(edges_x)
-
-    if len(samples_data) == 0:
-        is_mc_only = True
-    else:
-        is_mc_only = False
-
-    for year in years:
-
-        for cat in categories:
-            if only_cat:
-                if isinstance(only_cat, list):
-                    if not cat in only_cat:
-                        continue
-                elif isinstance(only_cat, str):
-                    if cat != only_cat:
-                        continue
-                else:
-                    raise NotImplementedError
-            slicing_mc = {'year': year, 'cat': cat}
-            slicing_mc_nominal = {'year': year, 'cat': cat, 'variation': 'nominal'}
-            if flavorsplit == '3f':
-                flavors = flavors_order['linear']
-                dict_mc = {
-                    f: stack_sum(
-                        hist.Stack.from_iter(
-                            [
-                                h[d][slicing_mc]
-                                for d in samples_mc
-                                if d.endswith(f'_{f}')
-                            ]
-                        )
-                    )
-                    for f in flavors
-                }
-                dict_mc_nominal = {
-                    f: stack_sum(
-                        hist.Stack.from_iter(
-                            [
-                                h[d][slicing_mc_nominal]
-                                for d in samples_mc
-                                if d.endswith(f'_{f}')
-                            ]
-                        )
-                    )
-                    for f in flavors
-                }
-                dict_mc = {
-                    'l': dict_mc['l'],
-                    'c+cc': dict_mc['c'] + dict_mc['cc'],
-                    'b+bb': dict_mc['b'] + dict_mc['bb'],
-                }
-                dict_mc_nominal = {
-                    'l': dict_mc_nominal['l'],
-                    'c+cc': dict_mc_nominal['c'] + dict_mc_nominal['cc'],
-                    'b+bb': dict_mc_nominal['b'] + dict_mc_nominal['bb'],
-                }
-                if any(
-                    cc in histname
-                    for cc in [
-                        'btagDDCvLV2',
-                        'particleNetMD_Xcc_QCD',
-                        'deepTagMD_ZHccvsQCD',
-                    ]
-                ):
-                    dict_mc = {
-                        'l': dict_mc['l'],
-                        'b+bb': dict_mc['b+bb'],
-                        'c+cc': dict_mc['c+cc'],
-                    }
-                    colors = colors_cc
+        h_dict_grouped = {}
+        samples_in_map = []
+        for sample_new, samples_list in self.style.samples_map.items():
+            h_dict_grouped[sample_new] = self._stack_sum(stack=hist.Stack.from_dict({s : h for s, h in self.h_dict.items() if s in samples_list}))
+            samples_in_map += samples_list
+        for s, h in self.h_dict.items():
+            if s not in samples_in_map:
+                h_dict_grouped[s] = h
+        self.h_dict = deepcopy(h_dict_grouped)
+
+    def load_attributes(self):
+        '''Loads the attributes from the dictionary of histograms.'''
+        assert len(set([self.h_dict[s].ndim for s in self.samples_mc])), "Not all the MC histograms have the same dimension."
+        for ax in self.categorical_axes_mc:
+            setattr(self, {'year': 'years', 'cat': 'categories', 'variation': 'variations'}[ax.name], self.get_axis_items(ax.name))
+        self.xaxis = self.dense_axes[0]
+        self.xlabel = self.xaxis.label
+        self.xcenters = self.xaxis.centers
+        self.xedges = self.xaxis.edges
+        self.xbinwidth = np.ediff1d(self.xedges)
+        self.is_mc_only = True if len(self.samples_data) == 0 else False
+        self.is_data_only = True if len(self.samples_mc) == 0 else False
+        if self.is_data_only | (not self.is_mc_only):
+            self.lumi = {year : femtobarn(lumi[year]['tot'], digits=1) for year in self.years}
+
+    def build_stacks(self, year, cat, spliteras=False):
+        '''Builds the data and MC stacks, applying a slicing by year and category.
+        If spliteras is True, the extra axis "era" is kept in the data stack to
+        distinguish between data samples from different data-taking eras.'''
+        slicing_mc = {'year': year, 'cat': cat}
+        slicing_mc_nominal = {'year': year, 'cat': cat, 'variation': 'nominal'}
+        self.h_dict_mc = {d: self.h_dict[d][slicing_mc] for d in self.samples_mc}
+        self.h_dict_mc_nominal = {d: self.h_dict[d][slicing_mc_nominal] for d in self.samples_mc}
+        # Store number of weighted MC events
+        self.nevents = {d: round(sum(self.h_dict_mc_nominal[d].values()), 1) for d in self.samples_mc}
+        reverse=True
+        # Order the events dictionary by decreasing number of events if linear scale, increasing if log scale
+        # N.B.: Here implement if log: reverse=False
+        self.nevents = dict( sorted(self.nevents.items(), key=lambda x:x[1], reverse=reverse) )
+        color = iter(cm.gist_rainbow(np.linspace(0, 1, len(self.nevents.keys()))))
+        # Assign random colors to each sample
+        self.colors = [next(color) for d in self.nevents.keys()]
+        if hasattr(self.style, "colors"):
+            # Initialize random colors
+            for i, d in enumerate(self.nevents.keys()):
+                # If the color for a corresponding sample exists in the dictionary, assign the color to the sample
+                if d in self.style.colors:
+                    self.colors[i] = self.style.colors[d]
+        # Order the MC dictionary by number of events
+        self.h_dict_mc = {d: self.h_dict_mc[d] for d in self.nevents.keys()}
+        self.h_dict_mc_nominal = {d: self.h_dict_mc_nominal[d] for d in self.nevents.keys()}
+        # Build MC stack with variations and nominal MC stack
+        self.stack_mc = hist.Stack.from_dict(self.h_dict_mc)
+        self.stack_mc_nominal = hist.Stack.from_dict(self.h_dict_mc_nominal)
+
+        if not self.is_mc_only:
+            # Sum over eras if specified as extra argument
+            if 'era' in self.categorical_axes_data:
+                if spliteras:
+                    slicing_data = {'year': year, 'cat': cat}
                 else:
-                    colors = colors_bb
-            elif flavorsplit == '5f':
-                flavors = flavors_order['linear']
-                if config:
-                    if hasattr(config, "plot_options"):
-                        if histname in config.plot_options["variables"].keys():
-                            cfg_plot = config.plot_options["variables"][histname]
-                            if 'scale' in cfg_plot.keys():
-                                flavors = flavors_order[
-                                    cfg_plot['scale']
-                                ]
-                dict_mc = {
-                    f: stack_sum(
-                        hist.Stack.from_iter(
-                            [
-                                h[d][slicing_mc]
-                                for d in samples_mc
-                                if d.endswith(f'_{f}')
-                            ]
-                        )
-                    )
-                    for f in flavors
-                }
-                dict_mc_nominal = {
-                    f: stack_sum(
-                        hist.Stack.from_iter(
-                            [
-                                h[d][slicing_mc_nominal]
-                                for d in samples_mc
-                                if d.endswith(f'_{f}')
-                            ]
-                        )
-                    )
-                    for f in flavors
-                }
-                colors = [colors_5f[f] for f in flavors]
-                nevents = {
-                    f: round(sum(dict_mc_nominal[f].values()), 1) for f in flavors
-                }
-            else:
-                dict_mc = {d: h[d][slicing_mc] for d in samples_mc}
-                dict_mc_nominal = {d: h[d][slicing_mc_nominal] for d in samples_mc}
-                nevents = {
-                    d: round(sum(dict_mc_nominal[d].values()), 1) for d in samples_mc
-                }
-                reverse=True
-                if ("variables" in config.plot_options) & (histname in config.plot_options["variables"].keys()):
-                    cfg_plot = config.plot_options["variables"][histname]
-                    if 'scale' in cfg_plot.keys():
-                        reverse = False
-                if log:
-                    reverse = False
-                nevents = dict( sorted(nevents.items(), key=lambda x:x[1], reverse=reverse) )
-                dict_mc = {d: dict_mc[d] for d in nevents.keys()}
-                dict_mc_nominal = {d: dict_mc_nominal[d] for d in nevents.keys()}
-                colors = [colors_tthbb[d] for d in nevents.keys()]
-            if reweighting_function:
-                for sample, val in dict_mc_nominal.items():
-                    histo_reweighted = hist.Hist(dict_mc_nominal[sample].axes[0])
-                    histo_reweighted.fill(
-                        dict_mc_nominal[sample].axes[0].centers,
-                        weight=dict_mc_nominal[sample].values()
-                        * reweighting_function(dict_mc_nominal[sample].axes[0].centers),
-                    )
-                    dict_mc_nominal[sample] = histo_reweighted
-            stack_mc = hist.Stack.from_dict(dict_mc)
-            stack_mc_nominal = hist.Stack.from_dict(dict_mc_nominal)
-
-            if not is_mc_only:
-                # Sum over eras if era axis exists in data histogram
-                if 'era' in h[samples_data[0]].axes.name:
                     slicing_data = {'year': year, 'cat': cat, 'era': sum}
+            else:
+                if spliteras:
+                    raise Exception("No axis 'era' found. Impossible to split data by era.")
                 else:
                     slicing_data = {'year': year, 'cat': cat}
-                dict_data = {d: h[d][slicing_data] for d in samples_data}
-                stack_data = hist.Stack.from_dict(dict_data)
-
-            rebinning = False
-            if config:
-                if hasattr(config, "plot_options"):
-                    if histname in config.plot_options["variables"].keys():
-                        cfg_plot = config.plot_options["variables"][histname]
-                        if 'binning' in cfg_plot.keys():
-                            rebinning = True
-                            stack_data = rebin(
-                                stack_data, cfg_plot['binning']
-                            )
-                            stack_mc_nominal = rebin(
-                                stack_mc_nominal,
-                                cfg_plot['binning'],
-                            )
-
-            if not is_mc_only:
-                h_data = stack_sum(stack_data)
-                if flavorsplit == '5f':
-                    nevents['Data'] = round(sum(h_data.values()))
-
-            totalLumi = femtobarn(lumi[year]['tot'], digits=1)
-            if partial_unc_band:
-                opts_fig = opts_figure['partial']
+            self.h_dict_data = {d: self.h_dict[d][slicing_data] for d in self.samples_data}
+            self.stack_data = hist.Stack.from_dict(self.h_dict_data)
+
+    def get_datamc_ratio(self):
+        '''Computes the data/MC ratio and the corresponding uncertainty.'''
+        num = self.stack_sum_data.values()
+        den = self.stack_sum_mc_nominal.values()
+        self.ratio = num / den
+        # TO DO: Implement Poisson interval valid also for num~0
+        # np.sqrt(num) is just an approximation of the uncertainty valid at large num
+        self.ratio_unc = np.sqrt(num) / den
+        self.ratio_unc[np.isnan(self.ratio_unc)] = np.inf
+
+    def get_systematic_uncertainty(self):
+        '''Instantiates the `SystUnc` objects and stores them in a dictionary with one entry for each systematic uncertainty.'''
+        self.syst_manager = SystManager(self)
+
+    def define_figure(self, year=None, ratio=True):
+        '''Defines the figure for the Data/MC plot.
+        If ratio is True, a subplot is defined to include the Data/MC ratio plot.'''
+        plt.style.use([hep.style.ROOT, {'font.size': self.style.fontsize}])
+        plt.rcParams.update({'font.size': self.style.fontsize})
+        if ratio:
+            self.fig, (self.ax, self.rax) = plt.subplots(2, 1, **self.style.opts_figure["datamc_ratio"])
+            self.fig.subplots_adjust(hspace=0.06)
+        else:
+            self.fig, self.ax  = plt.subplots(1, 1, **self.style.opts_figure["datamc"])
+        if self.is_mc_only:
+            hep.cms.text("Simulation Preliminary", fontsize=self.style.fontsize, loc=0, ax=self.ax)
+        if year:
+            if not self.is_mc_only:
+                hep.cms.lumitext(text=f'{self.lumi[year]}' + r' fb$^{-1}$, 13 TeV,' + f' {year}', fontsize=self.style.fontsize, ax=self.ax)
             else:
-                opts_fig = opts_figure['total']
-            fig, (ax, rax) = plt.subplots(2, 1, **opts_fig)
-            fig.subplots_adjust(hspace=0.06)
-            hep.cms.text("Preliminary", fontsize=fontsize, loc=0, ax=ax)
-            hep.cms.lumitext(
-                text=f'{totalLumi}' + r' fb$^{-1}$, 13 TeV,' + f' {year}',
-                fontsize=fontsize,
-                ax=ax,
-            )
-            stack_mc_nominal.plot(stack=True, histtype='fill', ax=ax, color=colors)
-            if not is_mc_only:
-                x = dense_axes(stack_mc_nominal)[0].centers
-                ax.errorbar(
-                    x, h_data.values(), yerr=np.sqrt(h_data.values()), **opts_data
-                )
-                # stack_data.plot(stack=True, color='black', ax=ax)
-            if rebinning:
-                syst_err2_up, syst_err2_down = get_systematic_uncertainty(
-                    stack_mc,
-                    variations,
-                    mcstat=mcstat,
-                    stat_only=stat_only,
-                    edges=cfg_plot['binning'],
-                )
+                hep.cms.lumitext(text=f'{year}', fontsize=self.style.fontsize, ax=self.ax)
+
+    def format_figure(self, ratio=True):
+        '''Formats the figure's axes, labels, ticks, xlim and ylim.'''
+        ylabel = "Counts" if not self.density else "A.U."
+        self.ax.set_ylabel(ylabel, fontsize=self.style.fontsize)
+        self.ax.legend(fontsize=self.style.fontsize, ncols=2, loc="upper right")
+        self.ax.tick_params(axis='x', labelsize=self.style.fontsize)
+        self.ax.tick_params(axis='y', labelsize=self.style.fontsize)
+        self.ax.set_xlim(self.xedges[0], self.xedges[-1])
+        if self.log:
+            self.ax.set_yscale("log")
+            if self.is_mc_only:
+                exp = math.floor(math.log(max(self.stack_sum_mc_nominal.values()), 10))
             else:
-                syst_err2_up, syst_err2_down = get_systematic_uncertainty(
-                    stack_mc, variations, mcstat=mcstat, stat_only=stat_only
-                )
-            # print("syst_err2_up", syst_err2_up)
-            # print("syst_err2_down", syst_err2_down)
-            plot_systematic_uncertainty(
-                stack_mc_nominal, syst_err2_up, syst_err2_down, ax
-            )
-            if not is_mc_only:
-                print(cat, histname)
-                ratio, unc = get_data_mc_ratio(stack_data, stack_mc_nominal)
-                rax.errorbar(x, ratio, unc, **opts_data)
-            plot_systematic_uncertainty(
-                stack_mc_nominal, syst_err2_up, syst_err2_down, rax, ratio=True, split_systematics=split_systematics, only_syst=only_syst, partial_unc_band=partial_unc_band
-            )
-            if is_mc_only:
-                maximum = max(stack_sum(stack_mc_nominal).values())
+                exp = math.floor(math.log(max(self.stack_sum_data.values()), 10))
+            self.ax.set_ylim((0.01, 10 ** (exp + 3)))
+        else:
+            if self.is_mc_only:
+                reference_shape = self.stack_sum_mc_nominal.values()
             else:
-                maximum = max(stack_sum(stack_data).values())
-            if not np.isnan(maximum):
-                ax.set_ylim((0, 2.0 * maximum))
-            rax.set_ylim((0.5, 1.5))
-            xlabel = ax.get_xlabel()
-            ax.set_xlabel("")
-            ax.set_ylabel("Counts", fontsize=fontsize)
-            rax.set_xlabel(xlabel, fontsize=fontsize)
-            rax.set_ylabel("Data / MC", fontsize=fontsize)
-            rax.yaxis.set_label_coords(-0.075, 1)
-            ax.legend(fontsize=fontsize, ncols=2, loc="upper right")
-            if flavorsplit == '5f':
-                handles, labels = ax.get_legend_handles_labels()
-                labels_new = []
-                handles_new = []
-                for i, f in enumerate(labels):
-                    if f in nevents:
-                        labels_new.append(f"{f} [{nevents[f]}]")
-                    else:
-                        labels_new.append(f)
-                    handles_new.append(handles[i])
-                labels = labels_new
-                handles = handles_new
-                ax.legend(handles, labels, fontsize=fontsize, ncols=2, loc="upper right")
-            ax.tick_params(axis='x', labelsize=fontsize)
-            ax.tick_params(axis='y', labelsize=fontsize)
-            #rax.set_yticks((0, 0.5, 1, 1.5, 2), axis='y', labelsize=fontsize)
-            rax.tick_params(axis='x', labelsize=fontsize)
-            rax.tick_params(axis='y', labelsize=fontsize)
-
-            if log:
-                ax.set_yscale("log")
-                exp = math.floor(
-                    math.log(max(stack_sum(stack_mc_nominal).values()), 10)
-                )
-                ax.set_ylim((0.01, 10 ** (exp + 2)))
-                # if flavorsplit == '5f':
-                #    ax.legend(handles, labels, loc="upper right", fontsize=fontsize, ncols=2)
-                # else:
-                #    ax.legend(loc="upper right", fontsize=fontsize, ncols=2)
-            if config:
-                if hasattr(config, "plot_options"):
-                    if "labels" in config.plot_options:
-                        handles, labels = ax.get_legend_handles_labels()
-                        labels_new = []
-                        handles_new = []
-                        for i, l in enumerate(labels):
-                            if l in config.plot_options["labels"]:
-                                labels_new.append(f"{config.plot_options['labels'][l]}")
-                            else:
-                                labels_new.append(l)
-                            handles_new.append(handles[i])
-                        labels = labels_new
-                        handles = handles_new
-                        ax.legend(handles, labels, fontsize=fontsize, ncols=2)
-                    if ("variables" in config.plot_options) & (histname in config.plot_options["variables"].keys()):
-                        cfg_plot = config.plot_options["variables"][histname]
-                        if 'xlim' in cfg_plot.keys():
-                            ax.set_xlim(*cfg_plot['xlim'])
-                        if 'scale' in cfg_plot.keys():
-                            ax.set_yscale(cfg_plot['scale'])
-                            if cfg_plot['scale'] == 'log':
-                                exp = math.floor(
-                                    math.log(
-                                        max(stack_sum(stack_mc_nominal).values()), 10
-                                    )
-                                )
-                                ax.set_ylim((0.01, 10 ** (exp + 2)))
-                                # ax.legend(handles, labels, loc="upper right", fontsize=fontsize, ncols=2)
-                        if 'ylim' in cfg_plot.keys():
-                            if isinstance(cfg_plot['ylim'], tuple):
-                                ax.set_ylim(*cfg_plot['ylim'])
-                            elif isinstance(
-                                cfg_plot['ylim'], float
-                            ) | isinstance(cfg_plot['ylim'], int):
-                                rescale = cfg_plot['ylim']
-                                ax.set_ylim(
-                                    (
-                                        0,
-                                        rescale
-                                        * max(stack_sum(stack_mc_nominal).values()),
-                                    )
-                                )
-                        if 'xlabel' in cfg_plot.keys():
-                            rax.set_xlabel(cfg_plot['xlabel'])
-                        if 'ylabel' in cfg_plot.keys():
-                            rax.set_ylabel(cfg_plot['ylabel'])
-                        if 'xticks' in cfg_plot.keys():
-                            rax.set_xticks(cfg_plot['xticks'])
-                            rax.xaxis.set_minor_locator(MultipleLocator(binwidth_x[0]))
+                reference_shape = self.stack_sum_data.values()
+            if self.density:
+                integral = sum(reference_shape) * self.xbinwidth
+                reference_shape = reference_shape / integral
+            ymax = max(reference_shape)
+            if not np.isnan(ymax):
+                self.ax.set_ylim((0, 2.0 * ymax))
+        if ratio:
+            self.ax.set_xlabel("")
+            self.rax.set_xlabel(self.xlabel, fontsize=self.style.fontsize)
+            self.rax.set_ylabel("Data / MC", fontsize=self.style.fontsize)
+            self.rax.yaxis.set_label_coords(-0.075, 1)
+            self.rax.tick_params(axis='x', labelsize=self.style.fontsize)
+            self.rax.tick_params(axis='y', labelsize=self.style.fontsize)
+            self.rax.set_ylim((0.5, 1.5))
+        if self.style.has_labels:
+            handles, labels = self.ax.get_legend_handles_labels()
+            labels_new = []
+            handles_new = []
+            for i, l in enumerate(labels):
+                if l in self.style.labels:
+                    labels_new.append(f"{self.style.labels[l]}")
                 else:
-                    if histname in config.variables.keys():
-                        if config.variables[histname].axes[0].lim != (0, 0):
-                            ax.set_xlim(*config.variables[histname].axes[0].lim)
-                        else:
-                            ax.set_xlim(
-                                config.variables[histname].axes[0].start,
-                                config.variables[histname].axes[0].stop,
-                            )
-                plot_dir = os.path.join(config.plots, cat)
-            if log:
-                plot_dir = os.path.join(plot_dir, "log")
-            if not os.path.exists(plot_dir):
-                os.makedirs(plot_dir)
-            filepath = os.path.join(plot_dir, f"{histname}_{year}_{cat}.png")
-
-            if save:
-                print("Saving", filepath)
-                plt.savefig(filepath, dpi=150, format="png")
-            else:
-                plt.show()
-            plt.close(fig)
-
-
-def plot_shapes_comparison(
-    df,
-    var,
-    shapes,
-    title=None,
-    ylog=False,
-    output_folder=None,
-    figsize=(8, 9),
-    dpi=100,
-    lumi_label="$137/fb$ (13 TeV)",
-    outputfile=None,
-):
-    '''
-    This function plots the comparison between different shapes, specified in the format
-    shapes = [ (sample,cat,year,variation, label),]
-
-    The sample, cat and year are used to retrive the shape from the `df`, the label is used in the plotting.
-    The ratio of all the shapes w.r.t. of the first one in the list are printed.
-
-    The plot is saved if outputfile!=None.
-    '''
-    H = df[var]
-    fig = plt.figure(figsize=figsize, dpi=dpi)
-    gs = fig.add_gridspec(nrows=2, ncols=1, hspace=0.05, height_ratios=[0.75, 0.25])
-    axs = gs.subplots(sharex=True)
-    plt.subplots_adjust(wspace=0.3)
-
-    axu = axs[0]
-    axd = axs[1]
-
-    for sample, cat, year, variation, label in shapes:
-        print(sample, cat, year, variation)
-        hep.histplot(H[sample][cat, variation, year, :], label=label, ax=axu)
-
-    if ylog:
-        axu.set_yscale("log")
-    axu.legend()
-    axu.set_xlabel('')
-    axu.set_ylabel('Events')
-    hep.plot.ylow(axu)
-    hep.plot.yscale_legend(axu)
-
-    # Ratios
-    sample, cat, year, variation, label = shapes[0]
-    nom = H[sample][cat, variation, year, :]
-    nomvalues = nom.values()
-    nom_sig2 = nom.variances()
-    centers = nom.axes[0].centers
-    edges = nom.axes[0].edges
-    minratio, maxratio = 1000.0, 0.0
-    for sample, cat, year, variation, label in shapes[:]:
-        h = H[sample][cat, variation, year, :]
-        h_val = h.values()
-        h_sig2 = h.variances()
-
-        err = np.sqrt(
-            (1 / nomvalues) ** 2 * h_sig2 + (h_val / nomvalues**2) ** 2 * nom_sig2
-        )
-        r = np.where(nomvalues > 0, h.values() / nomvalues, 1.0)
-        m, M = np.min(r), np.max(r)
-        if m < minratio:
-            minratio = m
-        if M > maxratio:
-            maxratio = M
-        axd.errorbar(
-            centers,
-            r,
-            xerr=0,
-            yerr=err,
-            label=label,
-            fmt=".",
-            linestyle='none',
-            elinewidth=1,
+                    labels_new.append(l)
+                handles_new.append(handles[i])
+            labels = labels_new
+            handles = handles_new
+            self.ax.legend(handles, labels, fontsize=self.style.fontsize, ncols=2, loc="upper right")
+
+    def plot_mc(self, ax=None):
+        '''Plots the MC histograms as a stacked plot.'''
+        if ax:
+            self.ax = ax
+        self.stack_mc_nominal.plot(ax=self.ax, color=self.colors, density=self.density, **self.style.opts_mc)
+        self.format_figure(ratio=False)
+
+    def plot_data(self, ax=None):
+        '''Plots the data histogram as an errorbar plot.'''
+        if ax:
+            self.ax = ax
+        y = self.stack_sum_data.values()
+        yerr = np.sqrt(y)
+        integral = (sum(y) * self.xbinwidth)
+        if self.density:
+            y = y / integral
+            yerr = yerr / integral
+        self.ax.errorbar(self.xcenters, y, yerr=yerr, **self.style.opts_data)
+        self.format_figure(ratio=False)
+
+    def plot_datamc_ratio(self, ax=None):
+        '''Plots the Data/MC ratio as an errorbar plot.'''
+        self.get_datamc_ratio()
+        if ax:
+            self.rax = rax
+        self.rax.errorbar(self.xcenters, self.ratio, yerr=self.ratio_unc, **self.style.opts_data)
+        self.format_figure(ratio=True)
+
+    def plot_systematic_uncertainty(self, ratio=False, ax=None):
+        '''Plots the asymmetric systematic uncertainty band on top of the MC stack, if `ratio` is set to False.
+        To plot the systematic uncertainty in a ratio plot, `ratio` has to be set to True and the uncertainty band will be plotted around 1 in the ratio plot.'''
+        ax = self.ax
+        up = self.syst_manager.total.up
+        down = self.syst_manager.total.down
+        if ratio:
+            # In order to get a consistent uncertainty band, the up/down variations of the ratio are set to 1 where the nominal value is 0
+            ax = self.rax
+            up = self.syst_manager.total.ratio_up
+            down = self.syst_manager.total.ratio_down
+
+        unc_band = np.array([down, up])
+        ax.fill_between(
+            self.xedges,
+            np.r_[unc_band[0], unc_band[0, -1]],
+            np.r_[unc_band[1], unc_band[1, -1]],
+            **self.style.opts_unc['total'],
+            label="syst. unc.",
         )
+        if ratio:
+            ax.hlines(1.0, *ak.Array(self.xedges)[[0,-1]], colors='gray', linestyles='dashed')
 
-    axd.legend(ncol=3, fontsize='xx-small')
-    hep.plot.yscale_legend(axd)
-    axd.set_xlabel(nom.axes[0].label)
-    axd.set_ylim(0.8 * minratio, 1.2 * maxratio)
-    axd.set_ylabel("ratio")
-    axd.grid(which="both", axis="y")
-
-    if title:
-        axu.text(0.5, 1.025, title, transform=axu.transAxes, fontsize='x-small')
-
-    hep.cms.label(llabel="", rlabel=lumi_label, loc=0, ax=axu)
+    def plot_datamc(self, year=None, ratio=True, syst=True, ax=None, rax=None):
+        '''Plots the data histogram as an errorbar plot on top of the MC stacked histograms.
+        If ratio is True, also the Data/MC ratio plot is plotted.
+        If syst is True, also the total systematic uncertainty is plotted.'''
+        if ratio:
+            if self.is_mc_only:
+                raise Exception("The Data/MC ratio cannot be plotted if the histogram is MC only.")
+            if self.is_data_only:
+                raise Exception("The Data/MC ratio cannot be plotted if the histogram is Data only.")
+
+        if ax:
+            self.ax = ax
+        if rax:
+            self.rax = rax
+        if (not self.is_mc_only) & (not self.is_data_only):
+            self.plot_mc()
+            self.plot_data(year)
+            if syst:
+                self.plot_systematic_uncertainty()
+        elif self.is_mc_only:
+            self.plot_mc()
+            if syst:
+                self.plot_systematic_uncertainty()
+        elif self.is_data_only:
+            self.plot_data(year)
 
-    if outputfile:
-        fig.savefig(outputfile.replace("*", "png"))
-        fig.savefig(outputfile.replace("*", "pdf"))
-    return fig
+        if ratio:
+            self.plot_datamc_ratio(year)
+            if syst:
+                self.plot_systematic_uncertainty(ratio)
+
+        self.format_figure(ratio)
+
+    def plot_datamc_all(self, ratio=True, syst=True, spliteras=False, save=True):
+        '''Plots the data and MC histograms for each year and category contained in the histograms.
+        If ratio is True, also the Data/MC ratio plot is plotted.
+        If syst is True, also the total systematic uncertainty is plotted.'''
+        for year in self.years:
+            for cat in self.categories:
+                if not any([c in cat for c in self.only_cat]):
+                    continue
+                self.define_figure(year, ratio)
+                self.build_stacks(year, cat, spliteras)
+                self.get_systematic_uncertainty()
+                self.plot_datamc(year, ratio, syst)
+                if save:
+                    plot_dir = os.path.join(self.plot_dir, cat)
+                    if self.log:
+                        plot_dir = os.path.join(plot_dir, "log")
+                    if not os.path.exists(plot_dir):
+                        os.makedirs(plot_dir)
+                    filepath = os.path.join(plot_dir, f"{self.name}_{year}_{cat}.png")
+                    print("Saving", filepath)
+                    plt.savefig(filepath, dpi=150, format="png")
+                else:
+                    plt.show(self.fig)
+                plt.close(self.fig)
+
+
+class SystManager:
+    '''This class handles the systematic uncertainties of 1D MC histograms.'''
+    def __init__(self, datamc : Shape, has_mcstat=True) -> None:
+        self.datamc = datamc
+        assert all([(var == "nominal") | var.endswith(("Up", "Down")) for var in self.datamc.variations]), "All the variations names that are not 'nominal' must end in 'Up' or 'Down'."
+        self.variations_up = [var for var in self.datamc.variations if var.endswith("Up")]
+        self.variations_down = [var for var in self.datamc.variations if var.endswith("Down")]
+        assert len(self.variations_up) == len(self.variations_down), "The number of up and down variations is mismatching."
+        self.systematics = [s.split("Up")[0] for s in self.variations_up]
+        if has_mcstat:
+            self.systematics.append("mcstat")
+        self.syst_dict = {}
+
+        for syst_name in self.systematics:
+            self.syst_dict[syst_name] = SystUnc(self.datamc, syst_name)
+
+    @property
+    def total(self):
+        total = SystUnc(name="total", syst_list=list(self.syst_dict.values()))
+        return total
+
+    @property
+    def mcstat(self):
+        return self.syst_dict["mcstat"]
+
+    def get_syst(self, syst_name : str):
+        '''Returns the SystUnc object corresponding to a given systematic uncertainty,
+        passed as the argument `syst_name`.'''
+        return self.syst_dict[syst_name]
+
+
+class SystUnc:
+    '''This class stores the information of a single systematic uncertainty of a 1D MC histogram.
+    The built-in __add__() method implements the sum in quadrature of two systematic uncertainties,
+    returning a `SystUnc` instance corresponding to their sum in quadrature.'''
+    def __init__(self, datamc : Shape = None, name : str = None, syst_list : list = None) -> None:
+        self.datamc = datamc
+        self.name = name
+        self.is_mcstat = self.name == "mcstat"
+
+        # Initialize the arrays of the nominal yield and squared errors as 0
+        self.nominal = 0.0
+        self.err2_up = 0.0
+        self.err2_down = 0.0
+        if datamc:
+            if syst_list:
+                raise Exception("The initialization of the instance is ambiguous. Either a `DataMC` object or a list of `SystUnc` objects should be passed to the constructor.")
+            else:
+                self.syst_list = [self]
+            self._get_err2()
+            # Inherit style from Shape object
+            self.style = self.datamc.style
+            # Full nominal MC including all MC samples
+            self.h_mc_nominal = self.datamc.stack_sum_mc_nominal
+            self.nominal = self.h_mc_nominal.values()
+            self.xlabel = self.datamc.xlabel
+            self.xcenters = self.datamc.xcenters
+            self.xedges = self.datamc.xedges
+            self.xbinwidth = self.datamc.xbinwidth
+        elif syst_list:
+            self.syst_list = syst_list
+            assert self.nsyst > 0, "Attempting to initialize a `SystUnc` instance with an empty list of systematic uncertainties."
+            assert not ((self._n_empty == 1) & (self.nsyst == 1)), "Attempting to intialize a `SystUnc` instance with an empty systematic uncertainty."
+            self._get_err2_from_syst()
+            # Get default style
+            self.style = Style()
+
+    def __add__(self, other):
+        '''Sum in quadrature of two systematic uncertainties.
+        In case multiple objects are summed, the information on the systematic uncertainties that
+        have been summed is stored in self.syst_list.'''
+        return SystUnc(name=f"{self.name}_{other.name}", syst_list=[self, other])
+
+    @property
+    def up(self):
+        return self.nominal + np.sqrt(self.err2_up)
+
+    @property
+    def down(self):
+        return self.nominal - np.sqrt(self.err2_down)
+
+    @property
+    def ratio_up(self):
+        return np.where(self.nominal != 0, self.up / self.nominal, 1)
+
+    @property
+    def ratio_down(self):
+        return np.where(self.nominal != 0, self.down / self.nominal, 1)
+
+    @property
+    def nsyst(self):
+        return len(self.syst_list)
+
+    @property
+    def _is_empty(self):
+        return np.sum(self.nominal) == 0
+
+    @property
+    def _n_empty(self):
+        return len([s for s in self.syst_list if s._is_empty])
+
+    def _get_err2_from_syst(self):
+        '''Method used in the constructor to instanstiate a SystUnc object from
+        a list of SystUnc objects. The sytematic uncertainties in self.syst_list,
+        are summed in quadrature to define a new SystUnc object.'''
+        index_non_empty = [i for i, s in enumerate(self.syst_list) if not s._is_empty][0]
+        self.nominal = self.syst_list[index_non_empty].nominal
+        self.xlabel = self.syst_list[index_non_empty].xlabel
+        self.xcenters = self.syst_list[index_non_empty].xcenters
+        self.xedges = self.syst_list[index_non_empty].xedges
+        self.xbinwidth = self.syst_list[index_non_empty].xbinwidth
+        for syst in self.syst_list:
+            if not ((self._is_empty) | (syst._is_empty)):
+                assert all(np.equal(self.nominal, syst.nominal)), "Attempting to sum systematic uncertainties with different nominal MC."
+                assert all(np.equal(self.xcenters, syst.xcenters)), "Attempting to sum systematic uncertainties with different bin centers."
+            self.err2_up += syst.err2_up
+            self.err2_down += syst.err2_up
+
+    def _get_err2(self):
+        '''Method used in the constructor to instanstiate a SystUnc object from
+        a Shape object. The corresponding up/down squared uncertainties are stored and take
+        into account the possibility for the uncertainty to be one-sided.'''
+        # Loop over all the MC samples and sum the systematic uncertainty in quadrature
+        for h in self.datamc.stack_mc:
+            # Nominal variation for a single MC sample
+            h_nom = h[{'variation': 'nominal'}]
+            nom = h_nom.values()
+            # Sum in quadrature of mcstat
+            if self.is_mcstat:
+                mcstat_err2 = h_nom.variances()
+                self.err2_up += mcstat_err2
+                self.err2_down += mcstat_err2
+                continue
+            # Up/down variations for a single MC sample
+            var_up = h[{'variation': f'{self.name}Up'}].values()
+            var_down = h[{'variation': f'{self.name}Down'}].values()
+            # Compute the uncertainties corresponding to the up/down variations
+            err_up = var_up - nom
+            err_down = var_down - nom
+            # Compute the flags to check which of the two variations (up and down) are pushing the nominal value up and down
+            up_is_up = err_up > 0
+            down_is_down = err_down < 0
+            # Compute the flag to check if the uncertainty is one-sided, i.e. when both variations are up or down
+            is_onesided = (up_is_up ^ down_is_down)
+
+            # Sum in quadrature of the systematic uncertainties taking into account if the uncertainty is one- or double-sided
+            err2_up_twosided = np.where(up_is_up, err_up**2, err_down**2)
+            err2_down_twosided = np.where(up_is_up, err_down**2, err_up**2)
+            err2_max = np.maximum(err2_up_twosided, err2_down_twosided)
+            err2_up_onesided = np.where(is_onesided & up_is_up, err2_max, 0)
+            err2_down_onesided = np.where(is_onesided & down_is_down, err2_max, 0)
+            err2_up_combined = np.where(is_onesided, err2_up_onesided, err2_up_twosided)
+            err2_down_combined = np.where(is_onesided, err2_down_onesided, err2_down_twosided)
+            # Sum in quadrature of the systematic uncertainty corresponding to a MC sample
+            self.err2_up += err2_up_combined
+            self.err2_down += err2_down_combined
+
+    def plot(self, ax=None):
+        '''Plots the nominal, up and down systematic variations on the same plot.'''
+        plt.style.use([hep.style.ROOT, {'font.size': self.style.fontsize}])
+        plt.rcParams.update({'font.size': self.style.fontsize})
+        if not ax:
+            self.fig, self.ax  = plt.subplots(1, 1, **self.style.opts_figure["datamc"])
+        else:
+            self.ax = ax
+            self.fig = self.ax.get_figure
+        hep.cms.text("Simulation Preliminary", fontsize=self.style.fontsize, loc=0, ax=self.ax)
+        #hep.cms.lumitext(text=f'{self.lumi[year]}' + r' fb$^{-1}$, 13 TeV,' + f' {year}', fontsize=self.style.fontsize, ax=self.ax)
+        self.ax.hist(self.xcenters, weights=self.nominal, histtype="step", label="nominal", **self.style.opts_syst["nominal"])
+        self.ax.hist(self.xcenters, weights=self.up, histtype="step", label=f"{self.name} up", **self.style.opts_syst["up"])
+        self.ax.hist(self.xcenters, weights=self.down, histtype="step", label=f"{self.name} down", **self.style.opts_syst["down"])
+        self.ax.set_xlabel(self.xlabel)
+        self.ax.set_ylabel("Counts")
+        self.ax.legend()
+        return self.fig, self.ax
diff --git a/scripts/plot/make_plots.py b/scripts/plot/make_plots.py
index 3f199f45644c243662d0c23fdf88fa6a40e2e092..3b56578398b288c90034b77283d1e1127d8a9d4b 100644
--- a/scripts/plot/make_plots.py
+++ b/scripts/plot/make_plots.py
@@ -1,52 +1,50 @@
 import os
 import sys
 import time
-import json
 import argparse
 
 import numpy as np
 
 import matplotlib
-import matplotlib.pyplot as plt
-from matplotlib.offsetbox import AnchoredText
 matplotlib.use('Agg')
 
-
-import matplotlib.pyplot as plt
-import math
-import mplhep as hep
 from coffea.util import load
-from coffea.hist import plot
-import coffea.hist as hist
 
 from multiprocessing import Pool
-from pocket_coffea.parameters.lumi import lumi, femtobarn
 
 from pocket_coffea.utils.configurator import Configurator
-from pocket_coffea.utils.plot_utils import slice_accumulator, plot_data_mc_hist1D
+from pocket_coffea.utils.plot_utils import PlotManager
+from pocket_coffea.parameters.plotting import style_cfg
+
+def slice_accumulator(accumulator, entrystart, entrystop):
+    '''Returns an accumulator containing only a reduced set of histograms, i.e. those between the positions `entrystart` and `entrystop`.'''
+    _accumulator = dict([(key, value) for key, value in accumulator.items()])
+    _accumulator['variables'] = dict(
+        [(key, value) for key, value in accumulator['variables'].items()][
+            entrystart:entrystop
+        ]
+    )
+    return _accumulator
 
 parser = argparse.ArgumentParser(description='Plot histograms from coffea file')
 parser.add_argument('--cfg', default=os.getcwd() + "/config/test.json", help='Config file with parameters specific to the current run', required=False)
 parser.add_argument("-i", "--inputfile", required=True, type=str, help="Input file")
 parser.add_argument('--plot_dir', default=None, help='Sub-directory inside the plots folder to save plots', required=False)
 parser.add_argument('-v', '--version', type=str, default=None, help='Version of output (e.g. `v01`, `v02`, etc.)')
-parser.add_argument('--test', default=False, action='store_true', help='Test mode')
 parser.add_argument('-j', '--workers', type=int, default=8, help='Number of parallel workers to use for plotting')
 parser.add_argument('-o', '--only', type=str, default='', help='Filter histograms name with string', required=False)
-parser.add_argument('-oc', '--only_cat', type=str, default='', help='Filter categories with string', required=False)
+parser.add_argument('-oc', '--only_cat', type=str, nargs="+", help='Filter categories with string', required=False)
 parser.add_argument('-os', '--only_syst', type=str, nargs="+", default='', help='Filter systematics with a list of strings', required=False)
 parser.add_argument('--split_systematics', action='store_true', help='Split systematic uncertainties in the ratio plot')
 parser.add_argument('--partial_unc_band', action='store_true', help='Plot only the partial uncertainty band corresponding to the systematics specified as the argument `only_syst`')
 parser.add_argument('--overwrite', action='store_true', help='Overwrite plots in output folder')
 parser.add_argument('--log', action='store_true', help='Set y-axis scale to log')
+parser.add_argument('--density', action='store_true', help='Set density parameter to have a normalized plot')
+parser.add_argument('-d', '--data_key', type=str, default='DATA', help='Prefix for data samples', required=False)
 
 args = parser.parse_args()
 config = Configurator(args.cfg, plot=True, plot_version=args.version)
 
-#finalstate = config.finalstate
-#categories_to_sum_over = config.plot_options["sum_over"]
-#var = config.plot_options["var"]
-
 print("Starting ", end='')
 print(time.ctime())
 start = time.time()
@@ -65,22 +63,21 @@ if not args.overwrite:
 if not os.path.exists(config.plots):
     os.makedirs(config.plots)
 
+
 def make_plots(entrystart, entrystop):
+    '''Function that instantiates multiple PlotManager objects each managing a different subset of histograms.'''
     _accumulator = slice_accumulator(accumulator, entrystart, entrystop)
-    for (histname, h) in _accumulator['variables'].items():
-        plot_data_mc_hist1D(
-            h,
-            histname,
-            config,
-            plot_dir=args.plot_dir,
-            flavorsplit=None,
-            only_cat=args.only_cat,
-            mcstat=True,
-            stat_only=False,
-            split_systematics=args.split_systematics,
-            only_syst=args.only_syst,
-            partial_unc_band=args.partial_unc_band,
-            log=args.log)
+    plotter = PlotManager(
+        hist_cfg=_accumulator['variables'],
+        plot_dir=config.plots,
+        style_cfg=style_cfg,
+        only_cat=args.only_cat,
+        data_key=args.data_key,
+        log=args.log,
+        density=args.density,
+        save=True
+    )
+    plotter.plot_datamc_all(ratio=True, syst=True, spliteras=False)
 
 # Filter dictionary of histograms with `args.only`
 accumulator['variables'] = { k : v for k,v in accumulator['variables'].items() if args.only in k }
@@ -96,6 +93,7 @@ print("Histograms to plot:", HistsToPlot)
 delimiters = np.linspace(0, NtotHists, args.workers + 1).astype(int)
 chunks = [(delimiters[i], delimiters[i+1]) for i in range(len(delimiters[:-1]))]
 pool = Pool()
+# Parallel calls of make_plots on different subsets of histograms
 pool.starmap(make_plots, chunks)
 pool.close()