diff --git a/binder/packedselection.ipynb b/binder/packedselection.ipynb
index b042a15b8..3dfed551c 100644
--- a/binder/packedselection.ipynb
+++ b/binder/packedselection.ipynb
@@ -22,38 +22,53 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/Users/iason/fun/coffea_dev/coffea/binder/coffea/nanoevents/schemas/nanoaod.py:215: RuntimeWarning: Missing cross-reference index for FatJet_genJetAK8Idx => GenJetAK8\n",
+      "/Users/nmangane/scikit-hep-dev-2/coffea/src/coffea/nanoevents/schemas/fcc.py:5: FutureWarning: In version 2025.1.0 (target date: 2024-12-31 11:59:59-06:00), this will be an error.\n",
+      "To raise these warnings as errors (and get stack traces to find out where they're called), run\n",
+      "    import warnings\n",
+      "    warnings.filterwarnings(\"error\", module=\"coffea.*\")\n",
+      "after the first `import coffea` or use `@pytest.mark.filterwarnings(\"error:::coffea.*\")` in pytest.\n",
+      "Issue: coffea.nanoevents.methods.vector will be removed and replaced with scikit-hep vector. Nanoevents schemas internal to coffea will be migrated. Otherwise please consider using that package!.\n",
+      "  from coffea.nanoevents.methods import vector\n",
+      "/Users/nmangane/scikit-hep-dev-2/coffea/src/coffea/nanoevents/schemas/nanoaod.py:264: RuntimeWarning: Missing cross-reference index for LowPtElectron_electronIdx => Electron\n",
+      "  warnings.warn(\n",
+      "/Users/nmangane/scikit-hep-dev-2/coffea/src/coffea/nanoevents/schemas/nanoaod.py:264: RuntimeWarning: Missing cross-reference index for LowPtElectron_genPartIdx => GenPart\n",
+      "  warnings.warn(\n",
+      "/Users/nmangane/scikit-hep-dev-2/coffea/src/coffea/nanoevents/schemas/nanoaod.py:264: RuntimeWarning: Missing cross-reference index for LowPtElectron_photonIdx => Photon\n",
+      "  warnings.warn(\n",
+      "/Users/nmangane/scikit-hep-dev-2/coffea/src/coffea/nanoevents/schemas/nanoaod.py:264: RuntimeWarning: Missing cross-reference index for FatJet_genJetAK8Idx => GenJetAK8\n",
       "  warnings.warn(\n"
      ]
     },
     {
      "data": {
       "text/html": [
-       "<pre>[{FsrPhoton: [], Electron: [], SoftActivityJetHT5: 63.5, RawMET: {...}, ...},\n",
-       " {FsrPhoton: [], Electron: [{...}], SoftActivityJetHT5: 64, RawMET: {...}, ...},\n",
-       " {FsrPhoton: [], Electron: [Electron, Electron], SoftActivityJetHT5: 130, ...},\n",
-       " {FsrPhoton: [], Electron: [Electron, Electron], SoftActivityJetHT5: 25.8, ...},\n",
-       " {FsrPhoton: [], Electron: [], SoftActivityJetHT5: 172, RawMET: {...}, ...},\n",
-       " {FsrPhoton: [], Electron: [{...}], SoftActivityJetHT5: 54.4, RawMET: ..., ...},\n",
-       " {FsrPhoton: [], Electron: [{...}], SoftActivityJetHT5: 96.2, RawMET: ..., ...},\n",
-       " {FsrPhoton: [], Electron: [], SoftActivityJetHT5: 19, RawMET: {...}, ...},\n",
-       " {FsrPhoton: [], Electron: [], SoftActivityJetHT5: 9.36, RawMET: {...}, ...},\n",
-       " {FsrPhoton: [], Electron: [{...}], SoftActivityJetHT5: 115, RawMET: ..., ...},\n",
+       "<pre>[{SubJet: [], OtherPV: [{z: -2.23}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: -3.48}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: 5.86}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: -1.46}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: 1.15}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: -3.95}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: 0.15}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: -3.04}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: 4.33}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: 1.26}, ..., {...}], ...},\n",
        " ...,\n",
-       " {FsrPhoton: [], Electron: [{...}], SoftActivityJetHT5: 49.6, RawMET: ..., ...},\n",
-       " {FsrPhoton: [], Electron: [], SoftActivityJetHT5: 14.7, RawMET: {...}, ...},\n",
-       " {FsrPhoton: [], Electron: [{...}], SoftActivityJetHT5: 22.1, RawMET: ..., ...},\n",
-       " {FsrPhoton: [], Electron: [], SoftActivityJetHT5: 33.9, RawMET: {...}, ...},\n",
-       " {FsrPhoton: [], Electron: [{...}], SoftActivityJetHT5: 16.2, RawMET: ..., ...},\n",
-       " {FsrPhoton: [], Electron: [], SoftActivityJetHT5: 28.4, RawMET: {...}, ...},\n",
-       " {FsrPhoton: [], Electron: [{...}], SoftActivityJetHT5: 16.1, RawMET: ..., ...},\n",
-       " {FsrPhoton: [], Electron: [], SoftActivityJetHT5: 28.5, RawMET: {...}, ...},\n",
-       " {FsrPhoton: [], Electron: [], SoftActivityJetHT5: 7, RawMET: {...}, ...}]\n",
-       "--------------------------------------------------------------------------------\n",
+       " {SubJet: [], OtherPV: [{z: -1.91}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: -5.22}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: -1.17}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: 0.758}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: 7.16}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: -3.6}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: -2.92}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: 3.41}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: 3.27}, ..., {...}], ...}]\n",
+       "------------------------------------------------------\n",
+       "backend: cpu\n",
+       "nbytes: 243.3 kB\n",
        "type: 40 * event</pre>"
       ],
       "text/plain": [
-       "<NanoEventsArray [<event 1:13889:3749778>, ...] type='40 * event'>"
+       "<NanoEventsArray [<event 1:                13889:                3749778>, ...] type='...'>"
       ]
      },
      "execution_count": 1,
@@ -67,12 +82,12 @@
     "from coffea.nanoevents import NanoEventsFactory, NanoAODSchema\n",
     "from matplotlib import pyplot as plt\n",
     "\n",
-    "\n",
+    "fname = \"https://raw.githubusercontent.com/scikit-hep/coffea/master/tests/samples/nano_dy.root\"\n",
     "events = NanoEventsFactory.from_root(\n",
-    "    {\"../tests/samples/nano_dy.root\": \"Events\"},\n",
+    "    {fname: \"Events\"},\n",
     "    metadata={\"dataset\": \"nano_dy\"},\n",
     "    schemaclass=NanoAODSchema,\n",
-    "    permit_dask=False,\n",
+    "    delayed=False,\n",
     ").events()\n",
     "\n",
     "events"
@@ -354,7 +369,7 @@
      "data": {
       "text/plain": [
        "(['initial', 'N - twoElectron', 'N - noMuon', 'N - leadPt20', 'N'],\n",
-       " [40, 10, 3, 5, 3],\n",
+       " [40, np.int64(10), np.int64(3), np.int64(5), np.int64(3)],\n",
        " [array([False,  True,  True, False, False, False, False, False, False,\n",
        "          True, False, False, False, False, False,  True,  True, False,\n",
        "         False, False,  True,  True, False, False, False, False, False,\n",
@@ -411,10 +426,10 @@
      "output_type": "stream",
      "text": [
       "N-1 selection stats:\n",
-      "Ignoring twoElectron         : pass = 10                                  all = 40                                  -- eff = 25.0 %\n",
-      "Ignoring noMuon              : pass = 3                                   all = 40                                  -- eff = 7.5 %\n",
-      "Ignoring leadPt20            : pass = 5                                   all = 40                                  -- eff = 12.5 %\n",
-      "All cuts                     : pass = 3                                   all = 40                                  -- eff = 7.5 %\n"
+      "Ignoring twoElectron         pass = 10                  all = 40                  -- eff = 25.0 %\n",
+      "Ignoring noMuon              pass = 3                   all = 40                  -- eff = 7.5 %\n",
+      "Ignoring leadPt20            pass = 5                   all = 40                  -- eff = 12.5 %\n",
+      "All cuts                     pass = 3                   all = 40                  -- eff = 7.5 %\n"
      ]
     }
    ],
@@ -442,7 +457,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -498,8 +513,7 @@
     }
    ],
    "source": [
-    "nminusone.to_npz(\"nminusone_results.npz\")\n",
-    "\n",
+    "nminusone.to_npz(\"nminusone_results.npz\").compute()\n",
     "with np.load(\"nminusone_results.npz\") as f:\n",
     "    for i in f.files:\n",
     "        print(f\"{i}: {f[i]}\")"
@@ -533,7 +547,7 @@
        "([Hist(\n",
        "    Regular(20, 5.81891, 60.0685, name='Ept'),\n",
        "    Integer(0, 5, name='N-1'),\n",
-       "    storage=Double()) # Sum: 60.0,\n",
+       "    storage=Double()) # Sum: 55.0 (60.0 with flow),\n",
        "  Hist(\n",
        "    Regular(20, -2.93115, 3.11865, name='Ephi'),\n",
        "    Integer(0, 5, name='N-1'),\n",
@@ -571,9 +585,9 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 640x480 with 2 Axes>"
+       "<Figure size 684.8x480 with 2 Axes>"
       ]
      },
      "metadata": {},
@@ -581,9 +595,9 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 640x480 with 2 Axes>"
+       "<Figure size 684.8x480 with 2 Axes>"
       ]
      },
      "metadata": {},
@@ -615,7 +629,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -654,7 +668,7 @@
       "\n",
       "plot_vars(vars, axes=None, bins=None, start=None, stop=None, edges=None, transform=None) method of coffea.analysis_tools.NminusOne instance\n",
       "    Plot the histograms of variables for each step of the N-1 selection\n",
-      "    \n",
+      "\n",
       "    Parameters\n",
       "    ----------\n",
       "        vars : dict\n",
@@ -679,7 +693,7 @@
       "        transform : iterable of hist.axis.transform objects or Nones, optional\n",
       "            The transforms to apply to each variable histogram axis. If not specified, it defaults to None.\n",
       "            Must be the same length as ``vars``.\n",
-      "    \n",
+      "\n",
       "    Returns\n",
       "    -------\n",
       "        hists : list of hist.Hist or hist.dask.Hist objects\n",
@@ -718,7 +732,7 @@
     {
      "data": {
       "text/plain": [
-       "Cutflow(selections=('noMuon', 'twoElectron', 'leadPt20'))"
+       "Cutflow(selections=('noMuon', 'twoElectron', 'leadPt20'), commonmasked=False, weighted=False, weightsmodifier=None)"
       ]
      },
      "execution_count": 19,
@@ -761,8 +775,8 @@
      "data": {
       "text/plain": [
        "(['initial', 'noMuon', 'twoElectron', 'leadPt20'],\n",
-       " [40, 28, 5, 17],\n",
-       " [40, 28, 5, 3],\n",
+       " [40, np.int64(28), np.int64(5), np.int64(17)],\n",
+       " [40, np.int64(28), np.int64(5), np.int64(3)],\n",
        " [array([ True,  True,  True,  True, False, False, False,  True,  True,\n",
        "          True, False,  True,  True,  True, False,  True,  True,  True,\n",
        "          True,  True,  True,  True,  True, False, False,  True, False,\n",
@@ -832,9 +846,9 @@
      "output_type": "stream",
      "text": [
       "Cutflow stats:\n",
-      "Cut noMuon              : pass = 28                                  cumulative pass = 28                                  all = 40                                  --  eff = 70.0 %                -- cumulative eff = 70.0 %\n",
-      "Cut twoElectron         : pass = 5                                   cumulative pass = 5                                   all = 40                                  --  eff = 12.5 %                -- cumulative eff = 12.5 %\n",
-      "Cut leadPt20            : pass = 17                                  cumulative pass = 3                                   all = 40                                  --  eff = 42.5 %                -- cumulative eff = 7.5 %\n"
+      "Cut noMuon              :pass = 28                  cumulative pass = 28                  all = 40                  -- eff = 70.0 %                    -- cumulative eff = 70.0 %\n",
+      "Cut twoElectron         :pass = 5                   cumulative pass = 5                   all = 40                  -- eff = 12.5 %                    -- cumulative eff = 12.5 %\n",
+      "Cut leadPt20            :pass = 17                  cumulative pass = 3                   all = 40                  -- eff = 42.5 %                    -- cumulative eff = 7.5 %\n"
      ]
     }
    ],
@@ -862,7 +876,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -872,7 +886,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -944,7 +958,7 @@
     }
    ],
    "source": [
-    "cutflow.to_npz(\"cutflow_results.npz\")\n",
+    "cutflow.to_npz(\"cutflow_results.npz\").compute()\n",
     "\n",
     "with np.load(\"cutflow_results.npz\") as f:\n",
     "    for i in f.files:\n",
@@ -976,7 +990,7 @@
        "([Hist(\n",
        "    Regular(20, 5.81891, 60.0685, name='ept'),\n",
        "    Integer(0, 4, name='onecut'),\n",
-       "    storage=Double()) # Sum: 73.0,\n",
+       "    storage=Double()) # Sum: 69.0 (73.0 with flow),\n",
        "  Hist(\n",
        "    Regular(20, -2.93115, 3.11865, name='ephi'),\n",
        "    Integer(0, 4, name='onecut'),\n",
@@ -984,7 +998,7 @@
        " [Hist(\n",
        "    Regular(20, 5.81891, 60.0685, name='ept'),\n",
        "    Integer(0, 4, name='cutflow'),\n",
-       "    storage=Double()) # Sum: 63.0,\n",
+       "    storage=Double()) # Sum: 59.0 (63.0 with flow),\n",
        "  Hist(\n",
        "    Regular(20, -2.93115, 3.11865, name='ephi'),\n",
        "    Integer(0, 4, name='cutflow'),\n",
@@ -1004,6 +1018,476 @@
     "h1, h2, labels"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "153f43de",
+   "metadata": {},
+   "source": [
+    "# Weighted Cutflows\n",
+    "It's also possible to apply per-event weights to a cutflow by passing in a Weights instance, along with the `weightsmodifier` (None or the string name of the variation you want applied)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "a92ff201",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Cutflow(selections=('noMuon', 'twoElectron', 'leadPt20'), commonmasked=False, weighted=True, weightsmodifier=None)"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from coffea.analysis_tools import Weights\n",
+    "\n",
+    "weights = Weights(len(events))\n",
+    "weights.add(\"genweight\", events.genWeight)\n",
+    "\n",
+    "wgtcutflow = selection.cutflow(\"noMuon\", \"twoElectron\", \"leadPt20\", weights=weights, weightsmodifier=None)\n",
+    "wgtcutflow"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "7dee4181",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'coffea.analysis_tools.ExtendedCutflowResult'> ('labels', 'nevonecut', 'nevcutflow', 'masksonecut', 'maskscutflow', 'commonmask', 'wgtevonecut', 'wgtevcutflow', 'weights', 'weightsmodifier')\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(['initial', 'noMuon', 'twoElectron', 'leadPt20'],\n",
+       " [40, np.int64(28), np.int64(5), np.int64(17)],\n",
+       " [40, np.int64(28), np.int64(5), np.int64(3)],\n",
+       " [array([ True,  True,  True,  True, False, False, False,  True,  True,\n",
+       "          True, False,  True,  True,  True, False,  True,  True,  True,\n",
+       "          True,  True,  True,  True,  True, False, False,  True, False,\n",
+       "          True, False,  True, False, False,  True,  True, False,  True,\n",
+       "          True,  True,  True,  True]),\n",
+       "  array([False, False,  True,  True, False, False, False, False, False,\n",
+       "         False, False, False, False, False, False, False, False, False,\n",
+       "          True, False,  True,  True, False, False, False, False, False,\n",
+       "         False, False, False, False, False, False, False, False, False,\n",
+       "         False, False, False, False]),\n",
+       "  array([False,  True,  True, False,  True,  True,  True, False, False,\n",
+       "          True, False, False, False, False, False,  True,  True, False,\n",
+       "         False, False,  True,  True, False,  True,  True, False,  True,\n",
+       "          True, False,  True, False,  True, False,  True, False, False,\n",
+       "         False, False, False, False])],\n",
+       " [array([ True,  True,  True,  True, False, False, False,  True,  True,\n",
+       "          True, False,  True,  True,  True, False,  True,  True,  True,\n",
+       "          True,  True,  True,  True,  True, False, False,  True, False,\n",
+       "          True, False,  True, False, False,  True,  True, False,  True,\n",
+       "          True,  True,  True,  True]),\n",
+       "  array([False, False,  True,  True, False, False, False, False, False,\n",
+       "         False, False, False, False, False, False, False, False, False,\n",
+       "          True, False,  True,  True, False, False, False, False, False,\n",
+       "         False, False, False, False, False, False, False, False, False,\n",
+       "         False, False, False, False]),\n",
+       "  array([False, False,  True, False, False, False, False, False, False,\n",
+       "         False, False, False, False, False, False, False, False, False,\n",
+       "         False, False,  True,  True, False, False, False, False, False,\n",
+       "         False, False, False, False, False, False, False, False, False,\n",
+       "         False, False, False, False])],\n",
+       " None,\n",
+       " [np.float64(578762.435546875),\n",
+       "  np.float64(315450.423828125),\n",
+       "  np.float64(25807.2109375),\n",
+       "  np.float64(237244.12109375)],\n",
+       " [np.float64(578762.435546875),\n",
+       "  np.float64(315450.423828125),\n",
+       "  np.float64(25807.2109375),\n",
+       "  np.float64(26331.201171875)],\n",
+       " <coffea.analysis_tools.Weights at 0x13dcdf290>,\n",
+       " None)"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "res = wgtcutflow.result()\n",
+    "print(type(res), res._fields)\n",
+    "(labels, nevonecut, nevcutflow, \n",
+    " masksonecut, maskscutflow, \n",
+    " commonmask, \n",
+    " wgtevonecut, wgtevcutflow,\n",
+    " rweights,rmod\n",
+    ") = res\n",
+    "labels, nevonecut, nevcutflow, masksonecut, maskscutflow, commonmask, wgtevonecut, wgtevcutflow, rweights,rmod"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b6c92745",
+   "metadata": {},
+   "source": [
+    "The weighted cutflow by default prints with weights if included, but passing `weighted=False` or `weighted=True` allows one to explicitly toggle between the two. Additionally, the keyword `scale` permits one to scale all value uniformly, such as with a cross-section, luminosity, sum of weights, etc."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "952a5662",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cutflow stats: (weighted)\n",
+      "Cut noMuon              :pass = 315450.423828125    cumulative pass = 315450.423828125    all = 578762.435546875    -- eff = 54.5 %                    -- cumulative eff = 54.5 %\n",
+      "Cut twoElectron         :pass = 25807.2109375       cumulative pass = 25807.2109375       all = 578762.435546875    -- eff = 4.5 %                    -- cumulative eff = 4.5 %\n",
+      "Cut leadPt20            :pass = 237244.12109375     cumulative pass = 26331.201171875     all = 578762.435546875    -- eff = 41.0 %                    -- cumulative eff = 4.5 %\n"
+     ]
+    }
+   ],
+   "source": [
+    "wgtcutflow.print()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "552df1d2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cutflow stats:\n",
+      "Cut noMuon              :pass = 28                  cumulative pass = 28                  all = 40                  -- eff = 70.0 %                    -- cumulative eff = 70.0 %\n",
+      "Cut twoElectron         :pass = 5                   cumulative pass = 5                   all = 40                  -- eff = 12.5 %                    -- cumulative eff = 12.5 %\n",
+      "Cut leadPt20            :pass = 17                  cumulative pass = 3                   all = 40                  -- eff = 42.5 %                    -- cumulative eff = 7.5 %\n"
+     ]
+    }
+   ],
+   "source": [
+    "wgtcutflow.print(weighted=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "2b4b06b3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cutflow stats: (weighted) (scaled by 0.0008639129728627657)\n",
+      "Cut noMuon              :pass = 272.5217134401749   cumulative pass = 272.5217134401749   all = 500.0003762745956   -- eff = 54.5 %                    -- cumulative eff = 54.5 %\n",
+      "Cut twoElectron         :pass = 22.295184322312107  cumulative pass = 22.295184322312107  all = 500.0003762745956   -- eff = 4.5 %                    -- cumulative eff = 4.5 %\n",
+      "Cut leadPt20            :pass = 204.95827394831554  cumulative pass = 22.74786628344207   all = 500.0003762745956   -- eff = 41.0 %                    -- cumulative eff = 4.5 %\n"
+     ]
+    }
+   ],
+   "source": [
+    "wgtcutflow.print(weighted=True, scale=500/578762)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e89c75df",
+   "metadata": {},
+   "source": [
+    "The histograms are now by default weighted, but like the print function this can be explicitly toggled between using `weighted=True|False.`There's no option to scale the histograms by a scalar, this is left to a user to do so afterwards."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "cc9c15b1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHnCAYAAABUnjLAAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAQdtJREFUeJzt3QucznX+///XYGaYNE7llGMpIhHWobNSU6lvbX6lspJQyiqpWJtD29YqbRvlULvaZTflsB0dIkt0MA6REpKiJYxjMyQG4/O/Pd/7/3xu10iZEa6ZeT/ut9u111zX5z3XvNen6/o8r/cxIQiCwAAAADxULN4VAAAAiBeCEAAA8BZBCAAAeIsgBAAAvEUQAgAA3iIIAQAAbxGEAACAtwhCAADAWyXiXYGC7ODBg7Zx40Y7+eSTLSEhId7VAQAAeaC1onft2mVVq1a1YsV+vs2HIPQzFIKqV68e72oAAICjsH79eqtWrdqxDUIbNmywvn372jvvvGM//PCD1alTx/7xj39Ys2bNohQ2aNAg+9vf/maZmZl2wQUX2KhRo+zMM8+MXmPHjh3Ws2dPmzx5sktq7dq1s2HDhlnp0qWjMp999pn16NHDFi1aZKeeeqor36dPn1x1mTRpkg0YMMC++eYb9/pPPfWUXXPNNdHxvNTl56glKPyHTE1Nze8/FQAAiIOdO3e6hozwOv6zgnzYsWNHULNmzeCOO+4IFixYEKxZsyaYMWNG8NVXX0VlnnzyyaBMmTLBm2++GXz66afB//3f/wW1a9cO9uzZE5W56qqrgkaNGgXz588PPvjgg6BOnTrBrbfeGh3PysoKKlWqFHTo0CH4/PPPg1dffTUoVapU8OKLL0ZlPvroo6B48eLBkCFDghUrVgT9+/cPEhMTg2XLluWrLj9H9dA/ke4BAEDhkJ/rd76CUN++fYMLL7zwJ48fPHgwqFy5cvD0009Hz2VmZgbJyckuzIhCiyq3aNGiqMw777wTJCQkBBs2bHCPR44cGZQrVy7Izs7O9bfr1q0bPb755puDtm3b5vr7LVq0CO6+++481+VICEIAABQ++bl+52vW2Ntvv+26wG666SarWLGinXfeea7bKbR27VrLyMiwNm3aRM+VKVPGWrRoYenp6e6x7suWLRt1pYnKq4tswYIFUZmLL77YkpKSojJpaWm2atUq++6776IysX8nLBP+nbzU5VDZ2dmuOS32BgAAiq58BaE1a9ZEY2xmzJhh99xzj9133302duxYd1zBQypVqpTr9/Q4PKZ7hahYJUqUsPLly+cqc7jXiP0bP1Um9viR6nKowYMHu7AU3hgoDQBA0VYsv9PJmzRpYn/6059ca9Bdd91l3bp1sxdeeMGKgn79+llWVlZ00yBpAABQdOUrCFWpUsXq16+f67mzzz7b1q1b536uXLmyu9+8eXOuMnocHtP9li1bch0/cOCAm0kWW+ZwrxH7N36qTOzxI9XlUMnJyW52WOwNAAAUXfkKQpp+rnE6sb788kurWbOm+7l27douZMyaNSs6rnE2GvvTqlUr91j3msq+ePHiqMzs2bNda5PG74Rl3n//fdu/f39UZubMmVa3bl0rV65cVCb274Rlwr+Tl7oAAADP5WcU9sKFC4MSJUoETzzxRLB69epg3LhxQUpKSvDyyy/nmrJetmzZ4K233go+++yz4Prrrz/s9PnzzjvPTcH/8MMPgzPPPDPX9HnN7tL0+Y4dO7rp8+PHj3d/59Dp86rLn//852DlypXBoEGDDjt9/kh1+TnMGgMAoPA5btPnZfLkycE555zjpqHXq1cv+Otf/5rruKatDxgwwAUZlbn88suDVatW5Sqzfft2F3xKly4dpKamBp07dw527dqVq4zW/dFUfb3Gaaed5kLNoSZOnBicddZZQVJSUtCgQYNg6tSp+a7LzyEIAQBQ+OTn+p2g/4l3q1RBpa40zR7TwGnGCwEAUPSu3+w+DwAAvEUQAgAA3iIIAQAAbxGEAACAt0rEuwI+0vj0Pftz4l0NHCOlEotbQkJCvKsBADgKBKE4UAiqP3BGvKuBY2TFY2mWksRbCQAKI7rGAACAt/gaG2cf929jKUnF410N5NMP+3Ks2eP/iXc1AAC/EEEozhSC6FYBACA+6BoDAADeIggBAABvEYQAAIC3CEIAAMBbBCEAAOAtghAAAPAWQQgAAHiLIAQAALxFEAIAAN4iCAEAAG8RhAAAgLcIQgAAwFsEIQAA4C2CEAAA8BZBCAAAeIsgBAAAvEUQAgAA3iIIAQAAbxGEAACAtwhCAADAWwQhAADgLYIQAADwFkEIAAB4iyAEAAC8RRACAADeIggBAABvEYQAAIC3CEIAAMBbBCEAAOAtghAAAPAWQQgAAHiLIAQAALxFEAIAAN4iCAEAAG8RhAAAgLcIQgAAwFsEIQAA4C2CEAAA8BZBCAAAeIsgBAAAvEUQAgAA3spXEHr00UctISEh161evXrR8b1791qPHj2sQoUKVrp0aWvXrp1t3rw512usW7fO2rZtaykpKVaxYkV7+OGH7cCBA7nKzJkzx5o0aWLJyclWp04dGzNmzI/qMmLECKtVq5aVLFnSWrRoYQsXLsx1PC91AQAAfst3i1CDBg1s06ZN0e3DDz+Mjj3wwAM2efJkmzRpks2dO9c2btxoN954Y3Q8JyfHhaB9+/bZvHnzbOzYsS7kDBw4MCqzdu1aV6Z169a2dOlS69Wrl3Xt2tVmzJgRlZkwYYL17t3bBg0aZEuWLLFGjRpZWlqabdmyJc91AQAAsCAfBg0aFDRq1OiwxzIzM4PExMRg0qRJ0XMrV64M9CfS09Pd42nTpgXFihULMjIyojKjRo0KUlNTg+zsbPe4T58+QYMGDXK9dvv27YO0tLTocfPmzYMePXpEj3NycoKqVasGgwcPznNdDmfv3r1BVlZWdFu/fr37Hf18LO3O3h/U7DvF3fQzCh/OIQAUXLpu5/X6ne8WodWrV1vVqlXt9NNPtw4dOriuLlm8eLHt37/f2rRpE5VVt1mNGjUsPT3dPdZ9w4YNrVKlSlEZteTs3LnTli9fHpWJfY2wTPgaak3S34otU6xYMfc4LJOXuhzO4MGDrUyZMtGtevXq+f3nAQAAhUi+gpDG4qgra/r06TZq1CjXjXXRRRfZrl27LCMjw5KSkqxs2bK5fkehR8dE97EhKDweHvu5MgpLe/bssW3btrkutsOViX2NI9XlcPr162dZWVnRbf369fn55wEAAIVMifwUvvrqq6Ofzz33XBeMatasaRMnTrRSpUpZYafB2boBAAA//KLp82pxOeuss+yrr76yypUru26rzMzMXGU0U0vHRPeHztwKHx+pTGpqqgtbp5xyihUvXvywZWJf40h1AQAA+EVB6Pvvv7evv/7aqlSpYk2bNrXExESbNWtWdHzVqlVuDFGrVq3cY90vW7Ys1+yumTNnupBTv379qEzsa4RlwtdQl5f+VmyZgwcPusdhmbzUBQAAIF9dYw899JBdd911rjtM09E1fV2tM7feeqsbXNylSxc3rb18+fIu3PTs2dMFj5YtW7rfv/LKK13g6dixow0ZMsSN1+nfv79b7yfskurevbsNHz7c+vTpY3feeafNnj3bdb1NnTo1qof+RqdOnaxZs2bWvHlzGzp0qO3evds6d+7sjuelLgAAAPkKQt9++60LPdu3b7dTTz3VLrzwQps/f777WZ599lk3g0uLF2ZnZ7vZXiNHjox+X6FpypQpds8997hQctJJJ7lA89hjj0Vlateu7UKP1gEaNmyYVatWzUaPHu1eK9S+fXvbunWrW39IYapx48ZuAHfsAOoj1QUAACBBc+jjXYmCSjPV1LqkGWRqVTpWfth3wOoP/N8CkSseS7OUpHzlURQAnEMAKBrXb/YaAwAA3iIIAQAAbxGEAACAtwhCAADAWwQhAADgLYIQAADwFkEIAAB4iyAEAAC8RRACAADeIggBAABvEYQAAIC3CEIAAMBbBCEAAOAtghAAAPAWQQgAAHiLIAQAALxFEAIAAN4iCAEAAG8RhAAAgLcIQgAAwFsEIQAA4C2CEAAA8BZBCAAAeIsgBAAAvEUQAgAA3iIIAQAAbxGEAACAtwhCAADAWwQhAADgLYIQAADwFkEIAAB4iyAEAAC8RRACAADeIggBAABvEYQAAIC3CEIAAMBbBCEAAOAtghAAAPAWQQgAAHiLIAQAALxFEAIAAN4iCAEAAG8RhAAAgLcIQgAAwFsEIQAA4C2CEAAA8BZBCAAAeIsgBAAAvEUQAgAA3iIIAQAAb/2iIPTkk09aQkKC9erVK3pu79691qNHD6tQoYKVLl3a2rVrZ5s3b871e+vWrbO2bdtaSkqKVaxY0R5++GE7cOBArjJz5syxJk2aWHJystWpU8fGjBnzo78/YsQIq1WrlpUsWdJatGhhCxcuzHU8L3UBAAD+OuogtGjRInvxxRft3HPPzfX8Aw88YJMnT7ZJkybZ3LlzbePGjXbjjTdGx3NyclwI2rdvn82bN8/Gjh3rQs7AgQOjMmvXrnVlWrdubUuXLnVBq2vXrjZjxoyozIQJE6x37942aNAgW7JkiTVq1MjS0tJsy5Ytea4LAADwXHAUdu3aFZx55pnBzJkzg0suuSS4//773fOZmZlBYmJiMGnSpKjsypUrA/2Z9PR093jatGlBsWLFgoyMjKjMqFGjgtTU1CA7O9s97tOnT9CgQYNcf7N9+/ZBWlpa9Lh58+ZBjx49osc5OTlB1apVg8GDB+e5Lofau3dvkJWVFd3Wr1/vyuvnY2l39v6gZt8p7qafUfhwDgGg4NJ1O6/X76NqEVJ3k1ps2rRpk+v5xYsX2/79+3M9X69ePatRo4alp6e7x7pv2LChVapUKSqjlpydO3fa8uXLozKHvrbKhK+h1iT9rdgyxYoVc4/DMnmpy6EGDx5sZcqUiW7Vq1c/mn8eAABQSOQ7CI0fP951RSk0HCojI8OSkpKsbNmyuZ5X6NGxsExsCAqPh8d+rozC0p49e2zbtm2ui+1wZWJf40h1OVS/fv0sKysruq1fvz7P/y4AAKDwKZGfwgoG999/v82cOdMNUC5qNDBbNwAA4Id8tQipu0mDkTWbq0SJEu6mQcjPPfec+1mtLeq2yszMzPV7mqlVuXJl97PuD525FT4+UpnU1FQrVaqUnXLKKVa8ePHDlol9jSPVBQAA+C1fQejyyy+3ZcuWuZlc4a1Zs2bWoUOH6OfExESbNWtW9DurVq1y0+VbtWrlHuterxE7u0stTAo59evXj8rEvkZYJnwNdXk1bdo0V5mDBw+6x2EZHT9SXQAAgN/y1TV28skn2znnnJPruZNOOsmt0xM+36VLFzetvXz58i7c9OzZ0wWPli1buuNXXnmlCzwdO3a0IUOGuPE6/fv3dwOww26p7t272/Dhw61Pnz5255132uzZs23ixIk2derU6O/qb3Tq1MmFr+bNm9vQoUNt9+7d1rlzZ3dcg52PVBcAAOC3fAWhvHj22WfdDC4tXpidne1me40cOTI6ri6tKVOm2D333ONCiYKUAs1jjz0Wlaldu7YLPVoHaNiwYVatWjUbPXq0e61Q+/btbevWrW79IYWpxo0b2/Tp03MNoD5SXQAAgN8SNIc+3pUoqDRLTS1LmkGmFqVj5Yd9B6z+wP8tDrnisTRLSTrmeRTHGecQAIrG9Zu9xgAAgLcIQgAAwFsEIQAA4C2CEAAA8BZBCAAAeIsgBAAAvEUQAgAA3iIIAQAAbxGEAACAtwhCAADAWwQhAADgLYIQAADwFkEIAAB4iyAEAAC8RRACAADeIggBAABvEYQAAIC3CEIAAMBbBCEAAOAtghAAAPAWQQgAAHiLIAQAALxFEAIAAN4iCAEAAG8RhAAAgLcIQgAAwFsEIQAA4C2CEAAA8BZBCAAAeIsgBAAAvEUQAgAA3iIIAQAAbxGEAACAtwhCAADAWwQhAADgLYIQAADwFkEIAAB4iyAEAAC8RRACAADeIggBAABvEYQAAIC3CEIAAMBbJeJdAaCw+2FfTryrgF+gVGJxS0hIiHc1AMQJQQj4hZo9/p94VwG/wIrH0iwliY9CwFd0jQEAAG/xNQg4yu4UtSSg8HZn0pIHQAhCwFHQmBK6UwCg8KNrDAAAeIsgBAAAvJWvIDRq1Cg799xzLTU11d1atWpl77zzTnR879691qNHD6tQoYKVLl3a2rVrZ5s3b871GuvWrbO2bdtaSkqKVaxY0R5++GE7cOBArjJz5syxJk2aWHJystWpU8fGjBnzo7qMGDHCatWqZSVLlrQWLVrYwoULcx3PS10AAIDf8hWEqlWrZk8++aQtXrzYPv74Y7vsssvs+uuvt+XLl7vjDzzwgE2ePNkmTZpkc+fOtY0bN9qNN94Y/X5OTo4LQfv27bN58+bZ2LFjXcgZOHBgVGbt2rWuTOvWrW3p0qXWq1cv69q1q82YMSMqM2HCBOvdu7cNGjTIlixZYo0aNbK0tDTbsmVLVOZIdQEAALDgFypXrlwwevToIDMzM0hMTAwmTZoUHVu5cmWgP5Genu4eT5s2LShWrFiQkZERlRk1alSQmpoaZGdnu8d9+vQJGjRokOtvtG/fPkhLS4seN2/ePOjRo0f0OCcnJ6hatWowePBg9zgvdcmLrKws9zu6P5Z2Z+8Pavad4m76GcCJxXsQKNqy8nH9PuoxQmrdGT9+vO3evdt1kamVaP/+/damTZuoTL169axGjRqWnp7uHuu+YcOGVqlSpaiMWnJ27twZtSqpTOxrhGXC11Brkv5WbJlixYq5x2GZvNTlcLKzs11dYm8AAKDoyncQWrZsmRtzo/E73bt3tzfeeMPq169vGRkZlpSUZGXLls1VXqFHx0T3sSEoPB4e+7kyCiV79uyxbdu2uRB2uDKxr3GkuhzO4MGDrUyZMtGtevXq+f3nAQAARTkI1a1b143dWbBggd1zzz3WqVMnW7FihRUF/fr1s6ysrOi2fv36eFcJAAAcR/leEU4tLZrJJU2bNrVFixbZsGHDrH379q7bKjMzM1dLjGZqVa5c2f2s+0Nnd4UzuWLLHDq7S481S61UqVJWvHhxdztcmdjXOFJdDketXLoBAAA//OJ1hA4ePOjG1igUJSYm2qxZs6Jjq1atctPlNYZIdK+utdjZXTNnznQhR91rYZnY1wjLhK+hIKa/FVtGddDjsExe6gIAAFAiv11HV199tRt0vGvXLnvllVfcmj+a2q4xNV26dHHT2suXL+/CTc+ePV3waNmypfv9K6+80gWejh072pAhQ9x4nf79+7v1fsKWGI07Gj58uPXp08fuvPNOmz17tk2cONGmTp0a1UN/Q11yzZo1s+bNm9vQoUPdoO3OnTu743mpCwAAQL6CkFpybr/9dtu0aZMLG1pcUSHoiiuucMefffZZN4NLixeqlUizvUaOHBn9vrq0pkyZ4sYWKZScdNJJLtA89thjUZnatWu70KN1gNTlprWLRo8e7V4rpG64rVu3uvWHFKYaN25s06dPzzWA+kh1AQAASNAc+nhXoqDSTDUFPg2cVqvSsfLDvgNWf+D/FojUDuYpbN4JnFC8B4GibWc+rt/sNQYAALxFEAIAAN4iCAEAAG8RhAAAgLcIQgAAwFsEIQAA4C2CEAAA8BZBCAAAeIsgBAAAvEUQAgAA3iIIAQAAbxGEAACAtwhCAADAWwQhAADgLYIQAADwFkEIAAB4iyAEAAC8RRACAADeIggBAABvEYQAAIC3CEIAAMBbBCEAAOAtghAAAPAWQQgAAHiLIAQAALxFEAIAAN4iCAEAAG8RhAAAgLcIQgAAwFsEIQAA4C2CEAAA8BZBCAAAeIsgBAAAvEUQAgAA3iIIAQAAbxGEAACAtwhCAADAWwQhAADgLYIQAADwFkEIAAB4iyAEAAC8RRACAADeIggBAABvEYQAAIC3CEIAAMBbBCEAAOAtghAAAPAWQQgAAHiLIAQAALxFEAIAAN7KVxAaPHiw/epXv7KTTz7ZKlasaDfccIOtWrUqV5m9e/dajx49rEKFCla6dGlr166dbd68OVeZdevWWdu2bS0lJcW9zsMPP2wHDhzIVWbOnDnWpEkTS05Otjp16tiYMWN+VJ8RI0ZYrVq1rGTJktaiRQtbuHBhvusCAAD8la8gNHfuXBcs5s+fbzNnzrT9+/fblVdeabt3747KPPDAAzZ58mSbNGmSK79x40a78cYbo+M5OTkuBO3bt8/mzZtnY8eOdSFn4MCBUZm1a9e6Mq1bt7alS5dar169rGvXrjZjxoyozIQJE6x37942aNAgW7JkiTVq1MjS0tJsy5Ytea4LAADwXPALbNmyJdBLzJ071z3OzMwMEhMTg0mTJkVlVq5c6cqkp6e7x9OmTQuKFSsWZGRkRGVGjRoVpKamBtnZ2e5xnz59ggYNGuT6W+3btw/S0tKix82bNw969OgRPc7JyQmqVq0aDB48OM91OZKsrCxXXvfH0u7s/UHNvlPcTT8DOLF4DwJFW1Y+rt+/aIxQVlaWuy9fvry7X7x4sWslatOmTVSmXr16VqNGDUtPT3ePdd+wYUOrVKlSVEYtOTt37rTly5dHZWJfIywTvoZak/S3YssUK1bMPQ7L5KUuh8rOznb1iL0BAICi66iD0MGDB12X1QUXXGDnnHOOey4jI8OSkpKsbNmyucoq9OhYWCY2BIXHw2M/V0bBZM+ePbZt2zbXxXa4MrGvcaS6HG4MVJkyZaJb9erVj+rfBgAAFPEgpLFCn3/+uY0fP96Kin79+rlWrvC2fv36eFcJAAAcRyWO5pd++9vf2pQpU+z999+3atWqRc9XrlzZdVtlZmbmaonRTC0dC8scOrsrnMkVW+bQ2V16nJqaaqVKlbLixYu72+HKxL7GkepyKM1Q0w0AAPghXy1CQRC4EPTGG2/Y7NmzrXbt2rmON23a1BITE23WrFnRc5per+nyrVq1co91v2zZslyzuzQDTSGnfv36UZnY1wjLhK+hLi/9rdgy6qrT47BMXuoCAAD8ViK/3WGvvPKKvfXWW24toXCsjcbTqKVG9126dHHT2jWAWuGmZ8+eLni0bNnSldV0ewWejh072pAhQ9xr9O/f37122BrTvXt3Gz58uPXp08fuvPNOF7omTpxoU6dOjeqiv9GpUydr1qyZNW/e3IYOHeqm8Xfu3Dmq05HqAgAAPJef6WgqfrjbP/7xj6jMnj17gnvvvTcoV65ckJKSEvz6178ONm3alOt1vvnmm+Dqq68OSpUqFZxyyinBgw8+GOzfn3sK63vvvRc0btw4SEpKCk4//fRcfyP0/PPPBzVq1HBlNJ1+/vz5uY7npS4/h+nzQNHEexAo2rLycf1O0P/EO4wVVJqlppYlDZxWi9Kx8sO+A1Z/4P8Wh1zxWJqlJB3VUC0AR4n3IFC07czH9Zu9xgAAgLcIQgAAwFsEIQAA4C2CEAAA8BZBCAAAeIsgBAAAvEUQAgAA3iIIAQAAbxGEAACAtwhCAADAWwQhAADgLYIQAADwFkEIAAB4iyAEAAC8RRACAADeIggBAABvEYQAAIC3CEIAAMBbBCEAAOAtghAAAPAWQQgAAHiLIAQAALxFEAIAAN4iCAEAAG8RhAAAgLcIQgAAwFsEIQAA4C2CEAAA8BZBCAAAeIsgBAAAvEUQAgAA3iIIAQAAbxGEAACAtwhCAADAWwQhAADgLYIQAADwFkEIAAB4iyAEAAC8RRACAADeIggBAABvEYQAAIC3CEIAAMBbBCEAAOAtghAAAPAWQQgAAHiLIAQAALxFEAIAAN4iCAEAAG8RhAAAgLcIQgAAwFv5DkLvv/++XXfddVa1alVLSEiwN998M9fxIAhs4MCBVqVKFStVqpS1adPGVq9enavMjh07rEOHDpaammply5a1Ll262Pfff5+rzGeffWYXXXSRlSxZ0qpXr25Dhgz5UV0mTZpk9erVc2UaNmxo06ZNy3ddAACAv/IdhHbv3m2NGjWyESNGHPa4Astzzz1nL7zwgi1YsMBOOukkS0tLs71790ZlFIKWL19uM2fOtClTprhwddddd0XHd+7caVdeeaXVrFnTFi9ebE8//bQ9+uij9te//jUqM2/ePLv11ltdiPrkk0/shhtucLfPP/88X3UBAAAeC34B/fobb7wRPT548GBQuXLl4Omnn46ey8zMDJKTk4NXX33VPV6xYoX7vUWLFkVl3nnnnSAhISHYsGGDezxy5MigXLlyQXZ2dlSmb9++Qd26daPHN998c9C2bdtc9WnRokVw991357kuR5KVleXqqvtjaXf2/qBm3ynupp8BnFi8B4GiLSsf1+9jOkZo7dq1lpGR4bqgQmXKlLEWLVpYenq6e6x7dYc1a9YsKqPyxYoVc602YZmLL77YkpKSojJqyVm1apV99913UZnYvxOWCf9OXupyqOzsbNcaFXsDAABF1zENQgoeUqlSpVzP63F4TPcVK1bMdbxEiRJWvnz5XGUO9xqxf+OnysQeP1JdDjV48GAXlsKbxiYBAICii1ljMfr162dZWVnRbf369fGuEgAAKCxBqHLlyu5+8+bNuZ7X4/CY7rds2ZLr+IEDB9xMstgyh3uN2L/xU2Vijx+pLodKTk52M9libwAAoOg6pkGodu3aLmTMmjUrek7jbDT2p1WrVu6x7jMzM91ssNDs2bPt4MGDbvxOWEYzyfbv3x+V0QyzunXrWrly5aIysX8nLBP+nbzUBQAA+C3fQUjr/SxdutTdwkHJ+nndunVuXaFevXrZ448/bm+//bYtW7bMbr/9drfmkKa2y9lnn21XXXWVdevWzRYuXGgfffSR/fa3v7VbbrnFlZPbbrvNDZTW1HhNs58wYYINGzbMevfuHdXj/vvvt+nTp9szzzxjX3zxhZte//HHH7vXkrzUBQAAeC6/U9Lee+89NyXt0FunTp2iaesDBgwIKlWq5KaqX3755cGqVatyvcb27duDW2+9NShdunSQmpoadO7cOdi1a1euMp9++mlw4YUXutc47bTTgieffPJHdZk4cWJw1llnBUlJSUGDBg2CqVOn5jqel7r8HKbPA0UT70GgaMvKx/U7Qf8T7zBWUKkrTbPHNHD6WI4X+mHfAas/cIb7ecVjaZaSVOKYvTaAI+M9CBRtO/Nx/WbWGAAA8BZBCAAAeIsgBAAAvEUQAgAA3iIIAQAAbxGEAACAtwhCAADAWwQhAADgLYIQAADwFkEIAAB4iyAEAAC8RRACAADeIggBAABvEYQAAIC3CEIAAMBbBCEAAOAtghAAAPAWQQgAAHiLIAQAALxFEAIAAN4iCAEAAG8RhAAAgLcIQgAAwFsEIQAA4C2CEAAA8BZBCAAAeIsgBAAAvEUQAgAA3iIIAQAAbxGEAACAtwhCAADAWwQhAADgLYIQAADwFkEIAAB4iyAEAAC8RRACAADeKhHvCgBAPP2wLyfeVQC8VyqxuCUkJMTlbxOEAHit2eP/iXcVAO+teCzNUpLiE0noGgMAAN6iRQiAl83w+gYKIL7d0gWhRZYgBMA7GosQr2Z4AAULXWMAAMBbBCEAAOAtghAAAPAWQQgAAHiLIAQAALxFEAIAAN4iCAEAAG8RhAAAgLcIQgAAwFteBKERI0ZYrVq1rGTJktaiRQtbuHBhvKsEAAAKgCIfhCZMmGC9e/e2QYMG2ZIlS6xRo0aWlpZmW7ZsiXfVAABAnBX5IPSXv/zFunXrZp07d7b69evbCy+8YCkpKfb3v/893lUDAABxVqR3Hdy3b58tXrzY+vXrFz1XrFgxa9OmjaWnp/+ofHZ2truFsrKy3P3OnTuPab1+2HfADmb/EL32ATZ/BAB45ofjeC0Mr9tBEByxbJG+Am/bts1ycnKsUqVKuZ7X4y+++OJH5QcPHmx/+MMffvR89erVj1sdqww9bi8NAEChUOU4XQt37dplZcqU8TcI5ZdajjSeKHTw4EHbsWOHVahQwRISEuJat8JGaVwBcv369Zaamhrv6uAocA4LP85h4cb5O3pqCVIIqlq16hHLFukgdMopp1jx4sVt8+bNuZ7X48qVK/+ofHJysrvFKlu27HGvZ1GmNy9v4MKNc1j4cQ4LN87f0TlSS5AXg6WTkpKsadOmNmvWrFytPHrcqlWruNYNAADEX5FuERJ1dXXq1MmaNWtmzZs3t6FDh9ru3bvdLDIAAOC3Ih+E2rdvb1u3brWBAwdaRkaGNW7c2KZPn/6jAdQ4ttTFqLWbDu1qROHBOSz8OIeFG+fvxEgI8jK3DAAAoAgq0mOEAAAAfg5BCAAAeIsgBAAAvEUQAgAA3iIIAQAAbxGEEBdbtmyJFrgEABx7TArPG4IQTrjXXnvNbXGydOlSK1asGGEIKAK46BYc4WfqoXtk8ll7eKwjhBNuw4YNdu+991p6errNnDnTGjVq5N6gCkUoevQRw6bFRfOcfvfdd5aTk+P2dUTBEH6Wrl271iZPnuzO02mnnWY33nhjvKtWYBGEEBda5VthaM6cOfbee+8RhorYBVK7ZetcpqSkWLly5Ti3RdCbb75pAwYMcOe2bt26NmLECKtSpUq8qwUz+/zzz+3iiy+2hg0bumEImzZtsssvv9yeeeYZq1WrVryrV+AQhBA3enP26NGDMFTEvPHGG3bffffZSSed5M7n+PHjrUmTJvGuFo6hxYsXW1pamnv/VqxY0YYPH24lS5a0f/3rX3bOOefEu3pe++GHH+yaa66xBg0auHC6fft2+/LLL+2WW25xLUOjR4+2+vXrx7uaBQpBCHHvJuvZsydhqIi0BKk5vmXLlq6lQN0lb731lrspHOnCicLvs88+c+dZY/y0D5bs2rXLLrroIvffwSuvvOIuwoiPAwcO2AUXXGDdu3fPtbm4Wob03lSL0LRp01xw5bP2f/gXwAkR5u3//ve/9s0339jKlSvdY31D0beWSy65xFq3bm2ffvopA6gLIYUghdlPPvnEunbtar/97W/dN9C///3vdvvtt9uvf/1rmzFjRryriWPU2qDzqS8xoZNPPtk++OAD99+Bzrfex4jfZ63Gbimwhvbv3+9a7mbPnu2ef+SRR9zzhKD/n1qEgOPp4MGD7v7NN98MGjRoEJx11llBxYoVg8GDB0fHNm3aFNxwww3u+Y8//jjONUZ+7d27N7j22muDhISEoG3btrmO/fDDD8Fdd90VpKamBpMnT45bHXFsrFixImjcuLG7ffvtt+658H28c+fOoEaNGsEFF1wQZGdnx7mmRV/4736o0aNHB9WqVQvGjRsXPReej2HDhgXnnXdesHnz5p/8fd8QhHDcxL7Jpk6dGpQuXToYPnx48PXXXwdDhw51F81+/foF+/bti8LQZZddFtSuXdtdWFG4rFmzJujUqZMLPJ988kmu/wb27NkT3HbbbUGVKlWC77//Ps41xdG8h2N/XrlypbvQtmnTxl1QY4/v2rXLvcdxfOXk5Lj7LVu2uPfbe++9Fx1btWqVey+2atUq+Pe//53r915++eXgzDPPDL777rsTXueCiiCEY+7dd9913wxD+qBs165d8NRTT7nH69atC04//XQXehITE4MHH3zQXSglIyMjWL9+fdzqjrwJL3oHDhxwLT6x5/qaa64JTjnllGD58uW5yuocK+yicAjP28yZM4NevXq586qWhsWLF0dh6LTTTnNhSBfj2N/BiQlBn332WdCkSZOgbt26rjW9RYsWUZl58+YFN910kzs+cuRI95zeq7/73e9cQMrMzIxb/QsaghCOqddffz246KKLom+JsmPHjuD55593AUjPn3POOUHXrl3dsQEDBriWofvuuy9qGULBFl7spk2bFrRv3z5o1qyZu1AqAMu2bduCq6++2oUhdaPE/g4KlzfeeCMoWbJkcMcddwRXXXVVcO6557r394wZM6IwpBbcX/3qV8HWrVvjXV2vqNXn1FNPda3qS5cuDd5///2gYcOGwb333huVUUvRQw895M6hWoH0Xq1QoUKwZMmSuNa9oCEI4ZgLxw189dVXUfNr+O3j2WefDVq3bh19g9RjBaNKlSrRWlCIvP3220FSUpL70NU3TH0AX3jhhcGoUaPccQXe66+/3oXcL774It7VxVHQ+1GtCerGDqn75Te/+U1w8cUXu9YI+fzzz917+L///W8ca+sXdS936NAhuPvuu6Pn9GWjb9++roUullqBdI6eeeaZYOzYse5zGbmVCAdNA8di2maJEiXcTDCtW3HTTTfZ9ddfbw899JCVKVPGzWbQbDHNLDn11FPd72jmyf3332+33XabW3wPBZvOYWZmpv35z3+2Rx991Pr16+ee1+KYf/zjH23cuHFu6rSmUg8bNsxKlSrFqtKFcBkEvZcTExNt8+bNuRZJvPTSS10ZrR/0xRdfuAX7dL6XLFniyuPE0GwvLVRar1696DmdN50fLXSp2X3Fixe35ORkN01e54glDX4ac+fwi8ROc1cIEk2PP+uss+zCCy90W2g8//zzlpWV5d6oWktG6wX95je/sXbt2tnf/vY3O//88wlBhYTOoRZKVBgKL3z6b6B69epuTRmtVRJOk69Zs6a9/PLL7r8FFJ7zq3WfhgwZ4s6lQpBWgY99r2uZC12Ep0yZEv0eIej4il3uT1Ph9QXjd7/7nQukscfDc6TP06SkJPfzzp0741LnwoQghF/8zWT16tWuRUD+/e9/u7CzceNGtz5QixYt3GJ6CkO6eGq/m5deeskdV3B6//33WeW0gAs/ZNVKIN9//737oNWaUOFxfQCrJVDfSLXqcFhW30pReM6xWmw7duxo1apVs7PPPttatWplf/jDH+zDDz/MteZM+fLl7Ywzzohjjf1rpdu6dWsUOvW5+fXXX7vHeu/FtrqG51LPPfjgg65VXuEJP42uMfxia9assRdeeMEFolmzZtmYMWOsatWq7tjQoUOtV69errlWb0wttKfVTtu3b++CUPitBQWXztvChQvt6aefdlspVKpUyZ3TW2+91W2ncPfdd0dltZy/WoIIQIXvHM+bN8/tEXfXXXe5RRHlueeec19adDHVRVWL8iks6UKs/x5wYs6N3lc6B9ovrFmzZm5By+nTp7vjsQFVrbXhl5Df//737nNZn8m02B3BIWOGgDz5/e9/76Znhvr06eMGxmpGSSh2QbX777/fTe3UDAembRY+L774oltA75ZbbolmBP7pT39y57xLly7uvwcNnNZaURqYiYIrdgaflj8I7zUAWudTg20PXQxRS1zova2ZR5deemm0ThRO3MB1LT+i5QqSk5ODV155xT2/f//+XOVmzZoVNG3a1M0U02SGcKkD/Dy6xpBvaopdt26d+/YRUiuAWnuWLVsWfZtUa092dnbUMnTeeee5JvbwGwsKj27durnzqxYD7Q2nb6gaKP3aa6/Zt99+61oIdP/RRx8xKLMQdLNoCwZRy53Omc6durDVda2Bz7qF5UWD4ydPnmwLFiywt99+2xo3bhzX/x9FXTjWZ9++fZaTk2OVK1d23c4avJ6amuomo4ha1XU8pG5rnTsNP0hPT2ez4zxi01X8Iv/5z3/czATNEhINoOzQoYNrxv3nP/8ZlVu1apXVrVvX9XOHM8ZQMIUbMWpWUI0aNaKB7Pqo0OB2nVeNIdG4L51LDcbUh/OePXvcIE4UbLqY6suK3qO6wP6///f/3Pv4sssuc5MabrjhBvdFR4FHoTYMT+E9Tsz7T5+Z6n5U6NGXSM3QU7DRZBPtIK/usT/96U/udxSGFGoVaDWA+vHHH3flkUdHaDECftavf/1rtzr0hx9+GDW7az+pMmXKuPVG1I2iRRO1zsj27dvjXV38jHB1b/nyyy/dInlap2T37t3R82qK115F2ipDi+zFLpyJwkErt+u8as8/dbP861//ytXNkpWV5brJzjjjjGh1cJzYFaO1QGK5cuXc56vW41KXmFaD1vtSC9T+8Y9/DM4+++zgkUceybV1htZ5in2/Im8IQvhFtBr0zTff7FYr/eCDD6IwpJVny5Yt68YUsJFqwacLnjbEDVeHDpfi1yKJGt916Idro0aN3PnVfkbhhzcKz/igKVOmuC8wtWrVihbBPDQMaQscnWOtHo0T+14sVapU8MQTT0TP6ctlSkpKtE2Rxgw9/vjjLgxpYUWNvdT4LhZLPDoEIeT7Q1QtO+HK0OHz+uYSG4ZErQVvvfUWe4cVgjCrrTL0QartEnTOwjA0aNAgN8hdW2iEA2i1qaZag4YMGRKtIo7C8/5VyNFEB51nbW2j8/uXv/zlR2FIq8Jfd911werVq+NWZ99oIolaYtUaF25cGw5oV4vQAw88EJXVliYvvPBCcMEFF7gbA9iPHkEI+d5LrGXLlkHNmjXdTJLYWQlhGAq7yVA4qEXn6aefDurXr+9mfuncHhqGdM4VltT0/vDDD7sP69gwjMIRgtSyoK6W8D2qbTHUTaYwFLuVxoQJE4JvvvmGPeJOkNhtaDRDU+dDszHDPcEURtWCF3ZjHi7c4ugRhPCzYj8IFy1a5Db505gfNdvqgqnwoymbIe12rJaF9PT0ONUY+RF2a6mpvWrVqq4bTK0ENWrUcPuJhWFoxIgR7sO5cuXKrjmeabmFz5tvvum6Vx599NFcSxxoM+Tu3bu7sKtz379/f/ceDlskcHxpKnzz5s2D8ePHR8+99NJLbp+3nj17Bu+88457P/bo0eNHn8sE1WODIITD0psydmyA+p7VaqBBerHBSGtW6Bvm7Nmzo+c7duzodkZGwaVwcyhtgKsL4YIFC4Lbb789qF69umtBCJvn1WyvCyi7jBc+CrraOf7Pf/5zrufDbhd1XysAKQzpPc3u5CfOp59+6jaiTktLcy1xodGjR7u1u7Q2l75gHnrOcOwQhPAj+lDUIFl9UxTNUtCsBQ3g0zeUWLpo6ptLu3btgunTp8epxsiPFStWuIHRCj6anRLSAHd981QzvS6cGgitx1OnTo1rffHLrVmzJjj99NPd+zVsSTi0NUFjxRSQNTYIJ0YYavRF86qrrgquvfbaYOLEiblmgum9qm4yFio9flhQET+iNWLeffddt5GmFkgM9xDTmjGffPKJLV26NCrbvHlze/HFF90iXv/617/crscouPbu3evWGFmxYoU9++yzbgsF7Q331Vdf2ZVXXunWlxk4cKA71w899JA7dvPNN7vNc1G416bZsGGDW2cmFC4h9/HHH9vcuXPd4nxaB6ps2bJxrKlfwnWZtPisNqnW5+tf/vIXt/GtaE223r17u+f1Xo397MWxQxDCYekDUQvl6Y2oBbq0g/iECRPcRpvDhg2LApJo7xsFpT/+8Y/sIl/AlSxZ0rp06eLCjUKRFmWrXbu22/tNqwpv2rTJbY6rlYe1j5g209XecLVq1Yp31ZFHh1sjV+f46quvdgtizp8/312Awz2q/v73v7s9qcJV4HHi6By8/vrrbuPpbdu2ub3E9KXkmWeesUmTJrkyd955p1vNXV9G/vGPf7jVpnFssbI0fpa+Ld5zzz127rnnumX21ZKgzTb1htUmjLpYonDRW15bnQwaNMgFHi3Frw/fd955x7UW7dq1y+bMmWMXX3yxK68PXjbHLRzC1Z+10aZuWh38uuuus2uuucbtVv7www+7rXG0w7xa/aZNm+ZacrVFCisRx2eV7zZt2riWWJ0b0ZdMbWejVjy1ymoFcHn55ZftggsucKEWxxZBCEekZll9K9Hy7mEY0htXy74/9thj7tsMChd9yCoAKcxqawx929TO4jq3ainSuWZLhcJJe4Yp6GgXebXqard4bcGg3eV1ntWyq9YGdX1raxR1bTdq1Cje1faS9gb71a9+Zb169bK777472l5j+fLlbtsihdOuXbu684nj6DiOP0IRolkkmsFw5513usGUWk9G22Zs2LAh3lXDEYSDYjX4XevGxM7omz9/fnD++ecH9erVcwOkhZWiC/c51uywcLVorfWk7W5iF+KTjIwMt+CpZgIiPvQ+27Ztm5ts0rdv32jwdPj+09Ik5cuXD2655RbWCTrOCELIVxhq1qyZ21JDH6CHm4KNgnmBfO2119zeUpo5pAujFk7UTKIwDGllWl1AdYFE4TBu3LhoraeQlrzQtjZ6f+r8agmEbt26Rce1zIUuvjjxfmrNnzFjxrh1m8aOHZvrea3t9Nxzz7Ey/wlQ4ni2NqFoUVfYyJEjXb+1ZoeVKVMm3lXCEahrSzOCfvOb37jZKPXq1XPjgtRtkpGR4WaOtWjRwoYMGWLdu3d3O49/9NFH7vfoFiu4tDv8X//6V9d9mZyc7Gb8yYEDB9zYH+1crgHxV111lY0aNcod++yzz2zixIluVliFChXi/P/AL2E38wcffOBuW7dudWO39N7r1KmTrVmzxu644w5bvHixVa1a1c3u07nSeCE9xvHFGCHkm8aQaPYRCodHHnnETbudOnVq9Jwea8C7xnopDGlsggbGV6pUyWrWrBnX+uKnhWNIRIOhR4wYYVlZWdanTx+31EE4i1PLWXTr1s2N/wmpjAZFa2q2zjNObAjS7DCFnWuvvdYFHy1XoCnzAwYMcAPYx40b587X7t273efr8OHD3ZdPHH8EIaAI09tb0+W1hsyMGTPchVStBpoFplkoGiy9aNEiq1GjRryrijyGoNWrV7tWH7XsqLVPLX0adKv1Ztq2bWvffPONa20oXbq0m8ygwfDvvfeevfTSS262oGaA4sTSkgVqodNMTb0ftQxJgwYNXGuPWu00W1MD19Vaq/OmL5snn3xyvKvtDdYRAoqQ8HvNjh07XPelvonqoqgL5n/+8x93IdU3UdEHrrpIdI/CEYI+/fRTq1u3rlu3Sy655BIXgHQOFYimT5/u1nxSt4r+W9DSF2oJUreYumQIQfGh8KoWO4WgtWvX2mWXXWY33XSTW8fr1VdfdWuwqWWvXLlylpiYSAg6wWgRAoqYN9980y1zsGXLFrfmU6tWrdwFUi1CWp32iiuucOX69evnplPrpg9gFPwQpHVkNNVaLQixFHKff/55twZU3759o24yXYDV0qAFUnWP+NB5Wb9+vdWpU8e12mn1/nBxRAVbtQBp8dqnn36asXlxwGBpoAjR2BCNQ1CX1/bt2924oC+//NJthaKVhfUhrDWC9K3z888/t9mzZxOCCkkIOv/88+2+++7LFYK0IKIWS9SifDqnWpFYA9/1ezrfZ555Zlzr7/OYIHVB79+/34VQtfBovTWt6aSB0BoXFC6oqDWc1FKnMV2EoPigawwoIrRysC6MWqFWH7RDhw51YxK0dL8WT7z00ktd64/u1V22cOFCBmMWcApBaknQeVJL0ODBg6PuzyeffNJuu+02t/he2E2mAKyxQ/3793chF/EJQXofahHEpk2buq5JLXIpCqs6rsUt9b7UuC11YT/wwANugUvEBy1CQBGgFYRvueUWN61aq4CHFHhEM8PGjh3rApIuoCg81GpQuXJlt8J7eKFVIFL3p1aI1qDbsOVIYUitENo/7Iwzzoh31b0Snpu3337bdUkrlKoFVmFHM/W0NYaWr9AXET2npUjUNabQRKtsfDFGCCgidKFUGNKMIk3D1QUypA9bTaPXc1p/Rs31NMMXDvqI1sw+zTrS3n6acq0uMO0RphlHsbQ2lEKTZorpHOP40vtK433UtaXzpFYeDYLWelxqwdN50HIUWsdL50zvOY0HWrBggSurFiM2NI4/ghBQhGh2kBZo05ggjSeJDUPvvvuuG5jJOkGFjz6mdfHUrCONM9Hgdy2iqD3Eihcv7spooVNN01b3JyHoxLTUaSKCWnjUHX322We7NYDUKqc1gbREhfYL0xguffkQnTeNFWK5ioKFMUJAEaJvpuoW0eKIGiOkTVRDunASggqHQ7+fqiVB4VZdKury0uyi2BCksWDqalGrAyHoxNCilFrGQJMOtHSB7nU+1Ao0Z84c937TgPVwZW+t76Tu6XBMFwoOghBQxGhg7ejRo13rkNYn+eKLL+JdJRzldgwaC6S1gNTKo7WhWrZs6RbC1BYa4bYaTzzxhJsppvLasgEnjmZgqhtaszX1xUMLIt57773unJ111ln2t7/9LQqr+llhSd2bKFjoGgOKKI0rUZO9FmyrUqVKvKuDfHjttdfc9icaD6Q1aLTnlGYh6QLbsGFDN+NPA3K1YrgGSSsEabwJ4jc+T5MUtL2JxumpC0wTFBRkRYsoKsBqi5PGjRvHu7o4BEEIKMLYF67w0UVTrT2adq21ZURhVt1hWktI6whpw2NtjqsWv6eeeoqLawEJQzpfCkPt2rVzrXYvvPCCW/X79NNPt9///ve0BhVQBCEAKEC0AKaCkFoQ1CIUeuWVV9yFVoPetcK0xghpqjxBt+BQF9ndd9/tgqn2edMMvnCmGOep4GKMEADEUfhdVBdLUVeYbgo5osG3osUTNVBa3S6isSdcXAvemCHNENNK4FokMZyskJycHO+q4WcQhAAgjtRioKnxmhUmGutz+eWXu7Vntm7dGs0C0+J7J510ktuxHAV7ssKIESPcmk7ly5d3z7FmV8FG1xgAxHmGmGYb6QKqRRM1A0xTrbUelLrJ1MKg1h+NCdKYE4Umbd6Jgo3usMKDIAQAcQpA2mcqJSXFPadWhNdff91Nh9c0+TVr1tgf/vAHN3VeA27VGqQ1otgfDji2CEIAEAfvvfeeawEaPny4G/yssKMF+LQbuVp+QqtXr3bHtFJxhQoV4lpnoChi01UAiAOt/r19+3YbM2aMW4lYG3TqZ60TdMUVV7gp2KJuMMaYAMcPLUIAcJyFH7OHTqVOS0uzzMxMtxqxtslQGNIg2y1btrhQxA7ywPHHrDEAOA4OHjwY/awApJu6wx599FE37kc0Hki7l5966qn24YcfunFBWohPA6NVhu+pwPFHEAKA40BbX6xfv95tzCkaCK1p8dohvlevXm6laIUgbYSbnp7ufp40aZI98sgjdu2111rr1q3pEgNOALrGAOA40IKI2i9s3bp1bo2gYcOGuVCkjVGnTp3qFtzTYGmtNaNVpNUVpsHSaknSqtGJiYnx/r8AeIEgBADHicb/XHXVVW6T1LvuuivXbLCvv/7a7SemVYfHjx9vtWvXdt1h2pcKwIlD1xgAHCda+0c3TYnX+J9x48ZFxzQQ+qWXXnKtQpdccolt2rQpWkUawIlDixAAHEfZ2dlu5eiuXbu6BRS7dOliHTp0iI6rG0wrRysIValSJa51BXxEEAKAE0AtQvfdd5+bPn/HHXe4vcQ0MHrz5s02evToeFcP8BZBCABOkLVr19qDDz7oVotWN5imyr/77rtuADWA+CAIAcAJtGHDBpsxY4Z9++231r59e6tbt268qwR4jSAEAAC8xawxAADgLYIQAADwFkEIAAB4iyAEAAC8RRACAADeIggBAABvEYQAAIC3CEIAAMBbBCEA3tHmp+3atbPU1FRLSEiwzMxMq1Wrlg0dOjTeVQNwghGEABRZY8aMsbJly/7o+bFjx9oHH3xg8+bNc7u+lylTJi71AxB/JeJdAQA40b7++ms7++yz7Zxzzol3VQDEGS1CAAq0gwcP2pAhQ6xOnTqWnJxsNWrUsCeeeMLmzJkTdWuFli5d6p775ptv3PHOnTtbVlaWe063Rx991C699FJ75pln7P3333fP6fHhrFu3zq6//norXbq060K7+eabbfPmze6YXrN48eL28ccfR3UsX768tWzZMvr9l19+2apXr37c/30A/DIEIQAFWr9+/ezJJ5+0AQMG2IoVK+yVV16xSpUqHfH3zj//fDfmRyFG3V+6PfTQQ/b6669bt27drFWrVu45PT6Ugo1C0I4dO2zu3Lk2c+ZMW7NmjdstXtSV1rhxYxe2ZNmyZS5UffLJJ/b999+75/R7l1xyyTH/9wBwbBGEABRYu3btsmHDhrkWoU6dOtkZZ5xhF154oXXt2vWIv5uUlOQCiwJK5cqV3U2tO2q5SUlJccf1nB4fatasWS7cKHQ1bdrUWrRoYf/85z9duFm0aJEro5akMAjp/oorrnDdbR9++GH0HEEIKPgIQgAKrJUrV1p2drZdfvnlJ/zvqlsrtmurfv36buC1jolCjkJPTk6OC0gKRmE42rhxo3311Vc/2e0GoOAgCAEosEqVKvWTx4oV+9/HVxAE0XP79++3E+Xiiy92LVZLlixx441ig5CCUdWqVe3MM888YfUBcHQIQgAKLAUJhSF1VR3q1FNPdfca5xM7WDqWur/UYpNf6uJav369u4U0PkkDs9UyJGodOvfcc2348OGWmJho9erVc+FI44SmTJlCtxhQSBCEABRYJUuWtL59+1qfPn3cGB1Ne58/f7699NJLbhaZuq40E2z16tU2depUNxsslhZJ1OBlBalt27a5hRTzok2bNtawYUPr0KGDa/FZuHCh3X777S7cNGvWLCqnFqBx48ZFoUfjjRSiJkyYQBACCgmCEIACTbPFHnzwQRs4cKALGZq5tWXLFtcK8+qrr9oXX3zhWmaeeuope/zxx380c6x79+7ud9SCpEHXeaEB1m+99ZaVK1fOtfIoGJ1++uku4MRS2FGLU+xYIP186HMACq6EILaDHQAAwCO0CAEAAG8RhAAAgLcIQgAAwFsEIQAA4C2CEAAA8BZBCAAAeIsgBAAAvEUQAgAA3iIIAQAAbxGEAACAtwhCAADAfPX/AahtrR3ZzxvhAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "whonecut, whcutflow, wlabels = wgtcutflow.yieldhist()\n",
+    "\n",
+    "whonecut.plot1d(yerr=0)\n",
+    "plt.xticks(plt.gca().get_xticks(), wlabels, rotation=45)\n",
+    "plt.show()\n",
+    "\n",
+    "whcutflow.plot1d(yerr=0)\n",
+    "plt.xticks(plt.gca().get_xticks(), wlabels, rotation=45)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9847580d",
+   "metadata": {},
+   "source": [
+    "Saving to npz will include the weighted summary statistics by default, as well as a `commonmask`, but the actual weights (with the appropriate `weightsmodifier`) can also be saved directly, for later inspection."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "5dd9f140",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CutflowToNpz(file=cutflow_results_weighted.npz), labels=['initial', 'noMuon', 'twoElectron', 'leadPt20'], commonmasked=False, weighted=True, weightsmodifier=None)\n"
+     ]
+    }
+   ],
+   "source": [
+    "npz = wgtcutflow.to_npz(\"cutflow_results_weighted.npz\", includeweights=True)\n",
+    "print(npz)\n",
+    "npz.compute()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "13c8a29a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "labels: ['initial' 'noMuon' 'twoElectron' 'leadPt20']\n",
+      "nevonecut: [40 28  5 17]\n",
+      "nevcutflow: [40 28  5  3]\n",
+      "masksonecut: [[ True  True  True  True False False False  True  True  True False  True\n",
+      "   True  True False  True  True  True  True  True  True  True  True False\n",
+      "  False  True False  True False  True False False  True  True False  True\n",
+      "   True  True  True  True]\n",
+      " [False False  True  True False False False False False False False False\n",
+      "  False False False False False False  True False  True  True False False\n",
+      "  False False False False False False False False False False False False\n",
+      "  False False False False]\n",
+      " [False  True  True False  True  True  True False False  True False False\n",
+      "  False False False  True  True False False False  True  True False  True\n",
+      "   True False  True  True False  True False  True False  True False False\n",
+      "  False False False False]]\n",
+      "maskscutflow: [[ True  True  True  True False False False  True  True  True False  True\n",
+      "   True  True False  True  True  True  True  True  True  True  True False\n",
+      "  False  True False  True False  True False False  True  True False  True\n",
+      "   True  True  True  True]\n",
+      " [False False  True  True False False False False False False False False\n",
+      "  False False False False False False  True False  True  True False False\n",
+      "  False False False False False False False False False False False False\n",
+      "  False False False False]\n",
+      " [False False  True False False False False False False False False False\n",
+      "  False False False False False False False False  True  True False False\n",
+      "  False False False False False False False False False False False False\n",
+      "  False False False False]]\n",
+      "wgtevonecut: [578762.43554688 315450.42382812  25807.2109375  237244.12109375]\n",
+      "wgtevcutflow: [578762.43554688 315450.42382812  25807.2109375   26331.20117188]\n",
+      "weights: [ 26331.20117188  26331.20117188  26331.20117188  25807.2109375\n",
+      "  26331.20117188  26331.20117188 -26331.20117188  26067.890625\n",
+      "  26331.20117188  26331.20117188  26331.20117188  26331.20117188\n",
+      "  26331.20117188 -26331.20117188  26331.20117188  26331.20117188\n",
+      " -26067.890625    26331.20117188 -26331.20117188  26331.20117188\n",
+      "  26331.20117188 -26331.20117188  26331.20117188  26331.20117188\n",
+      "  26331.20117188  26331.20117188  26331.20117188  26331.20117188\n",
+      "  26331.20117188  26331.20117188  26331.20117188  26331.20117188\n",
+      "  26331.20117188 -26331.20117188  26331.20117188 -26331.20117188\n",
+      "  26331.20117188 -26331.20117188  26331.20117188 -26331.20117188]\n"
+     ]
+    }
+   ],
+   "source": [
+    "with np.load(\"cutflow_results_weighted.npz\") as f2:\n",
+    "    for i in f2.files:\n",
+    "        print(f\"{i}: {f2[i]}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4f9e3dfc",
+   "metadata": {},
+   "source": [
+    "# Commonmask support in cutflow\n",
+    "The `commonmask` feature allows one to specify a boolean array that is applied to every individual and combination of cuts, as well as the initial counts. Orthogonal selections like a cut for channels or gen-level requirements can be specified independant of cuts applied to all channels, e.g. cuts on jet multiplicity or invariant masses, while allowing studies in individual 'channels.' This serves two purposes, one permitting the same studies with fewer masks in the PackedSelection (which in a very complex analysis might not fit into the widest storage backend) or even injecting 'external' boolean arrays, and two, allowing the single cuts and cutflows to be interpreted from more complex initial states than all events in a sample."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "e7029385",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "selection.add_multiple(\n",
+    "    {\n",
+    "        \"lheTaus\": ak.sum(np.abs(events.LHEPart.pdgId) == 15, axis=1) >= 2,\n",
+    "        \"lheMuons\": ak.sum(np.abs(events.LHEPart.pdgId) == 13, axis=1) >= 2,\n",
+    "        \"lheElectrons\": ak.sum(np.abs(events.LHEPart.pdgId) == 11, axis=1) >= 2,\n",
+    "    }\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "a56a4a90",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "taucutflow = selection.cutflow(\"noMuon\", \"twoElectron\", \"leadPt20\", commonmask=selection.require(lheTaus=True))\n",
+    "elecutflow = selection.cutflow(\"noMuon\", \"twoElectron\", \"leadPt20\", commonmask=selection.require(lheElectrons=True))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "abd4fd01",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "TAUS\n",
+      "Cutflow stats:\n",
+      "Cut noMuon              :pass = 12                  cumulative pass = 12                  all = 18                  -- eff = 66.7 %                    -- cumulative eff = 66.7 %\n",
+      "Cut twoElectron         :pass = 2                   cumulative pass = 2                   all = 18                  -- eff = 11.1 %                    -- cumulative eff = 11.1 %\n",
+      "Cut leadPt20            :pass = 3                   cumulative pass = 0                   all = 18                  -- eff = 16.7 %                    -- cumulative eff = 0.0 %\n",
+      "ELECTRONS\n",
+      "Cutflow stats:\n",
+      "Cut noMuon              :pass = 13                  cumulative pass = 13                  all = 13                  -- eff = 100.0 %                    -- cumulative eff = 100.0 %\n",
+      "Cut twoElectron         :pass = 3                   cumulative pass = 3                   all = 13                  -- eff = 23.1 %                    -- cumulative eff = 23.1 %\n",
+      "Cut leadPt20            :pass = 9                   cumulative pass = 3                   all = 13                  -- eff = 69.2 %                    -- cumulative eff = 23.1 %\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"TAUS\")\n",
+    "taucutflow.print()\n",
+    "print(\"ELECTRONS\")\n",
+    "elecutflow.print()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "851963d2",
+   "metadata": {},
+   "source": [
+    "# Categorical Axis fill for `yieldhist` and `plot_vars`\n",
+    "In order to support subdividing a sample into subsamples or different channels in an efficient manner, a complex input `categorical` is available. This is expected to be a dictionary with several key-value pairs: `axis`: a `hist.axis` type including the axis features desired; `values`: an event-by-event array of fill values that should be passed into the histogram fill, and `labels`: the human-readable bin labels matching the axis passed in."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "e9072a2d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import hist\n",
+    "cwhonecut, cwhcutflow, cutlabels, catlabels = wgtcutflow.yieldhist(categorical={\n",
+    "    \"axis\": hist.axis.IntCategory([0, 41, 43], name=\"ttbarID\"),\n",
+    "    \"values\": events.genTtbarId,\n",
+    "    \"labels\": [\"X+jj\", \"X+c\", \"X+cc\"]\n",
+    "})\n",
+    "\n",
+    "cwhcutflow.plot1d(yerr=0, overlay=\"ttbarID\")\n",
+    "plt.xticks(plt.gca().get_xticks(), wlabels, rotation=45)\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "89ee2204",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[StairsArtists(stairs=<matplotlib.patches.StepPatch object at 0x13fbbd6d0>, errorbar=None, legend_artist=None),\n",
+       " StairsArtists(stairs=<matplotlib.patches.StepPatch object at 0x1485b1160>, errorbar=None, legend_artist=None),\n",
+       " StairsArtists(stairs=<matplotlib.patches.StepPatch object at 0x13e859dc0>, errorbar=None, legend_artist=None),\n",
+       " StairsArtists(stairs=<matplotlib.patches.StepPatch object at 0x1485b2060>, errorbar=None, legend_artist=None)]"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "wch1, wch2, wclabels, catlabels = wgtcutflow.plot_vars(\n",
+    "    {\"ept\": events.Electron.pt, \"ephi\": events.Electron.phi},\n",
+    "    axes=[hist.axis.Regular(3, 0, 60, name=\"ept\", label=r\"$p_{T}$ [GeV]\"), \n",
+    "          hist.axis.Regular(10, -3.14, 3.14, name=\"ephi\", label=r\"$\\phi\", circular=True)],\n",
+    "    categorical={\n",
+    "        \"axis\": hist.axis.IntCategory([0, 41, 43], name=\"ttbarID\"),\n",
+    "        \"values\": events.genTtbarId,\n",
+    "        \"labels\": [\"X+jj\", \"X+c\", \"X+cc\"]\n",
+    "    }\n",
+    ")\n",
+    "wch2[0][:, :, 0].project(\"ept\", \"cutflow\").plot1d(overlay=\"cutflow\", yerr=False)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "a96edc79-1b3b-4ff9-8459-6ef28a99d629",
@@ -1022,7 +1506,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 38,
    "id": "1adf0374-eee9-471b-9582-9cbbf06d2dda",
    "metadata": {
     "tags": []
@@ -1032,7 +1516,13 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/Users/iason/fun/coffea_dev/coffea/binder/coffea/nanoevents/schemas/nanoaod.py:215: RuntimeWarning: Missing cross-reference index for FatJet_genJetAK8Idx => GenJetAK8\n",
+      "/Users/nmangane/scikit-hep-dev-2/coffea/src/coffea/nanoevents/schemas/nanoaod.py:264: RuntimeWarning: Missing cross-reference index for LowPtElectron_electronIdx => Electron\n",
+      "  warnings.warn(\n",
+      "/Users/nmangane/scikit-hep-dev-2/coffea/src/coffea/nanoevents/schemas/nanoaod.py:264: RuntimeWarning: Missing cross-reference index for LowPtElectron_genPartIdx => GenPart\n",
+      "  warnings.warn(\n",
+      "/Users/nmangane/scikit-hep-dev-2/coffea/src/coffea/nanoevents/schemas/nanoaod.py:264: RuntimeWarning: Missing cross-reference index for LowPtElectron_photonIdx => Photon\n",
+      "  warnings.warn(\n",
+      "/Users/nmangane/scikit-hep-dev-2/coffea/src/coffea/nanoevents/schemas/nanoaod.py:264: RuntimeWarning: Missing cross-reference index for FatJet_genJetAK8Idx => GenJetAK8\n",
       "  warnings.warn(\n"
      ]
     },
@@ -1042,7 +1532,7 @@
        "dask.awkward<from-uproot, npartitions=1>"
       ]
      },
-     "execution_count": 25,
+     "execution_count": 38,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1051,11 +1541,12 @@
     "import dask\n",
     "import dask_awkward as dak\n",
     "\n",
+    "fname = \"https://raw.githubusercontent.com/scikit-hep/coffea/master/tests/samples/nano_dy.root\"\n",
     "dakevents = NanoEventsFactory.from_root(\n",
-    "    {\"../tests/samples/nano_dy.root\": \"Events\"},\n",
+    "    {fname: \"Events\"},\n",
     "    metadata={\"dataset\": \"nano_dy\"},\n",
     "    schemaclass=NanoAODSchema,\n",
-    "    permit_dask=True,\n",
+    "    delayed=True,\n",
     ").events()\n",
     "\n",
     "dakevents"
@@ -1071,41 +1562,43 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 39,
    "id": "a54d1fcc-13c6-4919-bbac-3d6c299f65ab",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/html": [
-       "<pre>[{FsrPhoton: [], Electron: [], SoftActivityJetHT5: 63.5, RawMET: {...}, ...},\n",
-       " {FsrPhoton: [], Electron: [{...}], SoftActivityJetHT5: 64, RawMET: {...}, ...},\n",
-       " {FsrPhoton: [], Electron: [Electron, Electron], SoftActivityJetHT5: 130, ...},\n",
-       " {FsrPhoton: [], Electron: [Electron, Electron], SoftActivityJetHT5: 25.8, ...},\n",
-       " {FsrPhoton: [], Electron: [], SoftActivityJetHT5: 172, RawMET: {...}, ...},\n",
-       " {FsrPhoton: [], Electron: [{...}], SoftActivityJetHT5: 54.4, RawMET: ..., ...},\n",
-       " {FsrPhoton: [], Electron: [{...}], SoftActivityJetHT5: 96.2, RawMET: ..., ...},\n",
-       " {FsrPhoton: [], Electron: [], SoftActivityJetHT5: 19, RawMET: {...}, ...},\n",
-       " {FsrPhoton: [], Electron: [], SoftActivityJetHT5: 9.36, RawMET: {...}, ...},\n",
-       " {FsrPhoton: [], Electron: [{...}], SoftActivityJetHT5: 115, RawMET: ..., ...},\n",
+       "<pre>[{SubJet: [], OtherPV: [{z: -2.23}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: -3.48}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: 5.86}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: -1.46}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: 1.15}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: -3.95}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: 0.15}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: -3.04}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: 4.33}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: 1.26}, ..., {...}], ...},\n",
        " ...,\n",
-       " {FsrPhoton: [], Electron: [{...}], SoftActivityJetHT5: 49.6, RawMET: ..., ...},\n",
-       " {FsrPhoton: [], Electron: [], SoftActivityJetHT5: 14.7, RawMET: {...}, ...},\n",
-       " {FsrPhoton: [], Electron: [{...}], SoftActivityJetHT5: 22.1, RawMET: ..., ...},\n",
-       " {FsrPhoton: [], Electron: [], SoftActivityJetHT5: 33.9, RawMET: {...}, ...},\n",
-       " {FsrPhoton: [], Electron: [{...}], SoftActivityJetHT5: 16.2, RawMET: ..., ...},\n",
-       " {FsrPhoton: [], Electron: [], SoftActivityJetHT5: 28.4, RawMET: {...}, ...},\n",
-       " {FsrPhoton: [], Electron: [{...}], SoftActivityJetHT5: 16.1, RawMET: ..., ...},\n",
-       " {FsrPhoton: [], Electron: [], SoftActivityJetHT5: 28.5, RawMET: {...}, ...},\n",
-       " {FsrPhoton: [], Electron: [], SoftActivityJetHT5: 7, RawMET: {...}, ...}]\n",
-       "--------------------------------------------------------------------------------\n",
+       " {SubJet: [], OtherPV: [{z: -1.91}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: -5.22}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: -1.17}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: 0.758}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: 7.16}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: -3.6}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: -2.92}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: 3.41}, ..., {...}], ...},\n",
+       " {SubJet: [], OtherPV: [{z: 3.27}, ..., {...}], ...}]\n",
+       "------------------------------------------------------\n",
+       "backend: cpu\n",
+       "nbytes: 243.3 kB\n",
        "type: 40 * event</pre>"
       ],
       "text/plain": [
-       "<NanoEventsArray [<event 1:13889:3749778>, ...] type='40 * event'>"
+       "<NanoEventsArray [<event 1:                13889:                3749778>, ...] type='...'>"
       ]
      },
-     "execution_count": 26,
+     "execution_count": 39,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1124,7 +1617,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 40,
    "id": "dc25b728-7504-44fb-b920-051dab6c99d1",
    "metadata": {
     "tags": []
@@ -1167,7 +1660,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 41,
    "id": "74c43d65-824b-49e6-a6aa-aa7bef97e7d9",
    "metadata": {
     "tags": []
@@ -1179,7 +1672,7 @@
        "dask.awkward<equal, npartitions=1>"
       ]
      },
-     "execution_count": 28,
+     "execution_count": 41,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1198,7 +1691,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 42,
    "id": "be4b8e7a-5ea1-45f4-b1d9-827e90331366",
    "metadata": {
     "tags": []
@@ -1228,7 +1721,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 43,
    "id": "4e79a6b3-55cc-4248-a1db-a076f4667278",
    "metadata": {
     "slideshow": {
@@ -1243,7 +1736,7 @@
        "NminusOne(selections=('twoElectron', 'noMuon', 'leadPt20'))"
       ]
      },
-     "execution_count": 30,
+     "execution_count": 43,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1279,7 +1772,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 44,
    "id": "dee4c70f-d6fa-4b0a-9d04-f5555ec1856f",
    "metadata": {
     "slideshow": {
@@ -1303,7 +1796,7 @@
        "  dask.awkward<equal, npartitions=1>])"
       ]
      },
-     "execution_count": 31,
+     "execution_count": 44,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1323,7 +1816,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 45,
    "id": "f8fc01f5-3f07-441d-b7de-44aeeaa042ca",
    "metadata": {
     "tags": []
@@ -1332,14 +1825,14 @@
     {
      "data": {
       "text/plain": [
-       "((40, 10, 3, 5, 3),\n",
+       "((np.int64(40), np.int64(10), np.int64(3), np.int64(5), np.int64(3)),\n",
        " (<Array [False, True, True, False, ..., False, False, False] type='40 * bool'>,\n",
        "  <Array [False, False, True, False, ..., False, False, False] type='40 * bool'>,\n",
        "  <Array [False, False, True, True, ..., False, False, False] type='40 * bool'>,\n",
        "  <Array [False, False, True, False, ..., False, False, False] type='40 * bool'>))"
       ]
      },
-     "execution_count": 32,
+     "execution_count": 45,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1358,7 +1851,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 46,
    "id": "118ee230-eb4f-44da-9dba-05ce15e7951e",
    "metadata": {
     "slideshow": {
@@ -1367,15 +1860,23 @@
     "tags": []
    },
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/nmangane/scikit-hep-dev-2/coffea/src/coffea/analysis_tools.py:825: UserWarning: Printing the N-1 selection statistics is going to compute dask_awkward objects.\n",
+      "  warnings.warn(\n"
+     ]
+    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "N-1 selection stats:\n",
-      "Ignoring twoElectron         : pass = 10                                  all = 40                                  -- eff = 25.0 %\n",
-      "Ignoring noMuon              : pass = 3                                   all = 40                                  -- eff = 7.5 %\n",
-      "Ignoring leadPt20            : pass = 5                                   all = 40                                  -- eff = 12.5 %\n",
-      "All cuts                     : pass = 3                                   all = 40                                  -- eff = 7.5 %\n"
+      "Ignoring twoElectron         pass = 10                  all = 40                  -- eff = 25.0 %\n",
+      "Ignoring noMuon              pass = 3                   all = 40                  -- eff = 7.5 %\n",
+      "Ignoring leadPt20            pass = 5                   all = 40                  -- eff = 12.5 %\n",
+      "All cuts                     pass = 3                   all = 40                  -- eff = 7.5 %\n"
      ]
     }
    ],
@@ -1393,7 +1894,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 47,
    "id": "700e7669-0459-4e3d-b020-805562106cab",
    "metadata": {
     "tags": []
@@ -1402,10 +1903,10 @@
     {
      "data": {
       "text/plain": [
-       "[40, 10, 3, 5, 3]"
+       "[np.int64(40), np.int64(10), np.int64(3), np.int64(5), np.int64(3)]"
       ]
      },
-     "execution_count": 34,
+     "execution_count": 47,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1429,7 +1930,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 48,
    "id": "a2c4fb20-b241-4eeb-8312-ee5a645f30b6",
    "metadata": {
     "slideshow": {
@@ -1471,7 +1972,7 @@
        "Hist(Integer(0, 5, name='N-1'), storage=Double()) # (has staged fills)"
       ]
      },
-     "execution_count": 35,
+     "execution_count": 48,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1491,7 +1992,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 49,
    "id": "38a6d003-fc3c-46e5-ad3b-5d343e997dc5",
    "metadata": {
     "tags": []
@@ -1530,7 +2031,7 @@
        "Hist(Integer(0, 5, name='N-1'), storage=Double()) # Sum: 61.0"
       ]
      },
-     "execution_count": 36,
+     "execution_count": 49,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1549,7 +2050,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 50,
    "id": "226cd7fa-ac79-460d-aee5-856eb3362099",
    "metadata": {
     "tags": []
@@ -1585,10 +2086,10 @@
        "</html>"
       ],
       "text/plain": [
-       "Hist(Integer(0, 5, name='N-1'), storage=Double()) # (has staged fills)"
+       "Hist(Integer(0, 5, name='N-1'), storage=Double())"
       ]
      },
-     "execution_count": 37,
+     "execution_count": 50,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1607,7 +2108,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 51,
    "id": "c96c48b2-53b3-460b-8019-e9f91473aef5",
    "metadata": {
     "tags": []
@@ -1615,7 +2116,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -1640,7 +2141,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": 52,
    "id": "d0d57fbb-633b-4140-95b6-7ac551a4c271",
    "metadata": {
     "tags": []
@@ -1689,7 +2190,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 53,
    "id": "621cc56b-7bf1-4be8-b24c-04c89125e6b0",
    "metadata": {
     "slideshow": {
@@ -1723,7 +2224,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },
@@ -1737,7 +2238,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.12.9"
   }
  },
  "nbformat": 4,
diff --git a/src/coffea/analysis_tools.py b/src/coffea/analysis_tools.py
index baa5178b6..01089d29c 100644
--- a/src/coffea/analysis_tools.py
+++ b/src/coffea/analysis_tools.py
@@ -21,6 +21,97 @@
 import coffea.util
 
 
+def _generate_slices(array_length, max_elements=128):
+    """Generate slices to split an array into chunks of at most `max_elements` elements
+
+    Parameters
+    ----------
+    array_length : int
+        The length of the array to split
+    max_elements : int, optional
+        The maximum number of elements in each chunk. Default is 128.
+
+    Returns
+    -------
+    slices : list of slice objects
+        A list of slice objects to iterate over and split the array into chunks with at most `max_elements` elements per slice
+    """
+    slices = []
+    for start in range(0, array_length, max_elements):
+        end = min(start + max_elements, array_length)
+        slices.append(slice(start, end))
+    return slices
+
+
+def boolean_masks_to_categorical_integers(
+    masks,
+    insert_unmasked_as_zeros=False,
+    insert_commonmask_as_zeros=None,
+    return_mask=False,
+):
+    """Converts a list of boolean masks to irregular arrays of enumerated categorical integers
+
+    Parameters
+    ----------
+    masks : list of boolean numpy.ndarray, awkward.Array or dask_awkward.lib.core.Array objects
+        The boolean mask arrays to convert to categorical integers
+    insert_unmasked_as_zeros : bool, optional
+        Whether to insert a zero entry representing an 'unmasked' state, equivalent to the first mask satisfying `ak.all(mask == True)`. Default is False.
+    insert_commonmask_as_zeros : boolean numpy.ndarray, awkward.Array, or dask_awkward.lib.core.Array, optional
+        If not None, insert a zero entry representing a 'commonmasked' state. Default is None. Not compatible with insert_unmasked_as_zeros=True.
+    return_mask : bool, optional
+        Whether to return the intermediate concatenated mask array instead of the ragged array of categorical integers. Default is False.
+
+    Returns
+    -------
+    irregular_categories : awkward.Array or dask_awkward.lib.core.Array containing integers representing whether an entry contained a True value in the corresponding mask
+
+        >>> pt = ak.Array([[1.1, 2.2, 3.3], [], [4.4, 5.5], [6.6]])
+        >>> at_least_one = (ak.num(pt, axis=1) >= 1)
+        >>> at_least_two = (ak.num(pt, axis=1) >= 2)
+        >>> at_least_three = (ak.num(pt, axis=1) >= 3)
+        >>> something_over_four = ak.any(pt > 4, axis=1)
+        >>> masks = [at_least_one, at_least_two, at_least_three, something_over_four]
+
+        >>> print(boolean_masks_to_categorical_integers(masks, insert_unmasked_as_zeros=False, return_mask=False))
+        [[0, 1, 2], [], [0, 1, 3], [0, 3]]
+        >>> print(boolean_masks_to_categorical_integers(masks, insert_unmasked_as_zeros=False, return_mask=True))
+        [[True, True, True, False], [False, ...], ..., [True, False, False, True]]
+        >>> print(boolean_masks_to_categorical_integers(masks, insert_unmasked_as_zeros=True, return_mask=False))
+        [[0, 1, 2, 3], [0], [0, 1, 2, 4], [0, 1, 4]]
+        >>> print(boolean_masks_to_categorical_integers(masks, insert_unmasked_as_zeros=True, return_mask=True))
+        [[True, True, True, True, False], [...], ..., [True, True, False, False, True]]
+    """
+    mask_inputs = [mask[:, None] for mask in masks]
+    if insert_unmasked_as_zeros and insert_commonmask_as_zeros is not None:
+        raise ValueError(
+            "insert_unmasked_as_zeros and insert_commonmask_as_zeros cannot be used together"
+        )
+    if insert_unmasked_as_zeros:
+        mask_inputs.insert(0, awkward.ones_like(mask_inputs[0], dtype=bool))
+    if insert_commonmask_as_zeros is not None:
+        mask_inputs.insert(0, insert_commonmask_as_zeros[:, None])
+    irregular_masks = []
+    # TODO: _generate_slices is used to work around the issue addressed in awkward PR https://github.com/scikit-hep/awkward/pull/3312
+    # which was merged in awkward v2.7.2 (https://github.com/scikit-hep/awkward/releases/tag/v2.7.2) and this can be removed when it becomes the minimum version for coffea
+    for slc in _generate_slices(len(mask_inputs), max_elements=128):
+        # create subarrays of the masks to concatenate, to work around issue prior to awkward v2.7.2
+        irregular_masks.append(
+            awkward.from_regular(awkward.concatenate(mask_inputs[slc], axis=1), axis=1)
+        )
+    if len(irregular_masks) == 1:
+        # unwrap the new concatenated (irregular) masks if there is only one
+        irregular_mask = irregular_masks[0]
+    else:
+        # if multiple irregular masks were created, concatenate them a final time
+        irregular_mask = awkward.concatenate(irregular_masks, axis=1)
+    if return_mask:
+        return irregular_mask
+    # convert the boolean masks to categorical integers by calling local index and remove elements whose mask entry was false
+    irregular_values = awkward.local_index(irregular_mask, axis=1)[irregular_mask]
+    return irregular_values
+
+
 class WeightStatistics:
     """
     Container for statistics about the weight, including the sum of squared weights
@@ -517,10 +608,30 @@ def compute(self):
 
 
 class CutflowToNpz:
-    """Object to be returned by Cutflow.to_npz()"""
+    """Object to be returned by Cutflow.to_npz()
+
+    Parameters
+    ----------
+        includeweights : bool, optional
+            Whether to include the weights in the saved npz file. Default is None, which includes the weights if the Cutflow was instantiated with weights
+            and excludes them otherwise.
+    """
 
     def __init__(
-        self, file, labels, nevonecut, nevcutflow, masksonecut, maskscutflow, saver
+        self,
+        file,
+        labels,
+        nevonecut,
+        nevcutflow,
+        masksonecut,
+        maskscutflow,
+        saver,
+        commonmask=None,
+        wgtevonecut=None,
+        wgtevcutflow=None,
+        weights=None,
+        weightsmodifier=None,
+        includeweights=None,
     ):
         self._file = file
         self._labels = labels
@@ -529,9 +640,18 @@ def __init__(
         self._masksonecut = masksonecut
         self._maskscutflow = maskscutflow
         self._saver = saver
+        self._commonmask = commonmask
+        self._wgtevonecut = wgtevonecut
+        self._wgtevcutflow = wgtevcutflow
+        self._weights = weights if includeweights is not False else None
+        self._weightsmodifier = weightsmodifier
+        self._commonmasked = self.commonmask is not None
+        self._weighted = (self._wgtevonecut is not None) and (
+            self._wgtevcutflow is not None
+        )
 
     def __repr__(self):
-        return f"CutflowToNpz(file={self._file}), labels={self._labels})"
+        return f"CutflowToNpz(file={self._file}), labels={self._labels}, commonmasked={self._commonmasked}, weighted={self._weighted}, weightsmodifier={self._weightsmodifier})"
 
     @property
     def file(self):
@@ -557,25 +677,77 @@ def masksonecut(self):
     def maskscutflow(self):
         return self._maskscutflow
 
+    @property
+    def commonmask(self):
+        return self._commonmask
+
+    @property
+    def wgtevonecut(self):
+        return self._wgtevonecut
+
+    @property
+    def wgtevcutflow(self):
+        return self._wgtevcutflow
+
+    @property
+    def weights(self):
+        return self._weights
+
+    @property
+    def weightsmodifier(self):
+        return self._weightsmodifier
+
     def compute(self):
-        self._nevonecut, self._nevcutflow = dask.compute(
-            self._nevonecut, self._nevcutflow
-        )
-        self._masksonecut, self._maskscutflow = dask.compute(
-            self._masksonecut, self._maskscutflow
+        # Weights has no compute method, ergo it will pass through uncomputed, i.e. as a delayed object
+        # self._weights = list(self._weights) if isinstance(self._weights, (tuple, list)) else self._weights
+        (
+            self._nevonecut,
+            self._nevcutflow,
+            self._commonmask,
+            self._wgtevonecut,
+            self._wgtevcutflow,
+            self._masksonecut,
+            self._maskscutflow,
+            self._weights_wmodifier,
+        ) = dask.compute(
+            self._nevonecut,
+            self._nevcutflow,
+            self._commonmask,
+            self._wgtevonecut,
+            self._wgtevcutflow,
+            self._masksonecut,
+            self._maskscutflow,
+            (
+                self._weights.weight(self._weightsmodifier)
+                if self._weights is not None
+                else None
+            ),
         )
         self._nevonecut = list(self._nevonecut)
         self._nevcutflow = list(self._nevcutflow)
         self._masksonecut = list(self._masksonecut)
         self._maskscutflow = list(self._maskscutflow)
-        self._saver(
-            self._file,
-            labels=self._labels,
-            nevonecut=self._nevonecut,
-            nevcutflow=self._nevcutflow,
-            masksonecut=self._masksonecut,
-            maskscutflow=self._maskscutflow,
+        self._commonmask = list(self._commonmask) if self._commonmasked else None
+        self._wgtevonecut = list(self._wgtevonecut) if self._weighted else None
+        self._wgtevcutflow = list(self._wgtevcutflow) if self._weighted else None
+        self._weights_wmodifier = (
+            list(self._weights_wmodifier) if self._weights is not None else None
         )
+        to_save = {
+            "labels": self._labels,
+            "nevonecut": self._nevonecut,
+            "nevcutflow": self._nevcutflow,
+            "masksonecut": self._masksonecut,
+            "maskscutflow": self._maskscutflow,
+        }
+        if self._commonmask is not None:
+            to_save["commonmask"] = self._commonmask
+        if self._weighted:
+            to_save["wgtevonecut"] = self._wgtevonecut
+            to_save["wgtevcutflow"] = self._wgtevcutflow
+        if self._weights is not None:
+            to_save["weights"] = self._weights_wmodifier
+        self._saver(self._file, **to_save)
 
 
 class NminusOne:
@@ -815,7 +987,18 @@ class Cutflow:
     """Object to be returned by PackedSelection.cutflow()"""
 
     def __init__(
-        self, names, nevonecut, nevcutflow, masksonecut, maskscutflow, delayed_mode
+        self,
+        names,
+        nevonecut,
+        nevcutflow,
+        masksonecut,
+        maskscutflow,
+        delayed_mode,
+        commonmask=None,
+        wgtevonecut=None,
+        wgtevcutflow=None,
+        weights=None,
+        weightsmodifier=None,
     ):
         self._names = names
         self._nevonecut = nevonecut
@@ -823,13 +1006,26 @@ def __init__(
         self._masksonecut = masksonecut
         self._maskscutflow = maskscutflow
         self._delayed_mode = delayed_mode
+        self._commonmask = commonmask
+        self._wgtevonecut = wgtevonecut
+        self._wgtevcutflow = wgtevcutflow
+        self._weights = weights
+        self._weightsmodifier = weightsmodifier
+        self._commonmasked = self._commonmask is not None
+        self._weighted = self._weights is not None
 
     def __repr__(self):
-        return f"Cutflow(selections={self._names})"
+        return f"Cutflow(selections={self._names}, commonmasked={self._commonmasked}, weighted={self._weighted}, weightsmodifier={self._weightsmodifier})"
 
-    def result(self):
+    def result(self, includeweights=None):
         """Returns the results of the cutflow as a namedtuple
 
+        Parameters
+        ----------
+            includeweights : bool, optional
+                Whether to include the weights in the result. Default is None, which includes the weights if the Cutflow was instantiated with weights
+                and excludes them otherwise.
+
         Returns
         -------
             result : CutflowResult
@@ -843,21 +1039,71 @@ def result(self):
                     The boolean mask vectors of which events pass each cut alone as a list of materialized or delayed boolean arrays
                 maskscutflow : list of boolean numpy.ndarray or dask_awkward.lib.core.Array objects
                     The boolean mask vectors of which events pass the cumulative cutflow a list of materialized or delayed boolean arrays
+
+            result: ExtendedCutflowResult
+                A namedtuple with the CutflowResult properties and additionally the following:
+
+                commonmask : boolean numpy.ndarray or dask_awkward.lib.core.Array object, or None if no common mask was provided
+                wgtevonecut : list of floats or dask_awkward.lib.core.Scalar objects, or None if no weights were provided
+                    The weighted number of events that survive each cut alone as a list of floats or delayed floats
+                wgtevcutflow : list of floats or dask_awkward.lib.core.Scalar objects, or None if no weights were provided
+                    The weighted number of events that survive the cumulative cutflow as a list of floats or delayed floats
+                weights : float numpy.ndarray or dask_awkward.lib.core.Array object, or None if no weights were provided
+                    The Weights.weight(modifier) array provided as input. Must be masked by masksonecut or maskscutflow to get the corresponding weights
+                weightsmodifier : str or None
+                    The modifier passed to Weights.weight([modifier]) if weights were provided
+
         """
+        _include_weights = self._weighted if includeweights is None else includeweights
         CutflowResult = namedtuple(
             "CutflowResult",
-            ["labels", "nevonecut", "nevcutflow", "masksonecut", "maskscutflow"],
+            [
+                "labels",
+                "nevonecut",
+                "nevcutflow",
+                "masksonecut",
+                "maskscutflow",
+            ],
         )
-        labels = ["initial"] + list(self._names)
-        return CutflowResult(
-            labels,
-            self._nevonecut,
-            self._nevcutflow,
-            self._masksonecut,
-            self._maskscutflow,
+        ExtendedCutflowResult = namedtuple(
+            "ExtendedCutflowResult",
+            [
+                "labels",
+                "nevonecut",
+                "nevcutflow",
+                "masksonecut",
+                "maskscutflow",
+                "commonmask",
+                "wgtevonecut",
+                "wgtevcutflow",
+                "weights",
+                "weightsmodifier",
+            ],
         )
+        labels = ["initial"] + list(self._names)
+        if self._weighted or self._commonmasked:
+            return ExtendedCutflowResult(
+                labels,
+                self._nevonecut,
+                self._nevcutflow,
+                self._masksonecut,
+                self._maskscutflow,
+                self._commonmask,
+                self._wgtevonecut,
+                self._wgtevcutflow,
+                self._weights if _include_weights else None,
+                self._weightsmodifier if _include_weights else None,
+            )
+        else:
+            return CutflowResult(
+                labels,
+                self._nevonecut,
+                self._nevcutflow,
+                self._masksonecut,
+                self._maskscutflow,
+            )
 
-    def to_npz(self, file, compressed=False, compute=False):
+    def to_npz(self, file, compressed=False, compute=False, includeweights=None):
         """Saves the results of the cutflow to a .npz file
 
         Parameters
@@ -874,6 +1120,8 @@ def to_npz(self, file, compressed=False, compute=False):
                 Whether to immediately start writing or to return an object
                 that the user can choose when to start writing by calling compute().
                 Default is False.
+            includeweights : bool, optional
+                Whether to save the weights in the npz file. Default is None, which saves the weights if the Cutflow was instantiated with weights
 
         Returns
         -------
@@ -881,15 +1129,50 @@ def to_npz(self, file, compressed=False, compute=False):
                 If ``compute=True``, returns None. Otherwise, returns an object
                 that can be used to start writing the data by calling compute().
         """
-        labels, nevonecut, nevcutflow, masksonecut, maskscutflow = self.result()
-
+        (
+            labels,
+            nevonecut,
+            nevcutflow,
+            masksonecut,
+            maskscutflow,
+            *packed_info,
+        ) = self.result(includeweights=includeweights)
+
+        if self._weighted or self._commonmasked:
+            (
+                commonmask,
+                wgtevonecut,
+                wgtevcutflow,
+                weights,
+                weightsmodifier,
+            ) = packed_info
+        else:
+            (
+                commonmask,
+                wgtevonecut,
+                wgtevcutflow,
+                weights,
+                weightsmodifier,
+            ) = (None, None, None, None, None)
         if compressed:
             saver = numpy.savez_compressed
         else:
             saver = numpy.savez
 
         out = CutflowToNpz(
-            file, labels, nevonecut, nevcutflow, masksonecut, maskscutflow, saver
+            file,
+            labels,
+            nevonecut,
+            nevcutflow,
+            masksonecut,
+            maskscutflow,
+            saver,
+            commonmask,
+            wgtevonecut,
+            wgtevcutflow,
+            weights,
+            weightsmodifier,
+            includeweights=includeweights,
         )
         if compute:
             out.compute()
@@ -897,35 +1180,80 @@ def to_npz(self, file, compressed=False, compute=False):
         else:
             return out
 
-    def print(self):
-        """Prints the statistics of the Cutflow"""
+    def print(self, weighted=None, scale=None):
+        """Prints the statistics of the Cutflow
+
+        Parameters
+        ----------
+            weighted : bool, optional
+                Whether to print the weighted statistics. Default is None, which prints the weighted statistics
+                if the cutflow was instantiated with weights and unweighted statistics otherwise.
+            scale : float, optional
+                A scale factor to apply to the cutflow statistics. Default is None, which does not apply any scaling.
+        """
+        do_weighted = self._weighted if weighted is None else weighted
+        do_scaled = scale is not None
+        if do_scaled:
+            if isinstance(scale, (int, float)):
+                pass
+            else:
+                raise ValueError(
+                    f"The scale must be an integer or a float, {scale} (type {type(scale)}) was provided."
+                )
 
         if self._delayed_mode:
             warnings.warn(
                 "Printing the cutflow statistics is going to compute dask_awkward objects."
             )
-            self._nevonecut, self._nevcutflow = dask.compute(
-                self._nevonecut, self._nevcutflow
+            self._nevonecut, self._nevcutflow, self._wgtevonecut, self._wgtevcutflow = (
+                dask.compute(
+                    self._nevonecut,
+                    self._nevcutflow,
+                    self._wgtevonecut,
+                    self._wgtevcutflow,
+                )
             )
 
-        nevonecut = self._nevonecut
-        nevcutflow = self._nevcutflow
-
-        print("Cutflow stats:")
+        xevonecut = self._nevonecut if not do_weighted else self._wgtevonecut
+        xevcutflow = self._nevcutflow if not do_weighted else self._wgtevcutflow
+
+        header = "Cutflow stats:"
+        if do_weighted:
+            header += " (weighted)"
+        if do_scaled:
+            header += f" (scaled by {scale})"
+            xevonecut = [x * scale for x in xevonecut]
+            xevcutflow = [x * scale for x in xevcutflow]
+        print(header)
         for i, name in enumerate(self._names):
             stats = (
                 f"Cut {name:<20}:"
-                f"pass = {nevonecut[i+1]:<20}"
-                f"cumulative pass = {nevcutflow[i+1]:<20}"
-                f"all = {nevonecut[0]:<20}"
-                f"-- eff = {nevonecut[i+1]*100/nevonecut[0]:.1f} %{'':<20}"
-                f"-- cumulative eff = {nevcutflow[i+1]*100/nevcutflow[0]:.1f} %"
+                f"pass = {xevonecut[i+1]:<20}"
+                f"cumulative pass = {xevcutflow[i+1]:<20}"
+                f"all = {xevonecut[0]:<20}"
+                f"-- eff = {xevonecut[i+1]*100/xevonecut[0]:.1f} %{'':<20}"
+                f"-- cumulative eff = {xevcutflow[i+1]*100/xevcutflow[0]:.1f} %"
             )
             print(stats)
 
-    def yieldhist(self):
+    def yieldhist(self, weighted=None, scale=None, categorical=None):
         """Returns the cutflow yields as ``hist.Hist`` objects
 
+        Parameters
+        ----------
+            weighted : bool, optional
+                Whether to fill the histograms with weights. Default is None, which applies the weights
+                if the cutflow was instantiated with weights and unweighted statistics otherwise.
+            categorical : dict, optional
+                A dictionary with the following keys:
+                    axis : hist.axis object
+                        The axis to be used as a categorical axis
+                    values : list
+                        The array to be filled in the categorical axis, must be the same length as the masks
+                    labels : list
+                        The labels corresponding to the values in the categorical axis
+                Default is None, which does not apply any categorical axis.
+
         Returns
         -------
             honecut : hist.Hist or hist.dask.Hist
@@ -933,34 +1261,161 @@ def yieldhist(self):
             hcutflow : hist.Hist or hist.dask.Hist
                 Histogram of the number of events surviving the cumulative cutflow
             labels : list of strings
-                The bin labels of the histograms
+                The bin labels of the onecut/cutflow histograms
+            catlabels : list of strings
+                The labels of the categorical axis
         """
+        do_weighted = self._weighted if weighted is None else weighted
+        do_categorical = categorical is not None
+        do_commonmasked = self._commonmasked
+        do_scaled = scale is not None
+        if do_scaled:
+            if isinstance(scale, (int, float)):
+                pass
+            else:
+                raise ValueError(
+                    f"The scale must be an integer or a float, {scale} (type {type(scale)}) was provided."
+                )
+        Hist = hist.Hist if not self._delayed_mode else hist.dask.Hist
+        ak_or_dak = awkward if not self._delayed_mode else dask_awkward
         labels = ["initial"] + list(self._names)
-
-        if not self._delayed_mode:
-            honecut = hist.Hist(hist.axis.Integer(0, len(labels), name="onecut"))
+        axes = [hist.axis.Integer(0, len(labels), name="onecut")]
+        if do_categorical:
+            catax = categorical.get("axis")
+            catvar = categorical.get("values")
+            catlabels = categorical.get("labels")
+            axes.append(catax)
+        else:
+            catlabels = None
+        if do_weighted:
+            axes.append(hist.storage.Weight())
+        if not self._delayed_mode and not do_categorical:
+            if categorical is not None:
+                raise NotImplementedError(
+                    "yieldhist is not implemented for non-delayed mode (v1) with categorical"
+                )
+            honecut = hist.Hist(*axes)
             hcutflow = honecut.copy()
             hcutflow.axes.name = ("cutflow",)
-            honecut.fill(numpy.arange(len(labels), dtype=int), weight=self._nevonecut)
-            hcutflow.fill(numpy.arange(len(labels), dtype=int), weight=self._nevcutflow)
-
-        else:
-            honecut = hist.dask.Hist(hist.axis.Integer(0, len(labels), name="onecut"))
+            weightonecut = self._wgtevonecut if do_weighted else self._nevonecut
+            weightcutflow = self._wgtevcutflow if do_weighted else self._nevcutflow
+            if do_scaled:
+                weightonecut = [wgt * scale for wgt in weightonecut]
+                weightcutflow = [wgt * scale for wgt in weightcutflow]
+            honecut.fill(numpy.arange(len(labels), dtype=int), weight=weightonecut)
+            hcutflow.fill(numpy.arange(len(labels), dtype=int), weight=weightcutflow)
+        elif self._delayed_mode and not do_categorical:
+            if categorical is not None:
+                raise NotImplementedError(
+                    "yieldhist is not implemented for non-delayed mode (v1) with categorical"
+                )
+            honecut = hist.dask.Hist(*axes)
             hcutflow = honecut.copy()
             hcutflow.axes.name = ("cutflow",)
 
-            for i, weight in enumerate(self._masksonecut, 1):
+            for i, mask in enumerate(self._masksonecut, 1):
+                weight = (
+                    self._weights.weight(self._weightsmodifier)[mask]
+                    if do_weighted
+                    else mask
+                )
+                if do_scaled:
+                    weight = weight * scale
                 honecut.fill(
                     dask_awkward.full_like(weight, i, dtype=int), weight=weight
                 )
-            honecut.fill(dask_awkward.zeros_like(weight, dtype=int))
-            for i, weight in enumerate(self._maskscutflow, 1):
+            weight = (
+                self._weights.weight(self._weightsmodifier)
+                if do_weighted
+                else dask_awkward.ones_like(self._masksonecut[0], dtype=bool)
+            )
+            if do_scaled:
+                weight = weight * scale
+            if do_commonmasked:
+                weight = weight[self._commonmask]
+            honecut.fill(dask_awkward.zeros_like(weight, dtype=int), weight=weight)
+
+            for i, mask in enumerate(self._maskscutflow, 1):
+                weight = (
+                    self._weights.weight(self._weightsmodifier)[mask]
+                    if do_weighted
+                    else mask
+                )
+                if do_scaled:
+                    weight = weight * scale
                 hcutflow.fill(
                     dask_awkward.full_like(weight, i, dtype=int), weight=weight
                 )
-            hcutflow.fill(dask_awkward.zeros_like(weight, dtype=int))
+            weight = (
+                self._weights.weight(self._weightsmodifier)
+                if do_weighted
+                else dask_awkward.ones_like(self._maskscutflow[0], dtype=bool)
+            )
+            if do_scaled:
+                weight = weight * scale
+            if do_commonmasked:
+                weight = weight[self._commonmask]
+            hcutflow.fill(dask_awkward.zeros_like(weight, dtype=int), weight=weight)
+        else:
+            honecut = Hist(*axes)
+            hcutflow = honecut.copy()
+            hcutflow.axes.name = ("cutflow", *honecut.axes[1:].name)
 
-        return honecut, hcutflow, labels
+            weight = (
+                self._weights.weight(self._weightsmodifier)
+                if do_weighted
+                else ak_or_dak.ones_like(self._masksonecut[0], dtype=numpy.float32)
+            )
+            if do_scaled:
+                weight = weight * scale
+            if self._commonmasked:
+                to_broadcastonecut = {
+                    "onecut": boolean_masks_to_categorical_integers(
+                        self._masksonecut, insert_commonmask_as_zeros=self._commonmask
+                    )
+                }
+                to_broadcastcutflow = {
+                    "cutflow": boolean_masks_to_categorical_integers(
+                        self._maskscutflow, insert_commonmask_as_zeros=self._commonmask
+                    )
+                }
+            else:
+                to_broadcastonecut = {
+                    "onecut": boolean_masks_to_categorical_integers(
+                        self._masksonecut, insert_unmasked_as_zeros=True
+                    )
+                }
+                to_broadcastcutflow = {
+                    "cutflow": boolean_masks_to_categorical_integers(
+                        self._maskscutflow, insert_unmasked_as_zeros=True
+                    )
+                }
+            if do_categorical:
+                to_broadcastonecut[catax.name] = catvar
+                to_broadcastcutflow[catax.name] = catvar
+            to_broadcastonecut["weight"] = weight
+            to_broadcastcutflow["weight"] = weight
+            broadcastedonecut = zip(
+                to_broadcastonecut.keys(),
+                ak_or_dak.broadcast_arrays(*to_broadcastonecut.values()),
+            )
+            broadcastedcutflow = zip(
+                to_broadcastcutflow.keys(),
+                ak_or_dak.broadcast_arrays(*to_broadcastcutflow.values()),
+            )
+            onecutargs = {
+                k: ak_or_dak.flatten(arr, axis=None) for k, arr in broadcastedonecut
+            }
+            cutflowargs = {
+                k: ak_or_dak.flatten(arr, axis=None) for k, arr in broadcastedcutflow
+            }
+            honecut.fill(**onecutargs)
+            hcutflow.fill(**cutflowargs)
+
+        if do_categorical:
+            return honecut, hcutflow, labels, catlabels
+        else:
+            return honecut, hcutflow, labels
 
     def plot_vars(
         self,
@@ -971,6 +1426,9 @@ def plot_vars(
         stop=None,
         edges=None,
         transform=None,
+        weighted=None,
+        scale=None,
+        categorical=None,
     ):
         """Plot the histograms of variables for each step of the N-1 selection
 
@@ -998,6 +1456,9 @@ def plot_vars(
             transform : iterable of hist.axis.transform objects or Nones, optional
                 The transforms to apply to each variable histogram axis. If not specified, it defaults to None.
                 Must be the same length as ``vars``.
+            weighted : bool, optional
+                Whether to fill the histograms with weights. Default is None, which applies the weights
+                if the cutflow was instantiated with weights and unweighted distributions otherwise.
 
         Returns
         -------
@@ -1009,11 +1470,34 @@ def plot_vars(
                 The first axis is the variable, the second axis is the cuts.
             labels : list of strings
                 The bin labels of the y axis of the histograms.
+            catlabels : list of strings, optional
+                The labels of the categorical axis
         """
+        do_weighted = self._weighted if weighted is None else weighted
+        do_categorical = categorical is not None
+        do_scaled = scale is not None
+        if do_scaled:
+            if isinstance(scale, (int, float)):
+                pass
+            else:
+                raise ValueError(
+                    f"The scale must be an integer or a float, {scale} (type {type(scale)}) was provided."
+                )
+        Hist = hist.dask.Hist if self._delayed_mode else hist.Hist
+        ak_or_dak = dask_awkward if self._delayed_mode else awkward
+        if do_categorical:
+            catax = categorical.get("axis")
+            catvar = categorical.get("values")
+            catlabels = categorical.get("labels")
         if self._delayed_mode:
             for name, var in vars.items():
                 if not compatible_partitions(var, self._masksonecut[0]):
                     raise IncompatiblePartitions("plot_vars", var, self._masksonecut[0])
+            if do_categorical:
+                if not compatible_partitions(catvar, self._masksonecut[0]):
+                    raise IncompatiblePartitions(
+                        "plot_vars (categorical values)", catvar, self._masksonecut[0]
+                    )
         else:
             for name, var in vars.items():
                 if len(var) != len(self._masksonecut[0]):
@@ -1050,53 +1534,91 @@ def plot_vars(
                 "vars, axes, bins, start, stop, edges, and transform must be the same length"
             )
 
-        if not self._delayed_mode:
-            for (name, var), axis in zip(vars.items(), axes):
-                honecut = hist.Hist(
-                    axis,
-                    hist.axis.Integer(0, len(labels), name="onecut"),
-                )
-                hcutflow = honecut.copy()
-                hcutflow.axes.name = name, "cutflow"
-
-                arr = awkward.flatten(var)
-                honecut.fill(arr, awkward.zeros_like(arr, dtype=int))
-                hcutflow.fill(arr, awkward.zeros_like(arr, dtype=int))
-
-                for i, mask in enumerate(self.result().masksonecut, 1):
-                    arr = awkward.flatten(var[mask])
-                    honecut.fill(arr, awkward.full_like(arr, i, dtype=int))
-                histsonecut.append(honecut)
-
-                for i, mask in enumerate(self.result().maskscutflow, 1):
-                    arr = awkward.flatten(var[mask])
-                    hcutflow.fill(arr, awkward.full_like(arr, i, dtype=int))
-                histscutflow.append(hcutflow)
+        for (name, var), axis in zip(vars.items(), axes):
+            constructor_args = [axis, hist.axis.Integer(0, len(labels), name="onecut")]
+            fill_args = {name: var}
+            if do_categorical:
+                constructor_args.append(catax)
+                fill_args[catax.name] = catvar
+            if do_weighted:
+                constructor_args.append(hist.storage.Weight())
+            fill_args["weight"] = (
+                self._weights.weight(self._weightsmodifier)
+                if do_weighted
+                else ak_or_dak.ones_like(self._masksonecut[0], dtype=numpy.float32)
+            )
+            if do_scaled:
+                fill_args["weight"] = fill_args["weight"] * scale
+            honecut = Hist(*constructor_args)
+            hcutflow = honecut.copy()
+            hcutflow.axes.name = (name, "cutflow", *honecut.axes[2:].name)
 
-        else:
-            for (name, var), axis in zip(vars.items(), axes):
-                honecut = hist.dask.Hist(
-                    axis,
-                    hist.axis.Integer(0, len(labels), name="onecut"),
+            # initial fill is special, needs to have commonmask applied if it exists
+            to_fill_initial = (
+                {k: v[self.result().commonmask] for k, v in fill_args.items()}
+                if self._commonmasked
+                else fill_args
+            )
+            to_fill_initial = dict(
+                zip(
+                    to_fill_initial.keys(),
+                    [
+                        ak_or_dak.flatten(arr)
+                        for arr in ak_or_dak.broadcast_arrays(*to_fill_initial.values())
+                    ],
                 )
-                hcutflow = honecut.copy()
-                hcutflow.axes.name = name, "cutflow"
-
-                arr = dask_awkward.flatten(var)
-                honecut.fill(arr, dask_awkward.zeros_like(arr, dtype=int))
-                hcutflow.fill(arr, dask_awkward.zeros_like(arr, dtype=int))
+            )
+            honecut.fill(
+                onecut=ak_or_dak.zeros_like(to_fill_initial[name], dtype=int),
+                **to_fill_initial,
+            )
 
-                for i, mask in enumerate(self.result().masksonecut, 1):
-                    arr = dask_awkward.flatten(var[mask])
-                    honecut.fill(arr, dask_awkward.full_like(arr, i, dtype=int))
-                histsonecut.append(honecut)
+            for i, mask in enumerate(self.result().masksonecut, 1):
+                to_fill_iter = {k: v[mask] for k, v in fill_args.items()}
+                to_fill_iter = dict(
+                    zip(
+                        to_fill_iter.keys(),
+                        [
+                            ak_or_dak.flatten(arr)
+                            for arr in ak_or_dak.broadcast_arrays(
+                                *to_fill_iter.values()
+                            )
+                        ],
+                    )
+                )
+                honecut.fill(
+                    onecut=ak_or_dak.full_like(to_fill_iter[name], i, dtype=int),
+                    **to_fill_iter,
+                )
+            histsonecut.append(honecut)
 
-                for i, mask in enumerate(self.result().maskscutflow, 1):
-                    arr = dask_awkward.flatten(var[mask])
-                    hcutflow.fill(arr, dask_awkward.full_like(arr, i, dtype=int))
-                histscutflow.append(hcutflow)
+            hcutflow.fill(
+                cutflow=ak_or_dak.zeros_like(to_fill_initial[name], dtype=int),
+                **to_fill_initial,
+            )
+            for i, mask in enumerate(self.result().maskscutflow, 1):
+                to_fill_iter = {k: v[mask] for k, v in fill_args.items()}
+                to_fill_iter = dict(
+                    zip(
+                        to_fill_iter.keys(),
+                        [
+                            ak_or_dak.flatten(arr)
+                            for arr in ak_or_dak.broadcast_arrays(
+                                *to_fill_iter.values()
+                            )
+                        ],
+                    )
+                )
+                hcutflow.fill(
+                    cutflow=ak_or_dak.full_like(to_fill_iter[name], i, dtype=int),
+                    **to_fill_iter,
+                )
+            histscutflow.append(hcutflow)
 
-        return histsonecut, histscutflow, labels
+        if do_categorical:
+            return histsonecut, histscutflow, labels, catlabels
+        else:
+            return histsonecut, histscutflow, labels
 
 
 class PackedSelection:
@@ -1405,7 +1927,7 @@ def nminusone(self, *names):
 
         return NminusOne(names, nev, masks, self.delayed_mode)
 
-    def cutflow(self, *names):
+    def cutflow(self, *names, commonmask=None, weights=None, weightsmodifier=None):
         """Compute the cutflow for a set of selections
 
         Returns an object which can return a list of the number of events that pass all the previous selections including the current one
@@ -1420,6 +1942,12 @@ def cutflow(self, *names):
         ----------
             ``*names`` : args
                 The named selections to use, need to be a subset of the selections already added
+            commonmask : boolean numpy.ndarray or dask_awkward.lib.core.Array, optional
+                A common mask which is applied for all the selections, including the initial one. Default is None.
+            weights : coffea.analysis_tools.Weights instance, optional
+                The Weights object to use for the cutflow. If not provided, the cutflow will be unweighted.
+            modifier : str, optional
+                The modifier to use for the weights. Default is None which results in Weights.weight() being called without a modifier.
 
         Returns
         -------
@@ -1433,24 +1961,93 @@ def cutflow(self, *names):
                 )
 
         masksonecut, maskscutflow = [], []
+        if weights is not None:
+            weightsonecut, weightscutflow = [], []
+        else:
+            weightsonecut, weightscutflow, wgtevonecut, wgtevcutflow = (
+                None,
+                None,
+                None,
+                None,
+            )
         for i, cut in enumerate(names):
             mask1 = self.any(cut)
             mask2 = self.all(*(names[: i + 1]))
+            if commonmask is not None:
+                mask1 = mask1 & commonmask
+                mask2 = mask2 & commonmask
             masksonecut.append(mask1)
             maskscutflow.append(mask2)
+            if weights is not None:
+                weights1 = weights.weight(weightsmodifier)[mask1]
+                weights2 = weights.weight(weightsmodifier)[mask2]
+                weightsonecut.append(weights1)
+                weightscutflow.append(weights2)
 
         if not self.delayed_mode:
-            nevonecut = [len(self._data)]
-            nevcutflow = [len(self._data)]
+            nevonecut = [
+                numpy.sum(commonmask) if commonmask is not None else len(self._data)
+            ]
+            nevcutflow = [
+                numpy.sum(commonmask) if commonmask is not None else len(self._data)
+            ]
             nevonecut.extend(numpy.sum(masksonecut, axis=1))
             nevcutflow.extend(numpy.sum(maskscutflow, axis=1))
+            if weights is not None:
+                if commonmask is not None:
+                    wgtevonecut = [
+                        numpy.sum(weights.weight(weightsmodifier)[commonmask])
+                    ]
+                    wgtevcutflow = [
+                        numpy.sum(weights.weight(weightsmodifier)[commonmask])
+                    ]
+                else:
+                    wgtevonecut = [numpy.sum(weights.weight(weightsmodifier))]
+                    wgtevcutflow = [numpy.sum(weights.weight(weightsmodifier))]
+                wgtevonecut.extend([numpy.sum(wgt1) for wgt1 in weightsonecut])
+                wgtevcutflow.extend([numpy.sum(wgt2) for wgt2 in weightscutflow])
 
         else:
-            nevonecut = [dask_awkward.count(self._data, axis=0)]
-            nevcutflow = [dask_awkward.count(self._data, axis=0)]
+            nevonecut = [
+                (
+                    dask_awkward.sum(commonmask)
+                    if commonmask is not None
+                    else dask_awkward.count(self._data, axis=0)
+                )
+            ]
+            nevcutflow = [
+                (
+                    dask_awkward.sum(commonmask)
+                    if commonmask is not None
+                    else dask_awkward.count(self._data, axis=0)
+                )
+            ]
             nevonecut.extend([dask_awkward.sum(mask1) for mask1 in masksonecut])
             nevcutflow.extend([dask_awkward.sum(mask2) for mask2 in maskscutflow])
+            if weights is not None:
+                if commonmask is not None:
+                    wgtevonecut = [
+                        dask_awkward.sum(weights.weight(weightsmodifier)[commonmask])
+                    ]
+                    wgtevcutflow = [
+                        dask_awkward.sum(weights.weight(weightsmodifier)[commonmask])
+                    ]
+                else:
+                    wgtevonecut = [dask_awkward.sum(weights.weight(weightsmodifier))]
+                    wgtevcutflow = [dask_awkward.sum(weights.weight(weightsmodifier))]
+                wgtevonecut.extend([dask_awkward.sum(wgt1) for wgt1 in weightsonecut])
+                wgtevcutflow.extend([dask_awkward.sum(wgt2) for wgt2 in weightscutflow])
 
         return Cutflow(
-            names, nevonecut, nevcutflow, masksonecut, maskscutflow, self.delayed_mode
+            names,
+            nevonecut,
+            nevcutflow,
+            masksonecut,
+            maskscutflow,
+            self.delayed_mode,
+            commonmask,
+            wgtevonecut,
+            wgtevcutflow,
+            weights,
+            weightsmodifier,
         )
diff --git a/tests/test_analysis_tools.py b/tests/test_analysis_tools.py
index c0b4baab0..a85a059bb 100644
--- a/tests/test_analysis_tools.py
+++ b/tests/test_analysis_tools.py
@@ -1,5 +1,7 @@
 import os
+import tempfile
 
+import hist
 import numpy as np
 import pytest
 import uproot
@@ -552,19 +554,20 @@ def test_packed_selection_nminusone():
     ):
         assert np.all(mask == truth)
 
-    nminusone.to_npz("nminusone.npz", compressed=False).compute()
-    with np.load("nminusone.npz") as file:
-        assert np.all(file["labels"] == labels)
-        assert np.all(file["nev"] == nev)
-        assert np.all(file["masks"] == masks)
-    os.remove("nminusone.npz")
+    with tempfile.TemporaryDirectory() as tmp:
+        nminusone_uncompressed = os.path.join(tmp, "nminusone_uncompressed.npz")
+        nminusone.to_npz(nminusone_uncompressed, compressed=False).compute()
+        with np.load(nminusone_uncompressed) as file:
+            assert np.all(file["labels"] == labels)
+            assert np.all(file["nev"] == nev)
+            assert np.all(file["masks"] == masks)
 
-    nminusone.to_npz("nminusone.npz", compressed=True).compute()
-    with np.load("nminusone.npz") as file:
-        assert np.all(file["labels"] == labels)
-        assert np.all(file["nev"] == nev)
-        assert np.all(file["masks"] == masks)
-    os.remove("nminusone.npz")
+        nminusone_compressed = os.path.join(tmp, "nminusone_compresssed.npz")
+        nminusone.to_npz(nminusone_compressed, compressed=True).compute()
+        with np.load(nminusone_compressed) as file:
+            assert np.all(file["labels"] == labels)
+            assert np.all(file["nev"] == nev)
+            assert np.all(file["masks"] == masks)
 
     h, hlabels = nminusone.yieldhist()
 
@@ -660,23 +663,24 @@ def test_packed_selection_cutflow():
     ):
         assert np.all(mask == truth)
 
-    cutflow.to_npz("cutflow.npz", compressed=False).compute()
-    with np.load("cutflow.npz") as file:
-        assert np.all(file["labels"] == labels)
-        assert np.all(file["nevonecut"] == nevonecut)
-        assert np.all(file["nevcutflow"] == nevcutflow)
-        assert np.all(file["masksonecut"] == masksonecut)
-        assert np.all(file["maskscutflow"] == maskscutflow)
-    os.remove("cutflow.npz")
-
-    cutflow.to_npz("cutflow.npz", compressed=True).compute()
-    with np.load("cutflow.npz") as file:
-        assert np.all(file["labels"] == labels)
-        assert np.all(file["nevonecut"] == nevonecut)
-        assert np.all(file["nevcutflow"] == nevcutflow)
-        assert np.all(file["masksonecut"] == masksonecut)
-        assert np.all(file["maskscutflow"] == maskscutflow)
-    os.remove("cutflow.npz")
+    with tempfile.TemporaryDirectory() as tmp:
+        cutflow_uncompressed = os.path.join(tmp, "cutflow_uncompresssed.npz")
+        cutflow.to_npz(cutflow_uncompressed, compressed=False).compute()
+        with np.load(cutflow_uncompressed) as file:
+            assert np.all(file["labels"] == labels)
+            assert np.all(file["nevonecut"] == nevonecut)
+            assert np.all(file["nevcutflow"] == nevcutflow)
+            assert np.all(file["masksonecut"] == masksonecut)
+            assert np.all(file["maskscutflow"] == maskscutflow)
+
+        cutflow_compressed = os.path.join(tmp, "cutflow_compresssed.npz")
+        cutflow.to_npz(cutflow_compressed, compressed=True).compute()
+        with np.load(cutflow_compressed) as file:
+            assert np.all(file["labels"] == labels)
+            assert np.all(file["nevonecut"] == nevonecut)
+            assert np.all(file["nevcutflow"] == nevcutflow)
+            assert np.all(file["masksonecut"] == masksonecut)
+            assert np.all(file["maskscutflow"] == maskscutflow)
 
     honecut, hcutflow, hlabels = cutflow.yieldhist()
 
@@ -724,6 +728,312 @@ def test_packed_selection_cutflow():
             assert np.all(np.isclose(counts[1:-1], c))
 
 
+@pytest.mark.parametrize("weighted", [True, False])
+@pytest.mark.parametrize("commonmasked", [True, False])
+@pytest.mark.parametrize("withcategorical", [True, False])
+def test_packed_selection_cutflow_extended(weighted, commonmasked, withcategorical):
+
+    import awkward as ak
+
+    from coffea.analysis_tools import PackedSelection, Weights
+
+    events = eagerevents
+
+    selection = PackedSelection()
+
+    twoelectron = ak.num(events.Electron) == 2
+    nomuon = ak.num(events.Muon) == 0
+    leadpt20 = ak.any(events.Electron.pt >= 20.0, axis=1) | ak.any(
+        events.Muon.pt >= 20.0, axis=1
+    )
+    selection.add_multiple(
+        {
+            "twoElectron": twoelectron,
+            "noMuon": nomuon,
+            "leadPt20": leadpt20,
+        }
+    )
+
+    assert selection.names == ["twoElectron", "noMuon", "leadPt20"]
+
+    commonmask = (ak.num(events.Electron) >= 1) & (ak.num(events.Muon) <= 1)
+
+    categorical = {
+        "axis": hist.axis.IntCategory(
+            [0, 41, 43], name="genTtbarId", growth=False, flow=False
+        ),
+        "values": events.genTtbarId,
+        "labels": ["0", "41", "43"],
+    }
+
+    weight = Weights(len(events))
+    weight.add(
+        "test",
+        ak.ones_like(events.genWeight),
+        weightUp=1.25 * ak.ones_like(events.genWeight),
+        weightDown=0.5 * ak.ones_like(events.genWeight),
+    )
+
+    with pytest.raises(
+        ValueError,
+        match="All arguments must be strings that refer to the names of existing selections",
+    ):
+        selection.cutflow("twoElectron", "nonexistent")
+    cutflow = selection.cutflow(
+        "noMuon",
+        "twoElectron",
+        "leadPt20",
+        commonmask=commonmask if commonmasked else None,
+        weights=weight if weighted else None,
+        weightsmodifier="testUp" if weighted else None,
+    )
+
+    labels, nevonecut, nevcutflow, masksonecut, maskscutflow, *packed = cutflow.result()
+
+    if commonmasked or weighted:
+        r_commonmask, r_wgtevonecut, r_wgtevcutflow, r_weights, r_weightsmodifier = (
+            packed
+        )
+    else:
+        r_commonmask, r_wgtevonecut, r_wgtevcutflow, r_weights, r_weightsmodifier = (
+            None,
+            None,
+            None,
+            None,
+            None,
+        )
+
+    assert labels == ["initial", "noMuon", "twoElectron", "leadPt20"]
+    assert nevonecut == [
+        len(events) if not commonmasked else len(events[commonmask]),
+        len(events[nomuon]) if not commonmasked else len(events[nomuon & commonmask]),
+        (
+            len(events[twoelectron])
+            if not commonmasked
+            else len(events[twoelectron & commonmask])
+        ),
+        (
+            len(events[leadpt20])
+            if not commonmasked
+            else len(events[leadpt20 & commonmask])
+        ),
+    ]
+
+    assert nevcutflow == [
+        len(events) if not commonmasked else len(events[commonmask]),
+        len(events[nomuon]) if not commonmasked else len(events[nomuon & commonmask]),
+        (
+            len(events[nomuon & twoelectron])
+            if not commonmasked
+            else len(events[nomuon & twoelectron & commonmask])
+        ),
+        (
+            len(events[nomuon & twoelectron & leadpt20])
+            if not commonmasked
+            else len(events[nomuon & twoelectron & leadpt20 & commonmask])
+        ),
+    ]
+
+    if weighted:
+        if commonmasked:
+            assert np.isclose(
+                r_wgtevcutflow[0], np.sum(weight.weight(r_weightsmodifier)[commonmask])
+            )
+        else:
+            assert np.isclose(
+                r_wgtevcutflow[0], np.sum(weight.weight(r_weightsmodifier))
+            )
+    truths = [nomuon, twoelectron, leadpt20]
+    if commonmasked:
+        truths = [truth & commonmask for truth in truths]
+    for i, (mask, truth) in enumerate(zip(masksonecut, truths), 1):
+        assert np.all(mask == truth)
+        if weighted:
+            assert np.isclose(
+                r_wgtevonecut[i], np.sum(weight.weight(r_weightsmodifier)[truth])
+            )
+
+    truths = [nomuon, nomuon & twoelectron, nomuon & twoelectron & leadpt20]
+    if commonmasked:
+        truths = [truth & commonmask for truth in truths]
+    for i, (mask, truth) in enumerate(zip(maskscutflow, truths), 1):
+        assert np.all(mask == truth)
+        if weighted:
+            assert np.isclose(
+                r_wgtevcutflow[i], np.sum(weight.weight(r_weightsmodifier)[truth])
+            )
+
+    with tempfile.TemporaryDirectory() as tmp:
+        cutflow_uncompressed = os.path.join(tmp, "cutflow_uncompresssed.npz")
+        cutflow.to_npz(
+            cutflow_uncompressed, compressed=False, includeweights=False
+        ).compute()
+        with np.load(cutflow_uncompressed) as file:
+            assert np.all(file["labels"] == labels)
+            assert np.all(file["nevonecut"] == nevonecut)
+            assert np.all(file["nevcutflow"] == nevcutflow)
+            assert np.all(file["masksonecut"] == masksonecut)
+            assert np.all(file["maskscutflow"] == maskscutflow)
+            if commonmasked:
+                assert np.all(file["commonmask"] == r_commonmask)
+            else:
+                assert "commonmask" not in file
+            if weighted:
+                assert np.all(file["wgtevonecut"] == r_wgtevonecut)
+                assert np.all(file["wgtevcutflow"] == r_wgtevcutflow)
+            else:
+                assert "wgtevonecut" not in file
+                assert "wgtevcutflow" not in file
+            assert "weights" not in file
+
+        cutflow_compressed = os.path.join(tmp, "cutflow_compressed.npz")
+        cutflow.to_npz(cutflow_compressed, compressed=True).compute()
+        with np.load(cutflow_compressed) as file:
+            assert np.all(file["labels"] == labels)
+            assert np.all(file["nevonecut"] == nevonecut)
+            assert np.all(file["nevcutflow"] == nevcutflow)
+            assert np.all(file["masksonecut"] == masksonecut)
+            assert np.all(file["maskscutflow"] == maskscutflow)
+            if commonmasked:
+                assert np.all(file["commonmask"] == r_commonmask)
+            else:
+                assert "commonmask" not in file
+            if weighted:
+                assert np.all(file["wgtevonecut"] == r_wgtevonecut)
+                assert np.all(file["wgtevcutflow"] == r_wgtevcutflow)
+                assert np.all(file["weights"] == r_weights.weight(r_weightsmodifier))
+            else:
+                assert "wgtevonecut" not in file
+                assert "wgtevcutflow" not in file
+                assert "weights" not in file
+
+        cutflow_compressed_weighted = os.path.join(
+            tmp, "cutflow_compresssed_weighted.npz"
+        )
+        cutflow.to_npz(
+            cutflow_compressed_weighted, compressed=True, includeweights=True
+        ).compute()
+        with np.load(cutflow_compressed_weighted) as file:
+            assert np.all(file["labels"] == labels)
+            assert np.all(file["nevonecut"] == nevonecut)
+            assert np.all(file["nevcutflow"] == nevcutflow)
+            assert np.all(file["masksonecut"] == masksonecut)
+            assert np.all(file["maskscutflow"] == maskscutflow)
+            if commonmasked:
+                assert np.all(file["commonmask"] == r_commonmask)
+            else:
+                assert "commonmask" not in file
+            if weighted:
+                assert np.all(file["wgtevonecut"] == r_wgtevonecut)
+                assert np.all(file["wgtevcutflow"] == r_wgtevcutflow)
+                assert np.all(file["weights"] == r_weights.weight(r_weightsmodifier))
+            else:
+                assert "wgtevonecut" not in file
+                assert "wgtevcutflow" not in file
+                assert "weights" not in file
+
+    honecut, hcutflow, hlabels, *optional = cutflow.yieldhist(
+        weighted=weighted, categorical=categorical if withcategorical else None
+    )
+
+    assert hlabels == ["initial", "noMuon", "twoElectron", "leadPt20"]
+
+    assert np.all(honecut.axes["onecut"].edges == np.arange(0, 5))
+    assert np.all(hcutflow.axes["cutflow"].edges == np.arange(0, 5))
+    if withcategorical:
+        assert np.all(honecut.axes["genTtbarId"].edges == np.array([0, 1, 2, 3]))
+        assert np.all(hcutflow.axes["genTtbarId"].edges == np.array([0, 1, 2, 3]))
+
+    firstcatentry = 36 if not commonmasked else 15
+    if weighted:
+        assert np.all(honecut.project("onecut").counts() == r_wgtevonecut)
+        assert np.all(hcutflow.project("cutflow").counts() == r_wgtevcutflow)
+        if withcategorical:
+            assert np.all(
+                np.isclose(
+                    honecut[0, :].project("genTtbarId").counts(),
+                    1.25 * np.array([firstcatentry, 3, 1]),
+                )
+            )
+            assert np.all(
+                np.isclose(
+                    hcutflow[0, :].project("genTtbarId").counts(),
+                    1.25 * np.array([firstcatentry, 3, 1]),
+                )
+            )
+    else:
+        assert np.all(honecut.project("onecut").counts() == nevonecut)
+        assert np.all(hcutflow.project("cutflow").counts() == nevcutflow)
+        if withcategorical:
+            assert np.all(
+                np.isclose(
+                    honecut[0, :].project("genTtbarId").counts(),
+                    np.array([firstcatentry, 3, 1]),
+                )
+            )
+            assert np.all(
+                np.isclose(
+                    hcutflow[0, :].project("genTtbarId").counts(),
+                    np.array([firstcatentry, 3, 1]),
+                )
+            )
+
+    with pytest.raises(ValueError):
+        cutflow.plot_vars({"Ept": events.Electron.pt, "Ephi": events.Electron.phi[:20]})
+    honecuts, hcutflows, hslabels, *catlabels = cutflow.plot_vars(
+        {"ept": events.Electron.pt, "ephi": events.Electron.phi},
+        weighted=weighted,
+        categorical=categorical if withcategorical else None,
+    )
+
+    assert hslabels == ["initial", "noMuon", "twoElectron", "leadPt20"]
+    if withcategorical:
+        assert catlabels[0] == ["0", "41", "43"]
+
+    truths = [np.ones(40, dtype=bool), nomuon, twoelectron, leadpt20]
+    if commonmasked:
+        truths = [truth & commonmask for truth in truths]
+    for h, array in zip(honecuts, [events.Electron.pt, events.Electron.phi]):
+        edges = h.axes[0].edges
+        for i, truth in enumerate(truths):
+            counts = h.project(h.axes.name[0], "onecut")[:, i].counts(flow=True)
+            counts[1] += counts[0]
+            counts[-2] += counts[-1]
+            fill_array, fill_weights = ak.broadcast_arrays(
+                array[truth], weight.weight(r_weightsmodifier)[truth]
+            )
+            c, e = np.histogram(
+                ak.flatten(fill_array),
+                bins=edges,
+                weights=ak.flatten(fill_weights) if weighted else None,
+            )
+            assert np.all(np.isclose(counts[1:-1], c))
+
+    truths = [
+        np.ones(40, dtype=bool),
+        nomuon,
+        nomuon & twoelectron,
+        nomuon & twoelectron & leadpt20,
+    ]
+    if commonmasked:
+        truths = [truth & commonmask for truth in truths]
+    for h, array in zip(hcutflows, [events.Electron.pt, events.Electron.phi]):
+        edges = h.axes[0].edges
+        for i, truth in enumerate(truths):
+            counts = h.project(h.axes.name[0], "cutflow")[:, i].counts(flow=True)
+            counts[1] += counts[0]
+            counts[-2] += counts[-1]
+            fill_array, fill_weights = ak.broadcast_arrays(
+                array[truth], weight.weight(r_weightsmodifier)[truth]
+            )
+            c, e = np.histogram(
+                ak.flatten(fill_array),
+                bins=edges,
+                weights=ak.flatten(fill_weights) if weighted else None,
+            )
+            assert np.all(np.isclose(counts[1:-1], c))
+
+
 @pytest.mark.parametrize("optimization_enabled", [True, False])
 @pytest.mark.parametrize("dtype", ["uint16", "uint32", "uint64"])
 def test_packed_selection_basic_dak(optimization_enabled, dtype):
@@ -899,19 +1209,20 @@ def test_packed_selection_nminusone_dak(optimization_enabled):
         ):
             assert np.all(mask.compute() == truth.compute())
 
-        nminusone.to_npz("nminusone.npz", compressed=False).compute()
-        with np.load("nminusone.npz") as file:
-            assert np.all(file["labels"] == labels)
-            assert np.all(file["nev"] == list(dask.compute(*nev)))
-            assert np.all(file["masks"] == list(dask.compute(*masks)))
-        os.remove("nminusone.npz")
-
-        nminusone.to_npz("nminusone.npz", compressed=True).compute()
-        with np.load("nminusone.npz") as file:
-            assert np.all(file["labels"] == labels)
-            assert np.all(file["nev"] == list(dask.compute(*nev)))
-            assert np.all(file["masks"] == list(dask.compute(*masks)))
-        os.remove("nminusone.npz")
+        with tempfile.TemporaryDirectory() as tmp:
+            nminusone_uncompressed = os.path.join(tmp, "nminusone_uncompresssed.npz")
+            nminusone.to_npz(nminusone_uncompressed, compressed=False).compute()
+            with np.load(nminusone_uncompressed) as file:
+                assert np.all(file["labels"] == labels)
+                assert np.all(file["nev"] == list(dask.compute(*nev)))
+                assert np.all(file["masks"] == list(dask.compute(*masks)))
+
+            nminusone_compressed = os.path.join(tmp, "nminusone_compresssed.npz")
+            nminusone.to_npz(nminusone_compressed, compressed=True).compute()
+            with np.load(nminusone_compressed) as file:
+                assert np.all(file["labels"] == labels)
+                assert np.all(file["nev"] == list(dask.compute(*nev)))
+                assert np.all(file["masks"] == list(dask.compute(*masks)))
 
         h, hlabels = dask.compute(*nminusone.yieldhist())
 
@@ -1025,23 +1336,24 @@ def test_packed_selection_cutflow_dak(optimization_enabled):
         ):
             assert np.all(mask.compute() == truth.compute())
 
-        cutflow.to_npz("cutflow.npz", compressed=False).compute()
-        with np.load("cutflow.npz") as file:
-            assert np.all(file["labels"] == labels)
-            assert np.all(file["nevonecut"] == list(dask.compute(*nevonecut)))
-            assert np.all(file["nevcutflow"] == list(dask.compute(*nevcutflow)))
-            assert np.all(file["masksonecut"] == list(dask.compute(*masksonecut)))
-            assert np.all(file["maskscutflow"] == list(dask.compute(*maskscutflow)))
-        os.remove("cutflow.npz")
-
-        cutflow.to_npz("cutflow.npz", compressed=True).compute()
-        with np.load("cutflow.npz") as file:
-            assert np.all(file["labels"] == labels)
-            assert np.all(file["nevonecut"] == list(dask.compute(*nevonecut)))
-            assert np.all(file["nevcutflow"] == list(dask.compute(*nevcutflow)))
-            assert np.all(file["masksonecut"] == list(dask.compute(*masksonecut)))
-            assert np.all(file["maskscutflow"] == list(dask.compute(*maskscutflow)))
-        os.remove("cutflow.npz")
+        with tempfile.TemporaryDirectory() as tmp:
+            cutflow_uncompressed = os.path.join(tmp, "cutflow_uncompressed.npz")
+            cutflow.to_npz(cutflow_uncompressed, compressed=False).compute()
+            with np.load(cutflow_uncompressed) as file:
+                assert np.all(file["labels"] == labels)
+                assert np.all(file["nevonecut"] == list(dask.compute(*nevonecut)))
+                assert np.all(file["nevcutflow"] == list(dask.compute(*nevcutflow)))
+                assert np.all(file["masksonecut"] == list(dask.compute(*masksonecut)))
+                assert np.all(file["maskscutflow"] == list(dask.compute(*maskscutflow)))
+
+            cutflow_compressed = os.path.join(tmp, "cutflow_compressed.npz")
+            cutflow.to_npz(cutflow_compressed, compressed=True).compute()
+            with np.load(cutflow_compressed) as file:
+                assert np.all(file["labels"] == labels)
+                assert np.all(file["nevonecut"] == list(dask.compute(*nevonecut)))
+                assert np.all(file["nevcutflow"] == list(dask.compute(*nevcutflow)))
+                assert np.all(file["masksonecut"] == list(dask.compute(*masksonecut)))
+                assert np.all(file["maskscutflow"] == list(dask.compute(*maskscutflow)))
 
         honecut, hcutflow, hlabels = dask.compute(*cutflow.yieldhist())
 
@@ -1096,6 +1408,447 @@ def test_packed_selection_cutflow_dak(optimization_enabled):
                 assert np.all(np.isclose(counts[1:-1], c))
 
 
+@pytest.mark.parametrize("optimization_enabled", [True, False])
+@pytest.mark.parametrize("weighted", [True, False])
+@pytest.mark.parametrize("commonmasked", [True, False])
+@pytest.mark.parametrize("withcategorical", [True, False])
+def test_packed_selection_cutflow_extended_dak(
+    optimization_enabled, weighted, commonmasked, withcategorical
+):
+
+    import awkward as ak
+    import dask
+    import dask_awkward as dak
+
+    from coffea.analysis_tools import PackedSelection, Weights
+
+    events = dakevents
+
+    selection = PackedSelection()
+
+    with dask.config.set({"awkward.optimization.enabled": optimization_enabled}):
+        twoelectron = dak.num(events.Electron) == 2
+        nomuon = dak.num(events.Muon) == 0
+        leadpt20 = dak.any(events.Electron.pt >= 20.0, axis=1) | dak.any(
+            events.Muon.pt >= 20.0, axis=1
+        )
+        selection.add_multiple(
+            {
+                "twoElectron": twoelectron,
+                "noMuon": nomuon,
+                "leadPt20": leadpt20,
+            }
+        )
+
+        assert selection.names == ["twoElectron", "noMuon", "leadPt20"]
+
+        commonmask = (dak.num(events.Electron) >= 1) & (dak.num(events.Muon) <= 1)
+
+        categorical = {
+            "axis": hist.axis.IntCategory(
+                [0, 41, 43], name="genTtbarId", growth=False, flow=False
+            ),
+            "values": events.genTtbarId,
+            "labels": ["0", "41", "43"],
+        }
+
+        weight = Weights(None)
+        weight.add(
+            "test",
+            dak.ones_like(events.genWeight),
+            weightUp=1.25 * dak.ones_like(events.genWeight),
+            weightDown=0.5 * dak.ones_like(events.genWeight),
+        )
+
+        with pytest.raises(
+            ValueError,
+            match="All arguments must be strings that refer to the names of existing selections",
+        ):
+            selection.cutflow("twoElectron", "nonexistent")
+        cutflow = selection.cutflow(
+            "noMuon",
+            "twoElectron",
+            "leadPt20",
+            commonmask=commonmask if commonmasked else None,
+            weights=weight if weighted else None,
+            weightsmodifier="testUp" if weighted else None,
+        )
+
+        labels, nevonecut, nevcutflow, masksonecut, maskscutflow, *packed = (
+            cutflow.result()
+        )
+
+        if commonmasked or weighted:
+            (
+                r_commonmask,
+                r_wgtevonecut,
+                r_wgtevcutflow,
+                r_weights,
+                r_weightsmodifier,
+            ) = packed
+        else:
+            (
+                r_commonmask,
+                r_wgtevonecut,
+                r_wgtevcutflow,
+                r_weights,
+                r_weightsmodifier,
+            ) = (None, None, None, None, None)
+
+        onecut_truths = [nomuon, twoelectron, leadpt20]
+        cutflow_truths = [nomuon, nomuon & twoelectron, nomuon & twoelectron & leadpt20]
+        honecuts_truths = [np.ones(40, dtype=bool), nomuon, twoelectron, leadpt20]
+        hcutflows_truths = [
+            np.ones(40, dtype=bool),
+            nomuon,
+            nomuon & twoelectron,
+            nomuon & twoelectron & leadpt20,
+        ]
+        if commonmasked:
+            onecut_truths = [truth & commonmask for truth in onecut_truths]
+            cutflow_truths = [truth & commonmask for truth in cutflow_truths]
+            honecuts_truths = [truth & commonmask for truth in honecuts_truths]
+            hcutflows_truths = [truth & commonmask for truth in hcutflows_truths]
+
+        honecut, hcutflow, hlabels, *catlabel = cutflow.yieldhist(
+            weighted=weighted,
+            categorical=categorical if withcategorical else None,
+        )
+
+        honecuts_fill_arrays = {"ept": [], "ephi": []}
+        honecuts_fill_weights = {"ept": [], "ephi": []}
+        hcutflows_fill_arrays = {"ept": [], "ephi": []}
+        hcutflows_fill_weights = {"ept": [], "ephi": []}
+        array_dict = {"ept": events.Electron.pt, "ephi": events.Electron.phi}
+        honecuts, hcutflows, hslabels, *catlabels = cutflow.plot_vars(
+            array_dict,
+            weighted=weighted,
+            categorical=categorical if withcategorical else None,
+        )
+
+        for varname, array in array_dict.items():
+            for i, truth in enumerate(honecuts_truths):
+                fill_array, fill_weights = dak.broadcast_arrays(
+                    array[truth], weight.weight(r_weightsmodifier)[truth]
+                )
+                honecuts_fill_arrays[varname].append(dak.flatten(fill_array))
+                honecuts_fill_weights[varname].append(dak.flatten(fill_weights))
+
+        for varname, array in array_dict.items():
+            for i, truth in enumerate(hcutflows_truths):
+                fill_array, fill_weights = dak.broadcast_arrays(
+                    array[truth], weight.weight(r_weightsmodifier)[truth]
+                )
+                hcutflows_fill_arrays[varname].append(dak.flatten(fill_array))
+                hcutflows_fill_weights[varname].append(dak.flatten(fill_weights))
+
+        # Ensure key alignment
+        assert array_dict.keys() == honecuts_fill_arrays.keys()
+        assert array_dict.keys() == hcutflows_fill_arrays.keys()
+        assert array_dict.keys() == honecuts_fill_weights.keys()
+        assert array_dict.keys() == hcutflows_fill_weights.keys()
+
+        # Compute all values for comparisons and assertions
+        to_compute = {
+            "nevonecut": nevonecut,
+            "nevcutflow": nevcutflow,
+            "masksonecut": masksonecut,
+            "maskscutflow": maskscutflow,
+            "r_commonmask": r_commonmask,
+            "r_wgtevonecut": r_wgtevonecut,
+            "r_wgtevcutflow": r_wgtevcutflow,
+            "r_weights_wmodifier": (
+                r_weights.weight(r_weightsmodifier) if weighted else None
+            ),
+            "r_weightsmodifier": r_weightsmodifier,
+            "nevonecut_comparison": [
+                (
+                    dak.num(events, axis=0)
+                    if not commonmasked
+                    else dak.num(events[commonmask], axis=0)
+                ),
+                (
+                    dak.num(events[nomuon], axis=0)
+                    if not commonmasked
+                    else dak.num(events[nomuon & commonmask], axis=0)
+                ),
+                (
+                    dak.num(events[twoelectron], axis=0)
+                    if not commonmasked
+                    else dak.num(events[twoelectron & commonmask], axis=0)
+                ),
+                (
+                    dak.num(events[leadpt20], axis=0)
+                    if not commonmasked
+                    else dak.num(events[leadpt20 & commonmask], axis=0)
+                ),
+            ],
+            "nevcutflow_comparison": [
+                (
+                    dak.num(events, axis=0)
+                    if not commonmasked
+                    else dak.num(events[commonmask], axis=0)
+                ),
+                (
+                    dak.num(events[nomuon], axis=0)
+                    if not commonmasked
+                    else dak.num(events[nomuon & commonmask], axis=0)
+                ),
+                (
+                    dak.num(events[nomuon & twoelectron], axis=0)
+                    if not commonmasked
+                    else dak.num(events[nomuon & twoelectron & commonmask], axis=0)
+                ),
+                (
+                    dak.num(events[nomuon & twoelectron & leadpt20], axis=0)
+                    if not commonmasked
+                    else dak.num(
+                        events[nomuon & twoelectron & leadpt20 & commonmask], axis=0
+                    )
+                ),
+            ],
+            "onecut_truths": onecut_truths,
+            "cutflow_truths": cutflow_truths,
+            "honecut": honecut,
+            "hcutflow": hcutflow,
+            "hlabels": hlabels,
+            "catlabel": catlabel,
+            "honecuts": honecuts,
+            "hcutflows": hcutflows,
+            "hslabels": hslabels,
+            "catlabels": catlabels,
+            "honecuts_fill_arrays": honecuts_fill_arrays,
+            "honecuts_fill_weights": honecuts_fill_weights,
+            "hcutflows_fill_arrays": hcutflows_fill_arrays,
+            "hcutflows_fill_weights": hcutflows_fill_weights,
+        }
+
+        computed = dask.compute(to_compute)[0]
+        computed_nevonecut = computed["nevonecut"]
+        computed_nevcutflow = computed["nevcutflow"]
+        computed_masksonecut = computed["masksonecut"]
+        computed_maskscutflow = computed["maskscutflow"]
+        computed_r_commonmask = computed["r_commonmask"]
+        computed_r_wgtevonecut = computed["r_wgtevonecut"]
+        computed_r_wgtevcutflow = computed["r_wgtevcutflow"]
+        computed_r_weights_wmodifier = computed["r_weights_wmodifier"]
+        computed_nevonecut_comparison = computed["nevonecut_comparison"]
+        computed_nevcutflow_comparison = computed["nevcutflow_comparison"]
+        computed_onecut_truths = computed["onecut_truths"]
+        computed_cutflow_truths = computed["cutflow_truths"]
+        computed_honecut = computed["honecut"]
+        computed_hcutflow = computed["hcutflow"]
+        computed_hlabels = computed["hlabels"]
+        computed_catlabel = computed["catlabel"]
+        computed_honecuts = computed["honecuts"]
+        computed_hcutflows = computed["hcutflows"]
+        computed_hslabels = computed["hslabels"]
+        computed_catlabels = computed["catlabels"]
+        computed_honecuts_fill_arrays = computed["honecuts_fill_arrays"]
+        computed_honecuts_fill_weights = computed["honecuts_fill_weights"]
+        computed_hcutflows_fill_arrays = computed["hcutflows_fill_arrays"]
+        computed_hcutflows_fill_weights = computed["hcutflows_fill_weights"]
+
+        assert labels == ["initial", "noMuon", "twoElectron", "leadPt20"]
+        assert computed_nevonecut == computed_nevonecut_comparison
+        assert computed_nevcutflow == computed_nevcutflow_comparison
+
+        if weighted:
+            if commonmasked:
+                assert np.isclose(
+                    computed_r_wgtevonecut[0],
+                    ak.sum(computed_r_weights_wmodifier[computed_r_commonmask]),
+                )
+            else:
+                assert np.isclose(
+                    computed_r_wgtevcutflow[0],
+                    ak.sum(computed_r_weights_wmodifier),
+                )
+        for i, (mask, truth) in enumerate(
+            zip(computed_masksonecut, computed_onecut_truths), 1
+        ):
+            assert ak.all(mask == truth)
+            if weighted:
+                assert np.isclose(
+                    computed_r_wgtevonecut[i],
+                    ak.sum(computed_r_weights_wmodifier[truth]),
+                )
+
+        for i, (mask, truth) in enumerate(
+            zip(computed_maskscutflow, computed_cutflow_truths), 1
+        ):
+            assert ak.all(mask == truth)
+            if weighted:
+                assert np.isclose(
+                    computed_r_wgtevcutflow[i],
+                    ak.sum(computed_r_weights_wmodifier[truth]),
+                )
+        # npz comparisons
+        with tempfile.TemporaryDirectory() as tmp:
+            cutflow_uncompressed = os.path.join(tmp, "cutflow_uncompresssed.npz")
+            cutflow_compressed = os.path.join(tmp, "cutflow_compresssed.npz")
+            cutflow_compressed_weighted = os.path.join(
+                tmp, "cutflow_compresssed_weighted.npz"
+            )
+            cutflow.to_npz(
+                cutflow_uncompressed, compressed=False, includeweights=False
+            ).compute()
+            cutflow.to_npz(cutflow_compressed, compressed=True).compute()
+            cutflow.to_npz(
+                cutflow_compressed_weighted, compressed=True, includeweights=True
+            ).compute()
+            with np.load(cutflow_uncompressed) as file:
+                assert np.all(file["labels"] == labels)
+                assert np.all(file["nevonecut"] == list(computed_nevonecut))
+                assert np.all(file["nevcutflow"] == list(computed_nevcutflow))
+                assert np.all(file["masksonecut"] == list(computed_masksonecut))
+                assert np.all(file["maskscutflow"] == list(computed_maskscutflow))
+                if commonmasked:
+                    assert np.all(file["commonmask"] == computed_r_commonmask)
+                else:
+                    assert "commonmask" not in file
+                if weighted:
+                    assert np.all(file["wgtevonecut"] == list(computed_r_wgtevonecut))
+                    assert np.all(file["wgtevcutflow"] == list(computed_r_wgtevcutflow))
+                else:
+                    assert "wgtevonecut" not in file
+                    assert "wgtevcutflow" not in file
+                assert "weights" not in file
+
+            with np.load(cutflow_compressed) as file:
+                assert np.all(file["labels"] == labels)
+                assert np.all(file["nevonecut"] == list(computed_nevonecut))
+                assert np.all(file["nevcutflow"] == list(computed_nevcutflow))
+                assert np.all(file["masksonecut"] == list(computed_masksonecut))
+                assert np.all(file["maskscutflow"] == list(computed_maskscutflow))
+                if commonmasked:
+                    assert np.all(file["commonmask"] == computed_r_commonmask)
+                else:
+                    assert "commonmask" not in file
+                if weighted:
+                    assert np.all(file["wgtevonecut"] == list(computed_r_wgtevonecut))
+                    assert np.all(file["wgtevcutflow"] == list(computed_r_wgtevcutflow))
+                    assert np.all(file["weights"] == computed_r_weights_wmodifier)
+                else:
+                    assert "wgtevonecut" not in file
+                    assert "wgtevcutflow" not in file
+                    assert "weights" not in file
+
+            with np.load(cutflow_compressed_weighted) as file:
+                assert np.all(file["labels"] == labels)
+                assert np.all(file["nevonecut"] == list(computed_nevonecut))
+                assert np.all(file["nevcutflow"] == list(computed_nevcutflow))
+                assert np.all(file["masksonecut"] == list(computed_masksonecut))
+                assert np.all(file["maskscutflow"] == list(computed_maskscutflow))
+                if commonmasked:
+                    assert np.all(file["commonmask"] == computed_r_commonmask)
+                else:
+                    assert "commonmask" not in file
+                if weighted:
+                    assert np.all(file["wgtevonecut"] == list(computed_r_wgtevonecut))
+                    assert np.all(file["wgtevcutflow"] == list(computed_r_wgtevcutflow))
+                    assert np.all(file["weights"] == computed_r_weights_wmodifier)
+                else:
+                    assert "wgtevonecut" not in file
+                    assert "wgtevcutflow" not in file
+                    assert "weights" not in file
+
+        # yieldhist comparisons
+        assert computed_hlabels == ["initial", "noMuon", "twoElectron", "leadPt20"]
+        if withcategorical:
+            assert computed_catlabel[0] == ["0", "41", "43"]
+        assert np.all(computed_honecut.axes["onecut"].edges == np.arange(0, 5))
+        assert np.all(computed_hcutflow.axes["cutflow"].edges == np.arange(0, 5))
+        if withcategorical:
+            assert np.all(
+                computed_honecut.axes["genTtbarId"].edges == np.array([0, 1, 2, 3])
+            )
+            assert np.all(
+                computed_hcutflow.axes["genTtbarId"].edges == np.array([0, 1, 2, 3])
+            )
+
+        firstcatentry = 36 if not commonmasked else 15
+        if weighted:
+            assert np.all(
+                computed_honecut.project("onecut").counts() == computed_r_wgtevonecut
+            )
+            assert np.all(
+                computed_hcutflow.project("cutflow").counts() == computed_r_wgtevcutflow
+            )
+            if withcategorical:
+                assert np.all(
+                    np.isclose(
+                        computed_honecut[0, :].project("genTtbarId").counts(),
+                        1.25 * np.array([firstcatentry, 3, 1]),
+                    )
+                )
+                assert np.all(
+                    np.isclose(
+                        computed_hcutflow[0, :].project("genTtbarId").counts(),
+                        1.25 * np.array([firstcatentry, 3, 1]),
+                    )
+                )
+        else:
+            assert np.all(
+                computed_honecut.project("onecut").counts() == computed_nevonecut
+            )
+            assert np.all(
+                computed_hcutflow.project("cutflow").counts() == computed_nevcutflow
+            )
+            if withcategorical:
+                assert np.all(
+                    np.isclose(
+                        computed_honecut[0, :].project("genTtbarId").counts(),
+                        np.array([firstcatentry, 3, 1]),
+                    )
+                )
+                assert np.all(
+                    np.isclose(
+                        computed_hcutflow[0, :].project("genTtbarId").counts(),
+                        np.array([firstcatentry, 3, 1]),
+                    )
+                )
+
+        # plot_vars comparisons
+        assert computed_hslabels == ["initial", "noMuon", "twoElectron", "leadPt20"]
+        if withcategorical:
+            assert computed_catlabels[0] == ["0", "41", "43"]
+
+        for h, computed_fill_arrays, computed_fill_weights in zip(
+            computed_honecuts,
+            computed_honecuts_fill_arrays.values(),
+            computed_honecuts_fill_weights.values(),
+        ):
+            edges = h.axes[0].edges
+            for i, truth in enumerate(honecuts_truths):
+                counts = h.project(h.axes.name[0], "onecut")[:, i].counts(flow=True)
+                counts[1] += counts[0]
+                counts[-2] += counts[-1]
+                c, e = np.histogram(
+                    computed_fill_arrays[i],
+                    bins=edges,
+                    weights=computed_fill_weights[i] if weighted else None,
+                )
+                assert np.all(np.isclose(counts[1:-1], c))
+
+        for h, computed_fill_arrays, computed_fill_weights in zip(
+            computed_hcutflows,
+            computed_hcutflows_fill_arrays.values(),
+            computed_hcutflows_fill_weights.values(),
+        ):
+            edges = h.axes[0].edges
+            for i, truth in enumerate(hcutflows_truths):
+                counts = h.project(h.axes.name[0], "cutflow")[:, i].counts(flow=True)
+                counts[1] += counts[0]
+                counts[-2] += counts[-1]
+                c, e = np.histogram(
+                    computed_fill_arrays[i],
+                    bins=edges,
+                    weights=computed_fill_weights[i] if weighted else None,
+                )
+                assert np.all(np.isclose(counts[1:-1], c))
+
+
 @pytest.mark.parametrize("optimization_enabled", [True, False])
 def test_packed_selection_nminusone_dak_uproot_only(optimization_enabled):
     import dask
@@ -1160,19 +1913,20 @@ def test_packed_selection_nminusone_dak_uproot_only(optimization_enabled):
         ):
             assert np.all(mask.compute() == truth.compute())
 
-        nminusone.to_npz("nminusone.npz", compressed=False).compute()
-        with np.load("nminusone.npz") as file:
-            assert np.all(file["labels"] == labels)
-            assert np.all(file["nev"] == list(dask.compute(*nev)))
-            assert np.all(file["masks"] == list(dask.compute(*masks)))
-        os.remove("nminusone.npz")
-
-        nminusone.to_npz("nminusone.npz", compressed=True).compute()
-        with np.load("nminusone.npz") as file:
-            assert np.all(file["labels"] == labels)
-            assert np.all(file["nev"] == list(dask.compute(*nev)))
-            assert np.all(file["masks"] == list(dask.compute(*masks)))
-        os.remove("nminusone.npz")
+        with tempfile.TemporaryDirectory() as tmp:
+            nminusone_uncompressed = os.path.join(tmp, "nminusone_uncompresssed.npz")
+            nminusone.to_npz(nminusone_uncompressed, compressed=False).compute()
+            with np.load(nminusone_uncompressed) as file:
+                assert np.all(file["labels"] == labels)
+                assert np.all(file["nev"] == list(dask.compute(*nev)))
+                assert np.all(file["masks"] == list(dask.compute(*masks)))
+
+            nminusone_compressed = os.path.join(tmp, "nminusone_compresssed.npz")
+            nminusone.to_npz(nminusone_compressed, compressed=True).compute()
+            with np.load(nminusone_compressed) as file:
+                assert np.all(file["labels"] == labels)
+                assert np.all(file["nev"] == list(dask.compute(*nev)))
+                assert np.all(file["masks"] == list(dask.compute(*masks)))
 
         h, hlabels = dask.compute(*nminusone.yieldhist())
 
@@ -1286,23 +2040,24 @@ def test_packed_selection_cutflow_dak_uproot_only(optimization_enabled):
         ):
             assert np.all(mask.compute() == truth.compute())
 
-        cutflow.to_npz("cutflow.npz", compressed=False).compute()
-        with np.load("cutflow.npz") as file:
-            assert np.all(file["labels"] == labels)
-            assert np.all(file["nevonecut"] == list(dask.compute(*nevonecut)))
-            assert np.all(file["nevcutflow"] == list(dask.compute(*nevcutflow)))
-            assert np.all(file["masksonecut"] == list(dask.compute(*masksonecut)))
-            assert np.all(file["maskscutflow"] == list(dask.compute(*maskscutflow)))
-        os.remove("cutflow.npz")
-
-        cutflow.to_npz("cutflow.npz", compressed=True).compute()
-        with np.load("cutflow.npz") as file:
-            assert np.all(file["labels"] == labels)
-            assert np.all(file["nevonecut"] == list(dask.compute(*nevonecut)))
-            assert np.all(file["nevcutflow"] == list(dask.compute(*nevcutflow)))
-            assert np.all(file["masksonecut"] == list(dask.compute(*masksonecut)))
-            assert np.all(file["maskscutflow"] == list(dask.compute(*maskscutflow)))
-        os.remove("cutflow.npz")
+        with tempfile.TemporaryDirectory() as tmp:
+            cutflow_uncompressed = os.path.join(tmp, "cutflow_uncompresssed.npz")
+            cutflow.to_npz(cutflow_uncompressed, compressed=False).compute()
+            with np.load(cutflow_uncompressed) as file:
+                assert np.all(file["labels"] == labels)
+                assert np.all(file["nevonecut"] == list(dask.compute(*nevonecut)))
+                assert np.all(file["nevcutflow"] == list(dask.compute(*nevcutflow)))
+                assert np.all(file["masksonecut"] == list(dask.compute(*masksonecut)))
+                assert np.all(file["maskscutflow"] == list(dask.compute(*maskscutflow)))
+
+            cutflow_compressed = os.path.join(tmp, "cutflow_compresssed.npz")
+            cutflow.to_npz(cutflow_compressed, compressed=True).compute()
+            with np.load(cutflow_compressed) as file:
+                assert np.all(file["labels"] == labels)
+                assert np.all(file["nevonecut"] == list(dask.compute(*nevonecut)))
+                assert np.all(file["nevcutflow"] == list(dask.compute(*nevcutflow)))
+                assert np.all(file["masksonecut"] == list(dask.compute(*masksonecut)))
+                assert np.all(file["maskscutflow"] == list(dask.compute(*maskscutflow)))
 
         honecut, hcutflow, hlabels = dask.compute(*cutflow.yieldhist())