diff --git a/PWGCF/Femto/Core/baseSelection.h b/PWGCF/Femto/Core/baseSelection.h
index 3e58511914b..a477594bd61 100644
--- a/PWGCF/Femto/Core/baseSelection.h
+++ b/PWGCF/Femto/Core/baseSelection.h
@@ -292,7 +292,7 @@ class BaseSelection
   /// \brief Evaluate a single observable against its configured selections.
   /// \param observableIndex Index of the observable.
   /// \param values Vector of values of the observable.
-  void evaluateObservable(int observableIndex, std::vector<T> values)
+  void evaluateObservable(int observableIndex, std::vector<T> const& values)
   {
     // if there are no selections configured, bail out
     if (mSelectionContainers.at(observableIndex).isEmpty()) {
diff --git a/PWGCF/Femto/Core/collisionBuilder.h b/PWGCF/Femto/Core/collisionBuilder.h
index 344bc562316..03bda34b671 100644
--- a/PWGCF/Femto/Core/collisionBuilder.h
+++ b/PWGCF/Femto/Core/collisionBuilder.h
@@ -334,7 +334,7 @@ class CollisionSelection : public baseselection::BaseSelection<float, o2::analys
   }
 
   template <typename T>
-  void setSphericity(T tracks)
+  void setSphericity(T const& tracks)
   {
     mSphericity = computeSphericity(tracks);
   }
diff --git a/PWGCF/Femto/Core/mcBuilder.h b/PWGCF/Femto/Core/mcBuilder.h
index 6727bbb0f47..d05820904a2 100644
--- a/PWGCF/Femto/Core/mcBuilder.h
+++ b/PWGCF/Femto/Core/mcBuilder.h
@@ -556,7 +556,7 @@ class McBuilder
     int64_t mcMotherRow = -1;
     if (mProduceMcMothers && mcParticle.has_mothers()) {
       auto mothers = mcParticle.template mothers_as<T2>();
-      auto motherParticle = mothers.front();
+      auto const& motherParticle = mothers.front();
       auto mcMotherIndex = motherParticle.globalIndex();
 
       auto itM = mMcMotherMap.find(mcMotherIndex);
diff --git a/PWGCF/Femto/Core/trackBuilder.h b/PWGCF/Femto/Core/trackBuilder.h
index c98ec68c8e4..9acba874559 100644
--- a/PWGCF/Femto/Core/trackBuilder.h
+++ b/PWGCF/Femto/Core/trackBuilder.h
@@ -27,8 +27,12 @@
 #include <Framework/AnalysisHelpers.h>
 #include <Framework/Configurable.h>
 #include <Framework/HistogramRegistry.h>
+#include <Framework/HistogramSpec.h>
 #include <Framework/Logger.h>
 
+#include <TH1.h>
+
+#include <array>
 #include <cmath>
 #include <cstdint>
 #include <string>
@@ -684,10 +688,17 @@ class TrackBuilder
       auto hSlotAssignment = registry->get<TH1>(HIST("hPuritySlotAssignment"));
       for (int i = 0; i < PuritySpeciesLast; i++) {
         std::string bitPosition = mPuritySlot[i] >= 0 ? std::to_string(mPuritySlot[i]) : "X";
-        std::string value = mPuritySlot[i] >= 0 ? ("Slot " + std::to_string(mPuritySlot[i])) : "Not configured";
-        std::string label = std::string("SelectionName___") + PuritySpeciesName[i] +
-                            ":::MinimalCut___0:::OptionalCut___0:::BitPosition___" + bitPosition +
-                            ":::Value___" + value;
+        std::string value = "Not configured";
+        if (mPuritySlot[i] >= 0) {
+          value = "Slot ";
+          value += std::to_string(mPuritySlot[i]);
+        }
+        std::string label = "SelectionName___";
+        label += PuritySpeciesName[i];
+        label += ":::MinimalCut___0:::OptionalCut___0:::BitPosition___";
+        label += bitPosition;
+        label += ":::Value___";
+        label += value;
         hSlotAssignment->GetXaxis()->SetBinLabel(i + 1, label.c_str());
         hSlotAssignment->Fill(i, 1);
       }
diff --git a/PWGCF/Femto/Core/trackHistManager.h b/PWGCF/Femto/Core/trackHistManager.h
index b02fc512f4e..296f11ab1aa 100644
--- a/PWGCF/Femto/Core/trackHistManager.h
+++ b/PWGCF/Femto/Core/trackHistManager.h
@@ -29,6 +29,7 @@
 #include <TH1.h>
 
 #include <array>
+#include <cmath>
 #include <cstddef>
 #include <map>
 #include <string>
diff --git a/PWGCF/Femto/TableProducer/femtoProducer.cxx b/PWGCF/Femto/TableProducer/femtoProducer.cxx
index 5b0f7beba3d..41922a24837 100644
--- a/PWGCF/Femto/TableProducer/femtoProducer.cxx
+++ b/PWGCF/Femto/TableProducer/femtoProducer.cxx
@@ -100,14 +100,38 @@ using Run3McGenParticles = o2::aod::McParticles;
 
 struct FemtoProducer {
 
-  o2::framework::Preslice<rawinputs::Run3McGenParticles> perMcCollision = o2::aod::mcparticle::mcCollisionId;
-  o2::framework::Preslice<rawinputs::Run3McRecoTracks> perColRecoTracks = o2::aod::track::collisionId;
-  o2::framework::Preslice<rawinputs::Run3RecoVzeros> perColRecoV0s = o2::aod::v0data::collisionId;
-  o2::framework::Preslice<o2::aod::V0PhotonsKF> perColRecoPCMPhotons = o2::aod::v0photonkf::collisionId;
-  o2::framework::Preslice<rawinputs::Run3RecoCascades> perColRecoCascades = o2::aod::cascdata::collisionId;
-  o2::framework::Preslice<rawinputs::Run3Kinks> perColRecoKinks = o2::aod::kinkcand::collisionId;
-  o2::framework::Preslice<rawinputs::Run3RecoD0s> perColRecoD0s = o2::aod::hf_cand::collisionId;
-  o2::framework::Preslice<rawinputs::Run3RecoLcs> perColRecoLcs = o2::aod::hf_cand::collisionId;
+  // all Preslice declarations, grouped into a single data member (see o2::framework::PresliceGroup's
+  // own doc comment) to stay well under the 100-direct-data-member cap on task structs
+  struct : public o2::framework::PresliceGroup {
+    o2::framework::Preslice<rawinputs::Run3McGenParticles> perMcCollision = o2::aod::mcparticle::mcCollisionId;
+    o2::framework::Preslice<rawinputs::Run3McRecoTracks> perColRecoTracks = o2::aod::track::collisionId;
+    o2::framework::Preslice<rawinputs::Run3RecoVzeros> perColRecoV0s = o2::aod::v0data::collisionId;
+    o2::framework::Preslice<o2::aod::V0PhotonsKF> perColRecoPCMPhotons = o2::aod::v0photonkf::collisionId;
+    o2::framework::Preslice<rawinputs::Run3RecoCascades> perColRecoCascades = o2::aod::cascdata::collisionId;
+    o2::framework::Preslice<rawinputs::Run3Kinks> perColRecoKinks = o2::aod::kinkcand::collisionId;
+    o2::framework::Preslice<rawinputs::Run3RecoD0s> perColRecoD0s = o2::aod::hf_cand::collisionId;
+    o2::framework::Preslice<rawinputs::Run3RecoLcs> perColRecoLcs = o2::aod::hf_cand::collisionId;
+  } preslices;
+
+  // plain builder helper objects, grouped into a single data member (not Configurable/Partition/
+  // Preslice/Produces, so the framework never needs to discover them individually -- free to nest)
+  struct {
+    collisionbuilder::CollisionBuilder<collisionbuilder::ColSelHistName, collisionbuilder::CollisionFilterHistName> collisionBuilder;
+    trackbuilder::TrackBuilder<trackbuilder::TrackSelHistName, trackbuilder::TrackFilterHistName> trackBuilder;
+    v0builder::V0Builder<modes::V0::kK0short, v0builder::K0shortSelHistName, v0builder::K0shortFilterHistName> k0shortBuilder;
+    v0builder::V0Builder<modes::V0::kLambda, v0builder::LambdaSelHistName, v0builder::LambdaFilterHistName> lambdaBuilder;
+    v0builder::V0Builder<modes::V0::kAntiLambda, v0builder::AntilambdaSelHistName, v0builder::AntiLambdaFilterHistName> antilambdaBuilder;
+    photonbuilder::PhotonBuilder photonBuilder;
+    charmhadronbuilder::CharmHadronBuilder<modes::CharmHadron::kD0, charmhadronbuilder::D0SelHistName, charmhadronbuilder::D0FilterHistName> d0Builder;
+    charmhadronbuilder::CharmHadronBuilder<modes::CharmHadron::kD0Bar, charmhadronbuilder::D0barSelHistName, charmhadronbuilder::D0barFilterHistName> d0barBuilder;
+    charmhadronbuilder::CharmHadronBuilder<modes::CharmHadron::kLc, charmhadronbuilder::LcSelHistName, charmhadronbuilder::LcFilterHistName> lcBuilder;
+    charmhadronbuilder::CharmHadronBuilder<modes::CharmHadron::kLcBar, charmhadronbuilder::LcBarSelHistName, charmhadronbuilder::LcBarFilterHistName> lcBarBuilder;
+    cascadebuilder::CascadeBuilder<modes::Cascade::kXi, cascadebuilder::XiSelHistName, cascadebuilder::XiFilterHistName> xiBuilder;
+    cascadebuilder::CascadeBuilder<modes::Cascade::kOmega, cascadebuilder::OmegaSelHistName, cascadebuilder::OmegaFilterHistName> omegaBuilder;
+    kinkbuilder::KinkBuilder<modes::Kink::kSigma, kinkbuilder::SigmaSelHistName, kinkbuilder::SigmaFilterHistName> sigmaBuilder;
+    kinkbuilder::KinkBuilder<modes::Kink::kSigmaPlus, kinkbuilder::SigmaPlusSelHistName, kinkbuilder::SigmaPlusFilterHistName> sigmaPlusBuilder;
+    mcbuilder::McBuilder mcBuilder;
+  } builders;
 
   // ccdb config
   collisionbuilder::ConfCcdb confCcdb;
@@ -118,12 +142,10 @@ struct FemtoProducer {
   collisionbuilder::ConfCollisionFilters confCollisionFilters;
   collisionbuilder::ConfCollisionBits confCollisionBits;
   collisionbuilder::ConfCollisionRctFlags confCollisionRctFlags;
-  collisionbuilder::CollisionBuilder<collisionbuilder::ColSelHistName, collisionbuilder::CollisionFilterHistName> collisionBuilder;
 
   // track builder
   trackbuilder::TrackBuilderProducts trackBuilderProducts;
   trackbuilder::ConfTrackTables confTrackTables;
-  trackbuilder::TrackBuilder<trackbuilder::TrackSelHistName, trackbuilder::TrackFilterHistName> trackBuilder;
   trackbuilder::ConfTrackBits confTrackBits;
   trackbuilder::ConfTrackFilters confTrackFilters;
 
@@ -132,17 +154,13 @@ struct FemtoProducer {
   v0builder::ConfV0Tables confV0Tables;
   v0builder::ConfV0Filters confV0Filters;
   v0builder::ConfK0shortBits confK0shortBits;
-  v0builder::V0Builder<modes::V0::kK0short, v0builder::K0shortSelHistName, v0builder::K0shortFilterHistName> k0shortBuilder;
   v0builder::ConfLambdaBits confLambdaBits;
-  v0builder::V0Builder<modes::V0::kLambda, v0builder::LambdaSelHistName, v0builder::LambdaFilterHistName> lambdaBuilder;
-  v0builder::V0Builder<modes::V0::kAntiLambda, v0builder::AntilambdaSelHistName, v0builder::AntiLambdaFilterHistName> antilambdaBuilder;
 
   // photon (PCM) builder
   photonbuilder::PhotonBuilderProducts photonBuilderProducts;
   photonbuilder::ConfPhotonTables confPhotonTables;
   photonbuilder::ConfPhotonFilters confPhotonFilters;
   photonbuilder::ConfPhotonBits confPhotonBits;
-  photonbuilder::PhotonBuilder photonBuilder;
 
   // charm hadron builder
   charmhadronbuilder::CharmHadronBuilderProducts charmHadronBuilderProducts;
@@ -150,34 +168,25 @@ struct FemtoProducer {
   charmhadronbuilder::ConfCharmHadronTables confCharmHadronTables;
   charmhadronbuilder::ConfD0Bits confD0Bits;
   charmhadronbuilder::ConfLcBits confLcBits;
-  charmhadronbuilder::CharmHadronBuilder<modes::CharmHadron::kD0, charmhadronbuilder::D0SelHistName, charmhadronbuilder::D0FilterHistName> d0Builder;
-  charmhadronbuilder::CharmHadronBuilder<modes::CharmHadron::kD0Bar, charmhadronbuilder::D0barSelHistName, charmhadronbuilder::D0barFilterHistName> d0barBuilder;
-  charmhadronbuilder::CharmHadronBuilder<modes::CharmHadron::kLc, charmhadronbuilder::LcSelHistName, charmhadronbuilder::LcFilterHistName> lcBuilder;
-  charmhadronbuilder::CharmHadronBuilder<modes::CharmHadron::kLcBar, charmhadronbuilder::LcBarSelHistName, charmhadronbuilder::LcBarFilterHistName> lcBarBuilder;
 
   // cascade builder
   cascadebuilder::CascadeBuilderProducts cascadeBuilderProducts;
   cascadebuilder::ConfCascadeTables confCascadeTables;
   cascadebuilder::ConfCascadeFilters confCascadeFilters;
   cascadebuilder::ConfXiBits confXiBits;
-  cascadebuilder::CascadeBuilder<modes::Cascade::kXi, cascadebuilder::XiSelHistName, cascadebuilder::XiFilterHistName> xiBuilder;
   cascadebuilder::ConfOmegaBits confOmegaBits;
-  cascadebuilder::CascadeBuilder<modes::Cascade::kOmega, cascadebuilder::OmegaSelHistName, cascadebuilder::OmegaFilterHistName> omegaBuilder;
 
   // kink builder
   kinkbuilder::KinkBuilderProducts kinkBuilderProducts;
   kinkbuilder::ConfKinkTables confKinkTables;
   kinkbuilder::ConfKinkFilters confKinkFilters;
   kinkbuilder::ConfSigmaBits confSigmaBits;
-  kinkbuilder::KinkBuilder<modes::Kink::kSigma, kinkbuilder::SigmaSelHistName, kinkbuilder::SigmaFilterHistName> sigmaBuilder;
   kinkbuilder::ConfSigmaPlusBits confSigmaPlusBits;
-  kinkbuilder::KinkBuilder<modes::Kink::kSigmaPlus, kinkbuilder::SigmaPlusSelHistName, kinkbuilder::SigmaPlusFilterHistName> sigmaPlusBuilder;
 
   // mc builder
   mcbuilder::ConfMc confMc;
   mcbuilder::ConfMcTables confMcTables;
   mcbuilder::McBuilderProducts mcProducts;
-  mcbuilder::McBuilder mcBuilder;
 
   // histogramming
   o2::framework::HistogramRegistry hRegistry{"FemtoProducer", {}, o2::framework::OutputObjHandlingPolicy::AnalysisObject};
@@ -198,34 +207,34 @@ struct FemtoProducer {
 
     // ---- builders -----------------------------------------------------------
     // Order matters here: CollisionBuilder must init before TrackBuilder (which checks
-    // collisionBuilder.producingCollisions()/producingLiteCollisions()), and TrackBuilder
+    // builders.collisionBuilder.producingCollisions()/producingLiteCollisions()), and TrackBuilder
     // must init before the V0/Cascade/Kink builders (which check
-    // trackBuilder.producingTracks()/producingLiteTracks()).
-    collisionBuilder.init(&hRegistry, confCollisionFilters, confCollisionBits, confCollisionRctFlags, confCcdb, confCollisionTables, context);
-    trackBuilder.init(&hRegistry, confTrackBits, confTrackFilters, confTrackTables, context, collisionBuilder);
+    // builders.trackBuilder.producingTracks()/producingLiteTracks()).
+    builders.collisionBuilder.init(&hRegistry, confCollisionFilters, confCollisionBits, confCollisionRctFlags, confCcdb, confCollisionTables, context);
+    builders.trackBuilder.init(&hRegistry, confTrackBits, confTrackFilters, confTrackTables, context, builders.collisionBuilder);
 
-    k0shortBuilder.init(&hRegistry, confK0shortBits, confV0Filters, confV0Tables, context, trackBuilder);
-    lambdaBuilder.init(&hRegistry, confLambdaBits, confV0Filters, confV0Tables, context, trackBuilder);
-    antilambdaBuilder.init(&hRegistry, confLambdaBits, confV0Filters, confV0Tables, context, trackBuilder);
+    builders.k0shortBuilder.init(&hRegistry, confK0shortBits, confV0Filters, confV0Tables, context, builders.trackBuilder);
+    builders.lambdaBuilder.init(&hRegistry, confLambdaBits, confV0Filters, confV0Tables, context, builders.trackBuilder);
+    builders.antilambdaBuilder.init(&hRegistry, confLambdaBits, confV0Filters, confV0Tables, context, builders.trackBuilder);
 
-    photonBuilder.init(&hRegistry, confPhotonBits, confPhotonFilters, confPhotonTables, context);
+    builders.photonBuilder.init(&hRegistry, confPhotonBits, confPhotonFilters, confPhotonTables, context);
 
-    d0Builder.init(&hRegistry, confD0Bits, confCharmHadronFilters, confCharmHadronTables, context);
-    d0barBuilder.init(&hRegistry, confD0Bits, confCharmHadronFilters, confCharmHadronTables, context);
+    builders.d0Builder.init(&hRegistry, confD0Bits, confCharmHadronFilters, confCharmHadronTables, context);
+    builders.d0barBuilder.init(&hRegistry, confD0Bits, confCharmHadronFilters, confCharmHadronTables, context);
 
-    lcBuilder.init(&hRegistry, confLcBits, confCharmHadronFilters, confCharmHadronTables, context);
-    lcBarBuilder.init(&hRegistry, confLcBits, confCharmHadronFilters, confCharmHadronTables, context);
+    builders.lcBuilder.init(&hRegistry, confLcBits, confCharmHadronFilters, confCharmHadronTables, context);
+    builders.lcBarBuilder.init(&hRegistry, confLcBits, confCharmHadronFilters, confCharmHadronTables, context);
 
-    sigmaBuilder.init(&hRegistry, confSigmaBits, confKinkFilters, confKinkTables, context, trackBuilder);
-    sigmaPlusBuilder.init(&hRegistry, confSigmaPlusBits, confKinkFilters, confKinkTables, context, trackBuilder);
+    builders.sigmaBuilder.init(&hRegistry, confSigmaBits, confKinkFilters, confKinkTables, context, builders.trackBuilder);
+    builders.sigmaPlusBuilder.init(&hRegistry, confSigmaPlusBits, confKinkFilters, confKinkTables, context, builders.trackBuilder);
 
-    xiBuilder.init(&hRegistry, confXiBits, confCascadeFilters, confCascadeTables, context, trackBuilder);
-    omegaBuilder.init(&hRegistry, confOmegaBits, confCascadeFilters, confCascadeTables, context, trackBuilder);
+    builders.xiBuilder.init(&hRegistry, confXiBits, confCascadeFilters, confCascadeTables, context, builders.trackBuilder);
+    builders.omegaBuilder.init(&hRegistry, confOmegaBits, confCascadeFilters, confCascadeTables, context, builders.trackBuilder);
 
-    mcBuilder.init(confMc, confMcTables, context);
+    builders.mcBuilder.init(confMc, confMcTables, context);
 
     // ---- guard: enabled tables vs. enabled process function ------------------
-    if ((xiBuilder.fillAnyTable() || omegaBuilder.fillAnyTable()) &&
+    if ((builders.xiBuilder.fillAnyTable() || builders.omegaBuilder.fillAnyTable()) &&
         (!doprocessTracksV0sCascadesRun3pp && !doprocessTracksV0sCascadesRun3PbPb &&
          !doprocessTracksV0sCascadesRun3PbPbWithEventShape &&
          !doprocessTracksV0sCascadesPhotonsRun3PbPbWithEventShape &&
@@ -234,7 +243,7 @@ struct FemtoProducer {
          !doprocessTracksV0sCascadesRun3PbPbMc)) {
       LOG(fatal) << "At least one cascade table is enabled, but wrong process function is enabled. Breaking...";
     }
-    if ((lambdaBuilder.fillAnyTable() || antilambdaBuilder.fillAnyTable() || k0shortBuilder.fillAnyTable()) &&
+    if ((builders.lambdaBuilder.fillAnyTable() || builders.antilambdaBuilder.fillAnyTable() || builders.k0shortBuilder.fillAnyTable()) &&
         (!doprocessTracksV0sCascadesRun3pp && !doprocessTracksV0sCascadesRun3PbPb &&
          !doprocessTracksV0sRun3pp && !doprocessTracksV0sCascadesKinksRun3pp && !doprocessTracksV0sCascadesKinksPhotonsRun3pp &&
          !doprocessTracksV0sCascadesRun3PbPbWithEventShape && !doprocessTracksV0sCascadesPhotonsRun3PbPbWithEventShape &&
@@ -243,27 +252,27 @@ struct FemtoProducer {
          !doprocessTracksV0sKinksRun3ppMc)) {
       LOG(fatal) << "At least one v0 table is enabled, but wrong process function is enabled. Breaking...";
     }
-    if (photonBuilder.fillAnyTable() &&
+    if (builders.photonBuilder.fillAnyTable() &&
         (!doprocessTracksPhotonsRun3pp && !doprocessTracksPhotonsRun3PbPb &&
          !doprocessTracksV0sCascadesKinksPhotonsRun3pp && !doprocessTracksV0sCascadesPhotonsRun3PbPbWithEventShape)) {
       LOG(fatal) << "At least one photon table is enabled, but wrong process function is enabled. Breaking...";
     }
-    if ((sigmaBuilder.fillAnyTable() || sigmaPlusBuilder.fillAnyTable()) &&
+    if ((builders.sigmaBuilder.fillAnyTable() || builders.sigmaPlusBuilder.fillAnyTable()) &&
         (!doprocessTracksKinksRun3pp && !doprocessTracksV0sCascadesKinksRun3pp && !doprocessTracksV0sCascadesKinksPhotonsRun3pp &&
          !doprocessTracksKinksRun3ppMc && !doprocessTracksV0sKinksRun3ppMc)) {
       LOG(fatal) << "At least one kink table is enabled, but wrong process function is enabled. Breaking...";
     }
-    if ((d0Builder.fillAnyTable() || d0barBuilder.fillAnyTable()) &&
+    if ((builders.d0Builder.fillAnyTable() || builders.d0barBuilder.fillAnyTable()) &&
         (!doprocessTracksD0sRun3pp && !doprocessTracksD0sRun3PbPb &&
          !doprocessTracksD0sRun3ppMc && !doprocessTracksD0sRun3PbPbMc)) {
       LOG(fatal) << "At least one d0 table is enabled, but wrong process function is enabled. Breaking...";
     }
-    if ((lcBuilder.fillAnyTable() || lcBarBuilder.fillAnyTable()) &&
+    if ((builders.lcBuilder.fillAnyTable() || builders.lcBarBuilder.fillAnyTable()) &&
         (!doprocessTracksLcsRun3pp && !doprocessTracksLcsRun3PbPb &&
          !doprocessTracksLcsRun3ppMc && !doprocessTracksLcsRun3PbPbMc)) {
       LOG(fatal) << "At least one lc table is enabled, but wrong process function is enabled. Breaking...";
     }
-    if (mcBuilder.fillAnyTable() &&
+    if (builders.mcBuilder.fillAnyTable() &&
         (!doprocessTracksRun3ppMc && !doprocessTracksRun3PbPbMc &&
          !doprocessTracksV0sRun3ppMc && !doprocessTracksV0sRun3PbPbMc &&
          !doprocessTracksV0sCascadesRun3ppMc && !doprocessTracksV0sCascadesRun3PbPbMc &&
@@ -283,21 +292,21 @@ struct FemtoProducer {
         }
       };
       // substitute the real accessors if they live on the builders rather than the conf groups
-      add("collision", collisionBuilder.fillAnyTable(), collisionBuilder.isPassThrough());
-      add("track", trackBuilder.fillAnyTable(), trackBuilder.isPassThrough());
-      add("k0short", k0shortBuilder.fillAnyTable(), k0shortBuilder.isPassThrough());
-      add("lambda", lambdaBuilder.fillAnyTable(), lambdaBuilder.isPassThrough());
-      add("antilambda", antilambdaBuilder.fillAnyTable(), antilambdaBuilder.isPassThrough());
-      add("photon", photonBuilder.fillAnyTable(), photonBuilder.isPassThrough());
-      add("d0", d0Builder.fillAnyTable(), d0Builder.isPassThrough());
-      add("d0bar", d0barBuilder.fillAnyTable(), d0barBuilder.isPassThrough());
-      add("lc", lcBuilder.fillAnyTable(), lcBuilder.isPassThrough());
-      add("lcbar", lcBarBuilder.fillAnyTable(), lcBarBuilder.isPassThrough());
-      add("sigma", sigmaBuilder.fillAnyTable(), sigmaBuilder.isPassThrough());
-      add("sigmaplus", sigmaPlusBuilder.fillAnyTable(), sigmaPlusBuilder.isPassThrough());
-      add("xi", xiBuilder.fillAnyTable(), xiBuilder.isPassThrough());
-      add("omega", omegaBuilder.fillAnyTable(), omegaBuilder.isPassThrough());
-      add("mc", mcBuilder.fillAnyTable(), mcBuilder.isPassThrough());
+      add("collision", builders.collisionBuilder.fillAnyTable(), builders.collisionBuilder.isPassThrough());
+      add("track", builders.trackBuilder.fillAnyTable(), builders.trackBuilder.isPassThrough());
+      add("k0short", builders.k0shortBuilder.fillAnyTable(), builders.k0shortBuilder.isPassThrough());
+      add("lambda", builders.lambdaBuilder.fillAnyTable(), builders.lambdaBuilder.isPassThrough());
+      add("antilambda", builders.antilambdaBuilder.fillAnyTable(), builders.antilambdaBuilder.isPassThrough());
+      add("photon", builders.photonBuilder.fillAnyTable(), builders.photonBuilder.isPassThrough());
+      add("d0", builders.d0Builder.fillAnyTable(), builders.d0Builder.isPassThrough());
+      add("d0bar", builders.d0barBuilder.fillAnyTable(), builders.d0barBuilder.isPassThrough());
+      add("lc", builders.lcBuilder.fillAnyTable(), builders.lcBuilder.isPassThrough());
+      add("lcbar", builders.lcBarBuilder.fillAnyTable(), builders.lcBarBuilder.isPassThrough());
+      add("sigma", builders.sigmaBuilder.fillAnyTable(), builders.sigmaBuilder.isPassThrough());
+      add("sigmaplus", builders.sigmaPlusBuilder.fillAnyTable(), builders.sigmaPlusBuilder.isPassThrough());
+      add("xi", builders.xiBuilder.fillAnyTable(), builders.xiBuilder.isPassThrough());
+      add("omega", builders.omegaBuilder.fillAnyTable(), builders.omegaBuilder.isPassThrough());
+      add("mc", builders.mcBuilder.fillAnyTable(), builders.mcBuilder.isPassThrough());
 
       const bool anyPassThrough = std::any_of(passThroughFlags.begin(), passThroughFlags.end(),
                                               [](const auto& f) { return f.second; });
@@ -318,19 +327,19 @@ struct FemtoProducer {
 
       // in mc pass-through every generated collision is written, but reco collisions of other
       // sub-generators are still rejected in checkCollision -> biased event-loss denominator
-      if (mcBuilder.isPassThrough() && collisionBuilder.isPassThrough() && collisionBuilder.subGeneratorId() >= 0) {
+      if (builders.mcBuilder.isPassThrough() && builders.collisionBuilder.isPassThrough() && builders.collisionBuilder.subGeneratorId() >= 0) {
         LOG(warn) << "MC and collision pass-through are enabled, but CollisionFilter.subGeneratorId = "
-                  << collisionBuilder.subGeneratorId() << " still rejects reconstructed collisions of other sub-generators, "
+                  << builders.collisionBuilder.subGeneratorId() << " still rejects reconstructed collisions of other sub-generators, "
                   << "while all generated collisions are written. Set it to -1 for unbiased event/signal-loss corrections.";
       }
 
       // daughter tracks can be written a second time under the collision of their mother candidate;
       // without FTrackExtras (fillType) these rows cannot be told apart from selected tracks downstream
-      const bool anyDaughterBuilder = k0shortBuilder.fillAnyTable() || lambdaBuilder.fillAnyTable() || antilambdaBuilder.fillAnyTable() ||
-                                      xiBuilder.fillAnyTable() || omegaBuilder.fillAnyTable() ||
-                                      sigmaBuilder.fillAnyTable() || sigmaPlusBuilder.fillAnyTable() ||
-                                      d0Builder.fillAnyTable() || d0barBuilder.fillAnyTable() || lcBuilder.fillAnyTable() || lcBarBuilder.fillAnyTable();
-      if (trackBuilder.isPassThrough() && anyDaughterBuilder && !trackBuilder.producingTrackExtras()) {
+      const bool anyDaughterBuilder = builders.k0shortBuilder.fillAnyTable() || builders.lambdaBuilder.fillAnyTable() || builders.antilambdaBuilder.fillAnyTable() ||
+                                      builders.xiBuilder.fillAnyTable() || builders.omegaBuilder.fillAnyTable() ||
+                                      builders.sigmaBuilder.fillAnyTable() || builders.sigmaPlusBuilder.fillAnyTable() ||
+                                      builders.d0Builder.fillAnyTable() || builders.d0barBuilder.fillAnyTable() || builders.lcBuilder.fillAnyTable() || builders.lcBarBuilder.fillAnyTable();
+      if (builders.trackBuilder.isPassThrough() && anyDaughterBuilder && !builders.trackBuilder.producingTrackExtras()) {
         LOG(warn) << "Track pass-through is enabled together with candidates that register daughter tracks, but FTrackExtras is not produced. "
                   << "Daughter-only track rows cannot be identified downstream (enable TrackTables.produceTrackExtras).";
       }
@@ -381,17 +390,17 @@ struct FemtoProducer {
   template <modes::System system, typename T1, typename T2, typename T3>
   bool processCollisions(T1 const& col, T2 const& /* bcs*/, T3 const& tracks)
   {
-    collisionBuilder.reset();
+    builders.collisionBuilder.reset();
     auto bc = col.template bc_as<T2>();
-    collisionBuilder.initCollision<system>(bc, col, tracks, ccdb, hRegistry);
-    if (!collisionBuilder.checkCollision(col)) {
+    builders.collisionBuilder.initCollision<system>(bc, col, tracks, ccdb, hRegistry);
+    if (!builders.collisionBuilder.checkCollision(col)) {
       return false;
     }
     // Normally the collision row is written lazily, once a candidate is found. In
     // pass-through we need every accepted collision, including those with no candidate,
     // otherwise event-normalised observables lose exactly those events.
-    if (collisionBuilder.isPassThrough()) {
-      collisionBuilder.fillCollision<system>(collisionBuilderProducts, col);
+    if (builders.collisionBuilder.isPassThrough()) {
+      builders.collisionBuilder.fillCollision<system>(collisionBuilderProducts, col);
     }
     return true;
   }
@@ -399,21 +408,21 @@ struct FemtoProducer {
   template <modes::System system, typename T1, typename T2, typename T3, typename T4>
   bool processMcCollisions(T1 const& col, T2 const& mcCols, T3 const& /* bcs*/, T4 const& tracks)
   {
-    collisionBuilder.reset();
-    // mcBuilder.reset() runs once per timeframe in the calling processTracksXXXMc function
+    builders.collisionBuilder.reset();
+    // builders.mcBuilder.reset() runs once per timeframe in the calling processTracksXXXMc function
     // (both pass-through and lazy-fill mode); resetting here on every reco collision would
     // wipe the dedup maps and duplicate every mc collision/particle referenced by more than
     // one reco collision (e.g. split-vertex reconstruction under pileup)
     auto bc = col.template bc_as<T3>();
-    collisionBuilder.initCollision<system>(bc, col, tracks, ccdb, hRegistry);
-    if (!collisionBuilder.checkCollision(col, mcCols)) {
+    builders.collisionBuilder.initCollision<system>(bc, col, tracks, ccdb, hRegistry);
+    if (!builders.collisionBuilder.checkCollision(col, mcCols)) {
       return false;
     }
     // NOTE: must be fillMcCollision, not fillCollision - fillMcCollision returns early on
     //       mCollisionAlreadyFilled, so filling the collision first would permanently skip
     //       the collision label
-    if (collisionBuilder.isPassThrough()) {
-      collisionBuilder.fillMcCollision<system>(collisionBuilderProducts, col, mcCols, mcProducts, mcBuilder);
+    if (builders.collisionBuilder.isPassThrough()) {
+      builders.collisionBuilder.fillMcCollision<system>(collisionBuilderProducts, col, mcCols, mcProducts, builders.mcBuilder);
     }
     return true;
   }
@@ -422,95 +431,95 @@ struct FemtoProducer {
   template <modes::System system, typename T1, typename T2>
   void processTracks(T1 const& col, T2 const& tracksWithItsPid)
   {
-    trackBuilder.reset(tracksWithItsPid);
-    trackBuilder.fillTracks<system>(col, collisionBuilder, collisionBuilderProducts, tracksWithItsPid, trackBuilderProducts);
+    builders.trackBuilder.reset(tracksWithItsPid);
+    builders.trackBuilder.fillTracks<system>(col, builders.collisionBuilder, collisionBuilderProducts, tracksWithItsPid, trackBuilderProducts);
   }
   template <modes::System system, typename T1, typename T2, typename T3, typename T4, typename T5>
   void processMcTracks(T1 const& col, T2 const& mcCols, T3 const& tracks, T4 const& tracksWithItsPid, T5 const& mcParticles)
   {
-    trackBuilder.reset(tracksWithItsPid);
-    trackBuilder.fillMcTracks<system>(col, collisionBuilder, collisionBuilderProducts, mcCols, tracks, tracksWithItsPid, trackBuilderProducts, mcParticles, mcBuilder, mcProducts);
+    builders.trackBuilder.reset(tracksWithItsPid);
+    builders.trackBuilder.fillMcTracks<system>(col, builders.collisionBuilder, collisionBuilderProducts, mcCols, tracks, tracksWithItsPid, trackBuilderProducts, mcParticles, builders.mcBuilder, mcProducts);
   }
 
   // processing v0s
   template <modes::System system, typename T1, typename T2, typename T3>
   void processV0s(T1 const& col, T2 const& tracks, T3 const& v0s)
   {
-    lambdaBuilder.fillV0s<system>(col, collisionBuilder, collisionBuilderProducts, trackBuilderProducts, v0builderProducts, v0s, tracks, trackBuilder);
-    antilambdaBuilder.fillV0s<system>(col, collisionBuilder, collisionBuilderProducts, trackBuilderProducts, v0builderProducts, v0s, tracks, trackBuilder);
-    k0shortBuilder.fillV0s<system>(col, collisionBuilder, collisionBuilderProducts, trackBuilderProducts, v0builderProducts, v0s, tracks, trackBuilder);
+    builders.lambdaBuilder.fillV0s<system>(col, builders.collisionBuilder, collisionBuilderProducts, trackBuilderProducts, v0builderProducts, v0s, tracks, builders.trackBuilder);
+    builders.antilambdaBuilder.fillV0s<system>(col, builders.collisionBuilder, collisionBuilderProducts, trackBuilderProducts, v0builderProducts, v0s, tracks, builders.trackBuilder);
+    builders.k0shortBuilder.fillV0s<system>(col, builders.collisionBuilder, collisionBuilderProducts, trackBuilderProducts, v0builderProducts, v0s, tracks, builders.trackBuilder);
   }
   template <modes::System system, typename T1, typename T2, typename T3, typename T4, typename T5>
   void processMcV0s(T1 const& col, T2 const& mcCols, T3 const& tracks, T4 const& v0s, T5 const& mcParticles)
   {
-    lambdaBuilder.fillMcV0s<system>(col, collisionBuilder, collisionBuilderProducts, mcCols, trackBuilderProducts, v0builderProducts, v0s, tracks, trackBuilder, mcParticles, mcBuilder, mcProducts);
-    antilambdaBuilder.fillMcV0s<system>(col, collisionBuilder, collisionBuilderProducts, mcCols, trackBuilderProducts, v0builderProducts, v0s, tracks, trackBuilder, mcParticles, mcBuilder, mcProducts);
-    k0shortBuilder.fillMcV0s<system>(col, collisionBuilder, collisionBuilderProducts, mcCols, trackBuilderProducts, v0builderProducts, v0s, tracks, trackBuilder, mcParticles, mcBuilder, mcProducts);
+    builders.lambdaBuilder.fillMcV0s<system>(col, builders.collisionBuilder, collisionBuilderProducts, mcCols, trackBuilderProducts, v0builderProducts, v0s, tracks, builders.trackBuilder, mcParticles, builders.mcBuilder, mcProducts);
+    builders.antilambdaBuilder.fillMcV0s<system>(col, builders.collisionBuilder, collisionBuilderProducts, mcCols, trackBuilderProducts, v0builderProducts, v0s, tracks, builders.trackBuilder, mcParticles, builders.mcBuilder, mcProducts);
+    builders.k0shortBuilder.fillMcV0s<system>(col, builders.collisionBuilder, collisionBuilderProducts, mcCols, trackBuilderProducts, v0builderProducts, v0s, tracks, builders.trackBuilder, mcParticles, builders.mcBuilder, mcProducts);
   }
 
   // processing photons (PCM)
   template <modes::System system, typename T1, typename T2, typename T3>
   void processPhotons(T1 const& col, T2 const& photons, T3 const& v0legs)
   {
-    photonBuilder.fillPhotons<system>(col, collisionBuilder, collisionBuilderProducts, photonBuilderProducts, photons, v0legs);
+    builders.photonBuilder.fillPhotons<system>(col, builders.collisionBuilder, collisionBuilderProducts, photonBuilderProducts, photons, v0legs);
   }
 
   // processing kinks
   template <modes::System system, typename T1, typename T2, typename T3>
   void processKinks(T1 const& col, T2 const& tracks, T3 const& kinks)
   {
-    sigmaBuilder.fillKinks<system>(col, collisionBuilder, collisionBuilderProducts, trackBuilderProducts, kinkBuilderProducts, kinks, tracks, trackBuilder);
-    sigmaPlusBuilder.fillKinks<system>(col, collisionBuilder, collisionBuilderProducts, trackBuilderProducts, kinkBuilderProducts, kinks, tracks, trackBuilder);
+    builders.sigmaBuilder.fillKinks<system>(col, builders.collisionBuilder, collisionBuilderProducts, trackBuilderProducts, kinkBuilderProducts, kinks, tracks, builders.trackBuilder);
+    builders.sigmaPlusBuilder.fillKinks<system>(col, builders.collisionBuilder, collisionBuilderProducts, trackBuilderProducts, kinkBuilderProducts, kinks, tracks, builders.trackBuilder);
   }
   template <modes::System system, typename T1, typename T2, typename T3, typename T4, typename T5>
   void processMcKinks(T1 const& col, T2 const& mcCols, T3 const& tracks, T4 const& kinks, T5 const& mcParticles)
   {
-    sigmaBuilder.fillMcKinks<system>(col, collisionBuilder, collisionBuilderProducts, mcCols, trackBuilderProducts, kinkBuilderProducts, kinks, tracks, trackBuilder, mcParticles, mcBuilder, mcProducts);
-    sigmaPlusBuilder.fillMcKinks<system>(col, collisionBuilder, collisionBuilderProducts, mcCols, trackBuilderProducts, kinkBuilderProducts, kinks, tracks, trackBuilder, mcParticles, mcBuilder, mcProducts);
+    builders.sigmaBuilder.fillMcKinks<system>(col, builders.collisionBuilder, collisionBuilderProducts, mcCols, trackBuilderProducts, kinkBuilderProducts, kinks, tracks, builders.trackBuilder, mcParticles, builders.mcBuilder, mcProducts);
+    builders.sigmaPlusBuilder.fillMcKinks<system>(col, builders.collisionBuilder, collisionBuilderProducts, mcCols, trackBuilderProducts, kinkBuilderProducts, kinks, tracks, builders.trackBuilder, mcParticles, builders.mcBuilder, mcProducts);
   }
 
   // processing cascades
   template <modes::System system, typename T1, typename T2, typename T3>
   void processCascades(T1 const& col, T2 const& tracks, T3 const& cascades)
   {
-    xiBuilder.fillCascades<system>(col, collisionBuilder, collisionBuilderProducts, trackBuilderProducts, cascadeBuilderProducts,
-                                   cascades, tracks, trackBuilder);
-    omegaBuilder.fillCascades<system>(col, collisionBuilder, collisionBuilderProducts, trackBuilderProducts, cascadeBuilderProducts,
-                                      cascades, tracks, trackBuilder);
+    builders.xiBuilder.fillCascades<system>(col, builders.collisionBuilder, collisionBuilderProducts, trackBuilderProducts, cascadeBuilderProducts,
+                                            cascades, tracks, builders.trackBuilder);
+    builders.omegaBuilder.fillCascades<system>(col, builders.collisionBuilder, collisionBuilderProducts, trackBuilderProducts, cascadeBuilderProducts,
+                                               cascades, tracks, builders.trackBuilder);
   }
   template <modes::System system, typename T1, typename T2, typename T3, typename T4, typename T5>
   void processMcCascades(T1 const& col, T2 const& mcCols, T3 const& tracks, T4 const& cascades, T5 const& mcParticles)
   {
-    xiBuilder.fillMcCascades<system>(col, collisionBuilder, collisionBuilderProducts, mcCols, trackBuilderProducts, cascadeBuilderProducts, cascades, tracks, trackBuilder, mcParticles, mcBuilder, mcProducts);
-    omegaBuilder.fillMcCascades<system>(col, collisionBuilder, collisionBuilderProducts, mcCols, trackBuilderProducts, cascadeBuilderProducts, cascades, tracks, trackBuilder, mcParticles, mcBuilder, mcProducts);
+    builders.xiBuilder.fillMcCascades<system>(col, builders.collisionBuilder, collisionBuilderProducts, mcCols, trackBuilderProducts, cascadeBuilderProducts, cascades, tracks, builders.trackBuilder, mcParticles, builders.mcBuilder, mcProducts);
+    builders.omegaBuilder.fillMcCascades<system>(col, builders.collisionBuilder, collisionBuilderProducts, mcCols, trackBuilderProducts, cascadeBuilderProducts, cascades, tracks, builders.trackBuilder, mcParticles, builders.mcBuilder, mcProducts);
   }
 
   // processing D0s
   template <modes::System system, typename T1, typename T2, typename T3>
   void processD0s(T1 const& col, T2 const& tracks, T3 const& candidates)
   {
-    d0Builder.fillCharmHadrons<system>(col, collisionBuilder, collisionBuilderProducts, trackBuilderProducts, charmHadronBuilderProducts, candidates, tracks, trackBuilder);
-    d0barBuilder.fillCharmHadrons<system>(col, collisionBuilder, collisionBuilderProducts, trackBuilderProducts, charmHadronBuilderProducts, candidates, tracks, trackBuilder);
+    builders.d0Builder.fillCharmHadrons<system>(col, builders.collisionBuilder, collisionBuilderProducts, trackBuilderProducts, charmHadronBuilderProducts, candidates, tracks, builders.trackBuilder);
+    builders.d0barBuilder.fillCharmHadrons<system>(col, builders.collisionBuilder, collisionBuilderProducts, trackBuilderProducts, charmHadronBuilderProducts, candidates, tracks, builders.trackBuilder);
   }
   template <modes::System system, typename T1, typename T2, typename T3, typename T4, typename T5>
   void processMcD0s(T1 const& col, T2 const& mcCols, T3 const& tracks, T4 const& candidates, T5 const& mcParticles)
   {
-    d0Builder.fillMcCharmHadrons<system>(col, collisionBuilder, collisionBuilderProducts, mcCols, trackBuilderProducts, charmHadronBuilderProducts, candidates, tracks, trackBuilder, mcParticles, mcBuilder, mcProducts);
-    d0barBuilder.fillMcCharmHadrons<system>(col, collisionBuilder, collisionBuilderProducts, mcCols, trackBuilderProducts, charmHadronBuilderProducts, candidates, tracks, trackBuilder, mcParticles, mcBuilder, mcProducts);
+    builders.d0Builder.fillMcCharmHadrons<system>(col, builders.collisionBuilder, collisionBuilderProducts, mcCols, trackBuilderProducts, charmHadronBuilderProducts, candidates, tracks, builders.trackBuilder, mcParticles, builders.mcBuilder, mcProducts);
+    builders.d0barBuilder.fillMcCharmHadrons<system>(col, builders.collisionBuilder, collisionBuilderProducts, mcCols, trackBuilderProducts, charmHadronBuilderProducts, candidates, tracks, builders.trackBuilder, mcParticles, builders.mcBuilder, mcProducts);
   }
 
   // processing Lcs
   template <modes::System system, typename T1, typename T2, typename T3>
   void processLcs(T1 const& col, T2 const& tracks, T3 const& candidates)
   {
-    lcBuilder.fillCharmHadrons<system>(col, collisionBuilder, collisionBuilderProducts, trackBuilderProducts, charmHadronBuilderProducts, candidates, tracks, trackBuilder);
-    lcBarBuilder.fillCharmHadrons<system>(col, collisionBuilder, collisionBuilderProducts, trackBuilderProducts, charmHadronBuilderProducts, candidates, tracks, trackBuilder);
+    builders.lcBuilder.fillCharmHadrons<system>(col, builders.collisionBuilder, collisionBuilderProducts, trackBuilderProducts, charmHadronBuilderProducts, candidates, tracks, builders.trackBuilder);
+    builders.lcBarBuilder.fillCharmHadrons<system>(col, builders.collisionBuilder, collisionBuilderProducts, trackBuilderProducts, charmHadronBuilderProducts, candidates, tracks, builders.trackBuilder);
   }
   template <modes::System system, typename T1, typename T2, typename T3, typename T4, typename T5>
   void processMcLcs(T1 const& col, T2 const& mcCols, T3 const& tracks, T4 const& candidates, T5 const& mcParticles)
   {
-    lcBuilder.fillMcCharmHadrons<system>(col, collisionBuilder, collisionBuilderProducts, mcCols, trackBuilderProducts, charmHadronBuilderProducts, candidates, tracks, trackBuilder, mcParticles, mcBuilder, mcProducts);
-    lcBarBuilder.fillMcCharmHadrons<system>(col, collisionBuilder, collisionBuilderProducts, mcCols, trackBuilderProducts, charmHadronBuilderProducts, candidates, tracks, trackBuilder, mcParticles, mcBuilder, mcProducts);
+    builders.lcBuilder.fillMcCharmHadrons<system>(col, builders.collisionBuilder, collisionBuilderProducts, mcCols, trackBuilderProducts, charmHadronBuilderProducts, candidates, tracks, builders.trackBuilder, mcParticles, builders.mcBuilder, mcProducts);
+    builders.lcBarBuilder.fillMcCharmHadrons<system>(col, builders.collisionBuilder, collisionBuilderProducts, mcCols, trackBuilderProducts, charmHadronBuilderProducts, candidates, tracks, builders.trackBuilder, mcParticles, builders.mcBuilder, mcProducts);
   }
 
   // ==========================================================================
@@ -585,7 +594,7 @@ struct FemtoProducer {
     processTracks<modes::System::kPP_Run3>(col, tracksWithItsPid);
     // V0PhotonsKF/V0Legs carry a plain CollisionId column (not a framework index column), so they
     // are not auto-grouped by the DPL binder and must be sliced manually, same as EMPhotonFilter.cxx
-    auto photonsThisCol = photons.sliceBy(perColRecoPCMPhotons, col.globalIndex());
+    auto photonsThisCol = photons.sliceBy(preslices.perColRecoPCMPhotons, col.globalIndex());
     processPhotons<modes::System::kPP_Run3>(col, photonsThisCol, v0legs);
   }
   PROCESS_SWITCH(FemtoProducer, processTracksPhotonsRun3pp, "Provide tracks and PCM photons", false);
@@ -602,7 +611,7 @@ struct FemtoProducer {
     auto tracksWithItsPid = o2::soa::Attach<rawinputs::Run3FullPidTracks, o2::aod::pidits::ITSNSigmaEl, o2::aod::pidits::ITSNSigmaPi, o2::aod::pidits::ITSNSigmaKa,
                                             o2::aod::pidits::ITSNSigmaPr, o2::aod::pidits::ITSNSigmaDe, o2::aod::pidits::ITSNSigmaTr, o2::aod::pidits::ITSNSigmaHe>(tracks);
     processTracks<modes::System::kPbPb_Run3>(col, tracksWithItsPid);
-    auto photonsThisCol = photons.sliceBy(perColRecoPCMPhotons, col.globalIndex());
+    auto photonsThisCol = photons.sliceBy(preslices.perColRecoPCMPhotons, col.globalIndex());
     processPhotons<modes::System::kPbPb_Run3>(col, photonsThisCol, v0legs);
   }
   PROCESS_SWITCH(FemtoProducer, processTracksPhotonsRun3PbPb, "Provide tracks and PCM photons in PbPb collisions", false);
@@ -691,7 +700,7 @@ struct FemtoProducer {
     processCascades<modes::System::kPbPb_Run3>(col, tracks, cascades);
     // V0PhotonsKF/V0Legs carry a plain CollisionId column (not a framework index column), so they
     // are not auto-grouped by the DPL binder and must be sliced manually, same as EMPhotonFilter.cxx
-    auto photonsThisCol = photons.sliceBy(perColRecoPCMPhotons, col.globalIndex());
+    auto photonsThisCol = photons.sliceBy(preslices.perColRecoPCMPhotons, col.globalIndex());
     processPhotons<modes::System::kPbPb_Run3>(col, photonsThisCol, v0legs);
   }
   PROCESS_SWITCH(FemtoProducer, processTracksV0sCascadesPhotonsRun3PbPbWithEventShape, "Provide tracks, v0s, cascades and PCM photons in PbPb collisions with event shape information", false);
@@ -750,7 +759,7 @@ struct FemtoProducer {
     processKinks<modes::System::kPP_Run3>(col, tracks, kinks);
     // V0PhotonsKF/V0Legs carry a plain CollisionId column (not a framework index column), so they
     // are not auto-grouped by the DPL binder and must be sliced manually, same as EMPhotonFilter.cxx
-    auto photonsThisCol = photons.sliceBy(perColRecoPCMPhotons, col.globalIndex());
+    auto photonsThisCol = photons.sliceBy(preslices.perColRecoPCMPhotons, col.globalIndex());
     processPhotons<modes::System::kPP_Run3>(col, photonsThisCol, v0legs);
   }
   PROCESS_SWITCH(FemtoProducer, processTracksV0sCascadesKinksPhotonsRun3pp, "Provide tracks, v0s, cascades, kinks and PCM photons", false);
@@ -804,13 +813,13 @@ struct FemtoProducer {
                              rawinputs::Run3McRecoTracks const& tracks,
                              rawinputs::Run3McGenParticles const& mcParticles)
   {
-    mcBuilder.reset(mcCols, mcParticles);
-    if (mcBuilder.isPassThrough()) {
-      mcBuilder.fillMcPassThrough<modes::System::kPP_Run3_MC>(mcCols, mcParticles, perMcCollision, mcProducts);
+    builders.mcBuilder.reset(mcCols, mcParticles);
+    if (builders.mcBuilder.isPassThrough()) {
+      builders.mcBuilder.fillMcPassThrough<modes::System::kPP_Run3_MC>(mcCols, mcParticles, preslices.perMcCollision, mcProducts);
     }
 
     for (const auto& col : cols) {
-      auto tracksThisCol = tracks.sliceBy(perColRecoTracks, col.globalIndex());
+      auto tracksThisCol = tracks.sliceBy(preslices.perColRecoTracks, col.globalIndex());
       if (!processMcCollisions<modes::System::kPP_Run3_MC>(col, mcCols, bcs, tracksThisCol)) {
         continue;
       }
@@ -827,13 +836,13 @@ struct FemtoProducer {
                                rawinputs::Run3McRecoTracks const& tracks,
                                rawinputs::Run3McGenParticles const& mcParticles)
   {
-    mcBuilder.reset(mcCols, mcParticles);
-    if (mcBuilder.isPassThrough()) {
-      mcBuilder.fillMcPassThrough<modes::System::kPbPb_Run3_MC>(mcCols, mcParticles, perMcCollision, mcProducts);
+    builders.mcBuilder.reset(mcCols, mcParticles);
+    if (builders.mcBuilder.isPassThrough()) {
+      builders.mcBuilder.fillMcPassThrough<modes::System::kPbPb_Run3_MC>(mcCols, mcParticles, preslices.perMcCollision, mcProducts);
     }
 
     for (const auto& col : cols) {
-      auto tracksThisCol = tracks.sliceBy(perColRecoTracks, col.globalIndex());
+      auto tracksThisCol = tracks.sliceBy(preslices.perColRecoTracks, col.globalIndex());
       if (!processMcCollisions<modes::System::kPbPb_Run3_MC>(col, mcCols, bcs, tracksThisCol)) {
         continue;
       }
@@ -851,13 +860,13 @@ struct FemtoProducer {
                                 rawinputs::Run3RecoVzeros const& v0s,
                                 rawinputs::Run3McGenParticles const& mcParticles)
   {
-    mcBuilder.reset(mcCols, mcParticles);
-    if (mcBuilder.isPassThrough()) {
-      mcBuilder.fillMcPassThrough<modes::System::kPP_Run3_MC>(mcCols, mcParticles, perMcCollision, mcProducts);
+    builders.mcBuilder.reset(mcCols, mcParticles);
+    if (builders.mcBuilder.isPassThrough()) {
+      builders.mcBuilder.fillMcPassThrough<modes::System::kPP_Run3_MC>(mcCols, mcParticles, preslices.perMcCollision, mcProducts);
     }
 
     for (const auto& col : cols) {
-      auto tracksThisCol = tracks.sliceBy(perColRecoTracks, col.globalIndex());
+      auto tracksThisCol = tracks.sliceBy(preslices.perColRecoTracks, col.globalIndex());
       if (!processMcCollisions<modes::System::kPP_Run3_MC>(col, mcCols, bcs, tracksThisCol)) {
         continue;
       }
@@ -865,7 +874,7 @@ struct FemtoProducer {
                                               o2::aod::pidits::ITSNSigmaPr, o2::aod::pidits::ITSNSigmaDe, o2::aod::pidits::ITSNSigmaTr, o2::aod::pidits::ITSNSigmaHe>(tracksThisCol);
       processMcTracks<modes::System::kPP_Run3_MC>(col, mcCols, tracksThisCol, tracksWithItsPid, mcParticles);
 
-      auto v0sThisCol = v0s.sliceBy(perColRecoV0s, col.globalIndex());
+      auto v0sThisCol = v0s.sliceBy(preslices.perColRecoV0s, col.globalIndex());
       processMcV0s<modes::System::kPP_Run3_MC>(col, mcCols, tracks, v0sThisCol, mcParticles);
     }
   }
@@ -878,13 +887,13 @@ struct FemtoProducer {
                                   rawinputs::Run3RecoVzeros const& v0s,
                                   rawinputs::Run3McGenParticles const& mcParticles)
   {
-    mcBuilder.reset(mcCols, mcParticles);
-    if (mcBuilder.isPassThrough()) {
-      mcBuilder.fillMcPassThrough<modes::System::kPbPb_Run3_MC>(mcCols, mcParticles, perMcCollision, mcProducts);
+    builders.mcBuilder.reset(mcCols, mcParticles);
+    if (builders.mcBuilder.isPassThrough()) {
+      builders.mcBuilder.fillMcPassThrough<modes::System::kPbPb_Run3_MC>(mcCols, mcParticles, preslices.perMcCollision, mcProducts);
     }
 
     for (const auto& col : cols) {
-      auto tracksThisCol = tracks.sliceBy(perColRecoTracks, col.globalIndex());
+      auto tracksThisCol = tracks.sliceBy(preslices.perColRecoTracks, col.globalIndex());
       if (!processMcCollisions<modes::System::kPbPb_Run3_MC>(col, mcCols, bcs, tracksThisCol)) {
         continue;
       }
@@ -892,7 +901,7 @@ struct FemtoProducer {
                                               o2::aod::pidits::ITSNSigmaPr, o2::aod::pidits::ITSNSigmaDe, o2::aod::pidits::ITSNSigmaTr, o2::aod::pidits::ITSNSigmaHe>(tracksThisCol);
       processMcTracks<modes::System::kPbPb_Run3_MC>(col, mcCols, tracksThisCol, tracksWithItsPid, mcParticles);
 
-      auto v0sThisCol = v0s.sliceBy(perColRecoV0s, col.globalIndex());
+      auto v0sThisCol = v0s.sliceBy(preslices.perColRecoV0s, col.globalIndex());
       processMcV0s<modes::System::kPbPb_Run3_MC>(col, mcCols, tracks, v0sThisCol, mcParticles);
     }
   }
@@ -906,13 +915,13 @@ struct FemtoProducer {
                                         rawinputs::Run3RecoCascades const& cascades,
                                         rawinputs::Run3McGenParticles const& mcParticles)
   {
-    mcBuilder.reset(mcCols, mcParticles);
-    if (mcBuilder.isPassThrough()) {
-      mcBuilder.fillMcPassThrough<modes::System::kPP_Run3_MC>(mcCols, mcParticles, perMcCollision, mcProducts);
+    builders.mcBuilder.reset(mcCols, mcParticles);
+    if (builders.mcBuilder.isPassThrough()) {
+      builders.mcBuilder.fillMcPassThrough<modes::System::kPP_Run3_MC>(mcCols, mcParticles, preslices.perMcCollision, mcProducts);
     }
 
     for (const auto& col : cols) {
-      auto tracksThisCol = tracks.sliceBy(perColRecoTracks, col.globalIndex());
+      auto tracksThisCol = tracks.sliceBy(preslices.perColRecoTracks, col.globalIndex());
       if (!processMcCollisions<modes::System::kPP_Run3_MC>(col, mcCols, bcs, tracksThisCol)) {
         continue;
       }
@@ -920,10 +929,10 @@ struct FemtoProducer {
                                               o2::aod::pidits::ITSNSigmaPr, o2::aod::pidits::ITSNSigmaDe, o2::aod::pidits::ITSNSigmaTr, o2::aod::pidits::ITSNSigmaHe>(tracksThisCol);
       processMcTracks<modes::System::kPP_Run3_MC>(col, mcCols, tracksThisCol, tracksWithItsPid, mcParticles);
 
-      auto v0sThisCol = v0s.sliceBy(perColRecoV0s, col.globalIndex());
+      auto v0sThisCol = v0s.sliceBy(preslices.perColRecoV0s, col.globalIndex());
       processMcV0s<modes::System::kPP_Run3_MC>(col, mcCols, tracks, v0sThisCol, mcParticles);
 
-      auto cascadesThisCol = cascades.sliceBy(perColRecoCascades, col.globalIndex());
+      auto cascadesThisCol = cascades.sliceBy(preslices.perColRecoCascades, col.globalIndex());
       processMcCascades<modes::System::kPP_Run3_MC>(col, mcCols, tracks, cascadesThisCol, mcParticles);
     }
   }
@@ -937,13 +946,13 @@ struct FemtoProducer {
                                           rawinputs::Run3RecoCascades const& cascades,
                                           rawinputs::Run3McGenParticles const& mcParticles)
   {
-    mcBuilder.reset(mcCols, mcParticles);
-    if (mcBuilder.isPassThrough()) {
-      mcBuilder.fillMcPassThrough<modes::System::kPbPb_Run3_MC>(mcCols, mcParticles, perMcCollision, mcProducts);
+    builders.mcBuilder.reset(mcCols, mcParticles);
+    if (builders.mcBuilder.isPassThrough()) {
+      builders.mcBuilder.fillMcPassThrough<modes::System::kPbPb_Run3_MC>(mcCols, mcParticles, preslices.perMcCollision, mcProducts);
     }
 
     for (const auto& col : cols) {
-      auto tracksThisCol = tracks.sliceBy(perColRecoTracks, col.globalIndex());
+      auto tracksThisCol = tracks.sliceBy(preslices.perColRecoTracks, col.globalIndex());
       if (!processMcCollisions<modes::System::kPbPb_Run3_MC>(col, mcCols, bcs, tracksThisCol)) {
         continue;
       }
@@ -951,10 +960,10 @@ struct FemtoProducer {
                                               o2::aod::pidits::ITSNSigmaPr, o2::aod::pidits::ITSNSigmaDe, o2::aod::pidits::ITSNSigmaTr, o2::aod::pidits::ITSNSigmaHe>(tracksThisCol);
       processMcTracks<modes::System::kPbPb_Run3_MC>(col, mcCols, tracksThisCol, tracksWithItsPid, mcParticles);
 
-      auto v0sThisCol = v0s.sliceBy(perColRecoV0s, col.globalIndex());
+      auto v0sThisCol = v0s.sliceBy(preslices.perColRecoV0s, col.globalIndex());
       processMcV0s<modes::System::kPbPb_Run3_MC>(col, mcCols, tracks, v0sThisCol, mcParticles);
 
-      auto cascadesThisCol = cascades.sliceBy(perColRecoCascades, col.globalIndex());
+      auto cascadesThisCol = cascades.sliceBy(preslices.perColRecoCascades, col.globalIndex());
       processMcCascades<modes::System::kPbPb_Run3_MC>(col, mcCols, tracks, cascadesThisCol, mcParticles);
     }
   }
@@ -967,13 +976,13 @@ struct FemtoProducer {
                                   rawinputs::Run3Kinks const& kinks,
                                   rawinputs::Run3McGenParticles const& mcParticles)
   {
-    mcBuilder.reset(mcCols, mcParticles);
-    if (mcBuilder.isPassThrough()) {
-      mcBuilder.fillMcPassThrough<modes::System::kPP_Run3_MC>(mcCols, mcParticles, perMcCollision, mcProducts);
+    builders.mcBuilder.reset(mcCols, mcParticles);
+    if (builders.mcBuilder.isPassThrough()) {
+      builders.mcBuilder.fillMcPassThrough<modes::System::kPP_Run3_MC>(mcCols, mcParticles, preslices.perMcCollision, mcProducts);
     }
 
     for (const auto& col : cols) {
-      auto tracksThisCol = tracks.sliceBy(perColRecoTracks, col.globalIndex());
+      auto tracksThisCol = tracks.sliceBy(preslices.perColRecoTracks, col.globalIndex());
       if (!processMcCollisions<modes::System::kPP_Run3_MC>(col, mcCols, bcs, tracksThisCol)) {
         continue;
       }
@@ -981,7 +990,7 @@ struct FemtoProducer {
                                               o2::aod::pidits::ITSNSigmaPr, o2::aod::pidits::ITSNSigmaDe, o2::aod::pidits::ITSNSigmaTr, o2::aod::pidits::ITSNSigmaHe>(tracksThisCol);
       processMcTracks<modes::System::kPP_Run3_MC>(col, mcCols, tracksThisCol, tracksWithItsPid, mcParticles);
 
-      auto kinksThisCol = kinks.sliceBy(perColRecoKinks, col.globalIndex());
+      auto kinksThisCol = kinks.sliceBy(preslices.perColRecoKinks, col.globalIndex());
       processMcKinks<modes::System::kPP_Run3_MC>(col, mcCols, tracks, kinksThisCol, mcParticles);
     }
   }
@@ -995,13 +1004,13 @@ struct FemtoProducer {
                                      rawinputs::Run3Kinks const& kinks,
                                      rawinputs::Run3McGenParticles const& mcParticles)
   {
-    mcBuilder.reset(mcCols, mcParticles);
-    if (mcBuilder.isPassThrough()) {
-      mcBuilder.fillMcPassThrough<modes::System::kPP_Run3_MC>(mcCols, mcParticles, perMcCollision, mcProducts);
+    builders.mcBuilder.reset(mcCols, mcParticles);
+    if (builders.mcBuilder.isPassThrough()) {
+      builders.mcBuilder.fillMcPassThrough<modes::System::kPP_Run3_MC>(mcCols, mcParticles, preslices.perMcCollision, mcProducts);
     }
 
     for (const auto& col : cols) {
-      auto tracksThisCol = tracks.sliceBy(perColRecoTracks, col.globalIndex());
+      auto tracksThisCol = tracks.sliceBy(preslices.perColRecoTracks, col.globalIndex());
       if (!processMcCollisions<modes::System::kPP_Run3_MC>(col, mcCols, bcs, tracksThisCol)) {
         continue;
       }
@@ -1009,10 +1018,10 @@ struct FemtoProducer {
                                               o2::aod::pidits::ITSNSigmaPr, o2::aod::pidits::ITSNSigmaDe, o2::aod::pidits::ITSNSigmaTr, o2::aod::pidits::ITSNSigmaHe>(tracksThisCol);
       processMcTracks<modes::System::kPP_Run3_MC>(col, mcCols, tracksThisCol, tracksWithItsPid, mcParticles);
 
-      auto v0sThisCol = v0s.sliceBy(perColRecoV0s, col.globalIndex());
+      auto v0sThisCol = v0s.sliceBy(preslices.perColRecoV0s, col.globalIndex());
       processMcV0s<modes::System::kPP_Run3_MC>(col, mcCols, tracks, v0sThisCol, mcParticles);
 
-      auto kinksThisCol = kinks.sliceBy(perColRecoKinks, col.globalIndex());
+      auto kinksThisCol = kinks.sliceBy(preslices.perColRecoKinks, col.globalIndex());
       processMcKinks<modes::System::kPP_Run3_MC>(col, mcCols, tracks, kinksThisCol, mcParticles);
     }
   }
@@ -1025,13 +1034,13 @@ struct FemtoProducer {
                                 rawinputs::Run3RecoD0s const& d0s,
                                 rawinputs::Run3McGenParticles const& mcParticles)
   {
-    mcBuilder.reset(mcCols, mcParticles);
-    if (mcBuilder.isPassThrough()) {
-      mcBuilder.fillMcPassThrough<modes::System::kPP_Run3_MC>(mcCols, mcParticles, perMcCollision, mcProducts);
+    builders.mcBuilder.reset(mcCols, mcParticles);
+    if (builders.mcBuilder.isPassThrough()) {
+      builders.mcBuilder.fillMcPassThrough<modes::System::kPP_Run3_MC>(mcCols, mcParticles, preslices.perMcCollision, mcProducts);
     }
 
     for (const auto& col : cols) {
-      auto tracksThisCol = tracks.sliceBy(perColRecoTracks, col.globalIndex());
+      auto tracksThisCol = tracks.sliceBy(preslices.perColRecoTracks, col.globalIndex());
       if (!processMcCollisions<modes::System::kPP_Run3_MC>(col, mcCols, bcs, tracksThisCol)) {
         continue;
       }
@@ -1039,7 +1048,7 @@ struct FemtoProducer {
                                               o2::aod::pidits::ITSNSigmaPr, o2::aod::pidits::ITSNSigmaDe, o2::aod::pidits::ITSNSigmaTr, o2::aod::pidits::ITSNSigmaHe>(tracksThisCol);
       processMcTracks<modes::System::kPP_Run3_MC>(col, mcCols, tracksThisCol, tracksWithItsPid, mcParticles);
 
-      auto d0sThisCol = d0s.sliceBy(perColRecoD0s, col.globalIndex());
+      auto d0sThisCol = d0s.sliceBy(preslices.perColRecoD0s, col.globalIndex());
       processMcD0s<modes::System::kPP_Run3_MC>(col, mcCols, tracks, d0sThisCol, mcParticles);
     }
   }
@@ -1052,13 +1061,13 @@ struct FemtoProducer {
                                   rawinputs::Run3RecoD0s const& d0s,
                                   rawinputs::Run3McGenParticles const& mcParticles)
   {
-    mcBuilder.reset(mcCols, mcParticles);
-    if (mcBuilder.isPassThrough()) {
-      mcBuilder.fillMcPassThrough<modes::System::kPbPb_Run3_MC>(mcCols, mcParticles, perMcCollision, mcProducts);
+    builders.mcBuilder.reset(mcCols, mcParticles);
+    if (builders.mcBuilder.isPassThrough()) {
+      builders.mcBuilder.fillMcPassThrough<modes::System::kPbPb_Run3_MC>(mcCols, mcParticles, preslices.perMcCollision, mcProducts);
     }
 
     for (const auto& col : cols) {
-      auto tracksThisCol = tracks.sliceBy(perColRecoTracks, col.globalIndex());
+      auto tracksThisCol = tracks.sliceBy(preslices.perColRecoTracks, col.globalIndex());
       if (!processMcCollisions<modes::System::kPbPb_Run3_MC>(col, mcCols, bcs, tracksThisCol)) {
         continue;
       }
@@ -1066,7 +1075,7 @@ struct FemtoProducer {
                                               o2::aod::pidits::ITSNSigmaPr, o2::aod::pidits::ITSNSigmaDe, o2::aod::pidits::ITSNSigmaTr, o2::aod::pidits::ITSNSigmaHe>(tracksThisCol);
       processMcTracks<modes::System::kPbPb_Run3_MC>(col, mcCols, tracksThisCol, tracksWithItsPid, mcParticles);
 
-      auto d0sThisCol = d0s.sliceBy(perColRecoD0s, col.globalIndex());
+      auto d0sThisCol = d0s.sliceBy(preslices.perColRecoD0s, col.globalIndex());
       processMcD0s<modes::System::kPbPb_Run3_MC>(col, mcCols, tracks, d0sThisCol, mcParticles);
     }
   }
@@ -1109,13 +1118,13 @@ struct FemtoProducer {
                                 rawinputs::Run3RecoLcs const& lcs,
                                 rawinputs::Run3McGenParticles const& mcParticles)
   {
-    mcBuilder.reset(mcCols, mcParticles);
-    if (mcBuilder.isPassThrough()) {
-      mcBuilder.fillMcPassThrough<modes::System::kPP_Run3_MC>(mcCols, mcParticles, perMcCollision, mcProducts);
+    builders.mcBuilder.reset(mcCols, mcParticles);
+    if (builders.mcBuilder.isPassThrough()) {
+      builders.mcBuilder.fillMcPassThrough<modes::System::kPP_Run3_MC>(mcCols, mcParticles, preslices.perMcCollision, mcProducts);
     }
 
     for (const auto& col : cols) {
-      auto tracksThisCol = tracks.sliceBy(perColRecoTracks, col.globalIndex());
+      auto tracksThisCol = tracks.sliceBy(preslices.perColRecoTracks, col.globalIndex());
       if (!processMcCollisions<modes::System::kPP_Run3_MC>(col, mcCols, bcs, tracksThisCol)) {
         continue;
       }
@@ -1123,7 +1132,7 @@ struct FemtoProducer {
                                               o2::aod::pidits::ITSNSigmaPr, o2::aod::pidits::ITSNSigmaDe, o2::aod::pidits::ITSNSigmaTr, o2::aod::pidits::ITSNSigmaHe>(tracksThisCol);
       processMcTracks<modes::System::kPP_Run3_MC>(col, mcCols, tracksThisCol, tracksWithItsPid, mcParticles);
 
-      auto lcsThisCol = lcs.sliceBy(perColRecoLcs, col.globalIndex());
+      auto lcsThisCol = lcs.sliceBy(preslices.perColRecoLcs, col.globalIndex());
       processMcLcs<modes::System::kPP_Run3_MC>(col, mcCols, tracks, lcsThisCol, mcParticles);
     }
   }
@@ -1136,13 +1145,13 @@ struct FemtoProducer {
                                   rawinputs::Run3RecoLcs const& lcs,
                                   rawinputs::Run3McGenParticles const& mcParticles)
   {
-    mcBuilder.reset(mcCols, mcParticles);
-    if (mcBuilder.isPassThrough()) {
-      mcBuilder.fillMcPassThrough<modes::System::kPbPb_Run3_MC>(mcCols, mcParticles, perMcCollision, mcProducts);
+    builders.mcBuilder.reset(mcCols, mcParticles);
+    if (builders.mcBuilder.isPassThrough()) {
+      builders.mcBuilder.fillMcPassThrough<modes::System::kPbPb_Run3_MC>(mcCols, mcParticles, preslices.perMcCollision, mcProducts);
     }
 
     for (const auto& col : cols) {
-      auto tracksThisCol = tracks.sliceBy(perColRecoTracks, col.globalIndex());
+      auto tracksThisCol = tracks.sliceBy(preslices.perColRecoTracks, col.globalIndex());
       if (!processMcCollisions<modes::System::kPbPb_Run3_MC>(col, mcCols, bcs, tracksThisCol)) {
         continue;
       }
@@ -1150,7 +1159,7 @@ struct FemtoProducer {
                                               o2::aod::pidits::ITSNSigmaPr, o2::aod::pidits::ITSNSigmaDe, o2::aod::pidits::ITSNSigmaTr, o2::aod::pidits::ITSNSigmaHe>(tracksThisCol);
       processMcTracks<modes::System::kPbPb_Run3_MC>(col, mcCols, tracksThisCol, tracksWithItsPid, mcParticles);
 
-      auto lcsThisCol = lcs.sliceBy(perColRecoLcs, col.globalIndex());
+      auto lcsThisCol = lcs.sliceBy(preslices.perColRecoLcs, col.globalIndex());
       processMcLcs<modes::System::kPbPb_Run3_MC>(col, mcCols, tracks, lcsThisCol, mcParticles);
     }
   }
@@ -1163,12 +1172,12 @@ struct FemtoProducer {
   // do not preslice the mcParticles table passed to fillMcParticle, otherwise the finding of the partonic mother can fail
   void processMcOnly(o2::aod::McCollisions const& mcCols, o2::aod::McParticles const& mcParticles)
   {
-    mcBuilder.reset(mcCols, mcParticles);
+    builders.mcBuilder.reset(mcCols, mcParticles);
     for (const auto& mcCol : mcCols) {
-      auto particlesThisCollision = mcParticles.sliceBy(perMcCollision, mcCol.globalIndex());
-      mcBuilder.fillMcCollision(mcCol, particlesThisCollision, mcProducts, pdgDb);
+      auto particlesThisCollision = mcParticles.sliceBy(preslices.perMcCollision, mcCol.globalIndex());
+      builders.mcBuilder.fillMcCollision(mcCol, particlesThisCollision, mcProducts, pdgDb);
       for (const auto& mcParticle : particlesThisCollision) {
-        mcBuilder.fillMcParticle<modes::System::kMC>(mcParticle, mcParticles, mcCol, mcProducts);
+        builders.mcBuilder.fillMcParticle<modes::System::kMC>(mcParticle, mcParticles, mcCol, mcProducts);
       }
     }
   }
diff --git a/PWGCF/Femto/TableProducer/femtoProducerDerivedToDerived.cxx b/PWGCF/Femto/TableProducer/femtoProducerDerivedToDerived.cxx
index b8cbdd436f1..a2bc14986b2 100644
--- a/PWGCF/Femto/TableProducer/femtoProducerDerivedToDerived.cxx
+++ b/PWGCF/Femto/TableProducer/femtoProducerDerivedToDerived.cxx
@@ -33,135 +33,150 @@
 
 using namespace o2::analysis::femto;
 
-struct FemtoProducerDerivedToDerived {
+// kept outside the task struct on purpose: the struct is reflected via a brace-decomposition
+// mechanism capped at 100 direct data members (see o2::framework::PresliceGroup for the same
+// concern applied to Preslice members below); type aliases don't need to live inside the struct
+// at all, so moving them here keeps that budget free for actual data members.
+namespace femtotables
+{
+using FemtoCollisions = o2::soa::Join<o2::aod::FCols, o2::aod::FColMasks>;
+
+using FilteredFemtoCollisions = o2::soa::Filtered<FemtoCollisions>;
+using FilteredFemtoCollision = FilteredFemtoCollisions::iterator;
+
+using FemtoMcCollisions = o2::soa::Join<FemtoCollisions, o2::aod::FColLabels>;
+using FilteredFemtoMcCollisions = o2::soa::Filtered<FemtoMcCollisions>;
+
+using FemtoTracks = o2::soa::Join<o2::aod::FTracks, o2::aod::FTrackMasks>;
+using FemtoTracksWithMass = o2::soa::Join<FemtoTracks, o2::aod::FTrackMass>;
+// opt-in: carries the packed purity tables and FTrackDcas through to the re-written output --
+// needs the upstream producer's TrackTables.produceItsPurity/produceTpcPurity/produceTofPurity/produceTrackDcas enabled
+using FemtoTracksWithPurity = o2::soa::Join<FemtoTracks, o2::aod::FItsPurity, o2::aod::FTpcPurity, o2::aod::FTofPurity, o2::aod::FTrackDcas>;
+using FemtoLambdas = o2::soa::Join<o2::aod::FLambdas, o2::aod::FLambdaMasks>;
+using FemtoK0shorts = o2::soa::Join<o2::aod::FK0shorts, o2::aod::FK0shortMasks>;
+using FemtoRho0s = o2::soa::Join<o2::aod::FRho0s, o2::aod::FRho0Masks>;
+using FemtoPhis = o2::soa::Join<o2::aod::FPhis, o2::aod::FPhiMasks>;
+using FemtoXis = o2::soa::Join<o2::aod::FXis, o2::aod::FXiMasks>;
+using FemtoOmegas = o2::soa::Join<o2::aod::FOmegas, o2::aod::FOmegaMasks>;
+using FemtoSigma = o2::soa::Join<o2::aod::FSigmas, o2::aod::FSigmaMasks>;
+using FemtoSigmaPlus = o2::soa::Join<o2::aod::FSigmaPlus, o2::aod::FSigmaPlusMasks>;
+using FemtoSigmaPlusExtended = o2::soa::Join<FemtoSigmaPlus, o2::aod::FSigmaPlusExtras>;
+
+using FemtoMcTracks = o2::soa::Join<FemtoTracks, o2::aod::FTrackLabels>;
+using FemtoMcSigma = o2::soa::Join<FemtoSigma, o2::aod::FSigmaLabels>;
+using FemtoMcSigmaPlus = o2::soa::Join<FemtoSigmaPlus, o2::aod::FSigmaPlusLabels>;
+using FemtoMcSigmaPlusExtended = o2::soa::Join<FemtoSigmaPlusExtended, o2::aod::FSigmaPlusLabels>;
+using FemtoMcParticles = o2::soa::Join<o2::aod::FMcParticles, o2::aod::FMcMotherLabels>;
+} // namespace femtotables
 
-  // setup tables
-  using FemtoCollisions = o2::soa::Join<o2::aod::FCols, o2::aod::FColMasks>;
-
-  using FilteredFemtoCollisions = o2::soa::Filtered<FemtoCollisions>;
-  using FilteredFemtoCollision = FilteredFemtoCollisions::iterator;
-
-  using FemtoMcCollisions = o2::soa::Join<FemtoCollisions, o2::aod::FColLabels>;
-  using FilteredFemtoMcCollisions = o2::soa::Filtered<FemtoMcCollisions>;
-
-  using FemtoTracks = o2::soa::Join<o2::aod::FTracks, o2::aod::FTrackMasks>;
-  using FemtoTracksWithMass = o2::soa::Join<FemtoTracks, o2::aod::FTrackMass>;
-  // opt-in: carries the packed purity tables and FTrackDcas through to the re-written output --
-  // needs the upstream producer's TrackTables.produceItsPurity/produceTpcPurity/produceTofPurity/produceTrackDcas enabled
-  using FemtoTracksWithPurity = o2::soa::Join<FemtoTracks, o2::aod::FItsPurity, o2::aod::FTpcPurity, o2::aod::FTofPurity, o2::aod::FTrackDcas>;
-  using FemtoLambdas = o2::soa::Join<o2::aod::FLambdas, o2::aod::FLambdaMasks>;
-  using FemtoK0shorts = o2::soa::Join<o2::aod::FK0shorts, o2::aod::FK0shortMasks>;
-  using FemtoRho0s = o2::soa::Join<o2::aod::FRho0s, o2::aod::FRho0Masks>;
-  using FemtoPhis = o2::soa::Join<o2::aod::FPhis, o2::aod::FPhiMasks>;
-  using FemtoXis = o2::soa::Join<o2::aod::FXis, o2::aod::FXiMasks>;
-  using FemtoOmegas = o2::soa::Join<o2::aod::FOmegas, o2::aod::FOmegaMasks>;
-  using FemtoSigma = o2::soa::Join<o2::aod::FSigmas, o2::aod::FSigmaMasks>;
-  using FemtoSigmaPlus = o2::soa::Join<o2::aod::FSigmaPlus, o2::aod::FSigmaPlusMasks>;
-  using FemtoSigmaPlusExtended = o2::soa::Join<FemtoSigmaPlus, o2::aod::FSigmaPlusExtras>;
-
-  using FemtoMcTracks = o2::soa::Join<FemtoTracks, o2::aod::FTrackLabels>;
-  using FemtoMcSigma = o2::soa::Join<FemtoSigma, o2::aod::FSigmaLabels>;
-  using FemtoMcSigmaPlus = o2::soa::Join<FemtoSigmaPlus, o2::aod::FSigmaPlusLabels>;
-  using FemtoMcSigmaPlusExtended = o2::soa::Join<FemtoSigmaPlusExtended, o2::aod::FSigmaPlusLabels>;
-  using FemtoMcParticles = o2::soa::Join<o2::aod::FMcParticles, o2::aod::FMcMotherLabels>;
+struct FemtoProducerDerivedToDerived {
 
   o2::framework::SliceCache cache;
 
+  // all fColId Preslice declarations, grouped into a single data member
+  struct : public o2::framework::PresliceGroup {
+    o2::framework::Preslice<femtotables::FemtoTracks> perColTracks = o2::aod::femtobase::stored::fColId;
+    o2::framework::Preslice<femtotables::FemtoTracksWithMass> perColTracksWithMass = o2::aod::femtobase::stored::fColId;
+    o2::framework::Preslice<femtotables::FemtoTracksWithPurity> perColTracksWithPurity = o2::aod::femtobase::stored::fColId;
+    o2::framework::Preslice<femtotables::FemtoLambdas> perColLambdas = o2::aod::femtobase::stored::fColId;
+    o2::framework::Preslice<femtotables::FemtoK0shorts> perColK0shorts = o2::aod::femtobase::stored::fColId;
+    o2::framework::Preslice<femtotables::FemtoRho0s> perColRho0s = o2::aod::femtobase::stored::fColId;
+    o2::framework::Preslice<femtotables::FemtoPhis> perColPhis = o2::aod::femtobase::stored::fColId;
+    o2::framework::Preslice<femtotables::FemtoSigma> perColSigma = o2::aod::femtobase::stored::fColId;
+    o2::framework::Preslice<femtotables::FemtoSigmaPlus> perColSigmaPlus = o2::aod::femtobase::stored::fColId;
+    o2::framework::Preslice<femtotables::FemtoSigmaPlusExtended> perColSigmaPlusExtended = o2::aod::femtobase::stored::fColId;
+    o2::framework::Preslice<femtotables::FemtoXis> perColXis = o2::aod::femtobase::stored::fColId;
+    o2::framework::Preslice<femtotables::FemtoOmegas> perColOmegas = o2::aod::femtobase::stored::fColId;
+    o2::framework::Preslice<femtotables::FemtoMcTracks> perColMcTracks = o2::aod::femtobase::stored::fColId;
+    o2::framework::Preslice<femtotables::FemtoMcSigma> perColMcSigma = o2::aod::femtobase::stored::fColId;
+    o2::framework::Preslice<femtotables::FemtoMcSigmaPlus> perColMcSigmaPlus = o2::aod::femtobase::stored::fColId;
+    o2::framework::Preslice<femtotables::FemtoMcSigmaPlusExtended> perColMcSigmaPlusExtended = o2::aod::femtobase::stored::fColId;
+  } preslices;
+
+  // plain builder helper objects, grouped into a single data member (not Configurable/Partition/
+  // Preslice/Produces, so the framework never needs to discover them individually -- free to nest)
+  struct {
+    collisionbuilder::CollisionBuilderDerivedToDerived collisionBuilder;
+    trackbuilder::TrackBuilderDerivedToDerived trackBuilder;
+    v0builder::V0BuilderDerivedToDerived v0Builder;
+    twotrackresonancebuilder::TwoTrackResonanceBuilderDerivedToDerived resonanceBuilder;
+    kinkbuilder::KinkBuilderDerivedToDerived kinkBuilder;
+    cascadebuilder::CascadeBuilderDerivedToDerived cascadeBuilder;
+    mcbuilder::McBuilderDerivedToDerived mcBuilder;
+  } builders;
+
   // collision builder
   collisionbuilder::ConfCollisionSelection collisionSelection;
   o2::framework::expressions::Filter collisionFilter = MAKE_COLLISION_FILTER(collisionSelection);
   collisionbuilder::CollisionBuilderDerivedToDerivedProducts collisionBuilderProducts;
-  collisionbuilder::CollisionBuilderDerivedToDerived collisionBuilder;
 
   // track builder
-  trackbuilder::TrackBuilderDerivedToDerived trackBuilder;
   trackbuilder::TrackBuilderDerivedToDerivedProducts trackBuilderProducts;
   trackbuilder::ConfTrackTablesDerivedToDerived confTrackBuilder;
   trackbuilder::ConfTrackSelection1 trackSelections1;
   trackbuilder::ConfTrackSelection2 trackSelections2;
 
-  o2::framework::Partition<FemtoTracks> trackPartition1 = MAKE_TRACK_PARTITION(trackSelections1);
-  o2::framework::Partition<FemtoTracks> trackPartition2 = MAKE_TRACK_PARTITION(trackSelections2);
-  o2::framework::Preslice<FemtoTracks> perColTracks = o2::aod::femtobase::stored::fColId;
+  o2::framework::Partition<femtotables::FemtoTracks> trackPartition1 = MAKE_TRACK_PARTITION(trackSelections1);
+  o2::framework::Partition<femtotables::FemtoTracks> trackPartition2 = MAKE_TRACK_PARTITION(trackSelections2);
 
-  o2::framework::Partition<FemtoTracksWithMass> trackWithMassPartition1 = MAKE_TRACK_PARTITION_WITH_MASS(trackSelections1);
-  o2::framework::Partition<FemtoTracksWithMass> trackWithMassPartition2 = MAKE_TRACK_PARTITION_WITH_MASS(trackSelections2);
-  o2::framework::Preslice<FemtoTracksWithMass> perColTracksWithMass = o2::aod::femtobase::stored::fColId;
+  o2::framework::Partition<femtotables::FemtoTracksWithMass> trackWithMassPartition1 = MAKE_TRACK_PARTITION_WITH_MASS(trackSelections1);
+  o2::framework::Partition<femtotables::FemtoTracksWithMass> trackWithMassPartition2 = MAKE_TRACK_PARTITION_WITH_MASS(trackSelections2);
 
-  o2::framework::Partition<FemtoTracksWithPurity> trackWithPurityPartition1 = MAKE_TRACK_PARTITION(trackSelections1);
-  o2::framework::Partition<FemtoTracksWithPurity> trackWithPurityPartition2 = MAKE_TRACK_PARTITION(trackSelections2);
-  o2::framework::Preslice<FemtoTracksWithPurity> perColTracksWithPurity = o2::aod::femtobase::stored::fColId;
+  o2::framework::Partition<femtotables::FemtoTracksWithPurity> trackWithPurityPartition1 = MAKE_TRACK_PARTITION(trackSelections1);
+  o2::framework::Partition<femtotables::FemtoTracksWithPurity> trackWithPurityPartition2 = MAKE_TRACK_PARTITION(trackSelections2);
 
   // v0 builder
-  v0builder::V0BuilderDerivedToDerived v0Builder;
   v0builder::V0BuilderDerivedToDerivedProducts v0BuilderProducts;
   v0builder::ConfV0TablesDerivedToDerived confV0Builder;
 
   v0builder::ConfLambdaSelection1 lambdaSelection1;
-  o2::framework::Partition<FemtoLambdas> lambdaPartition = MAKE_LAMBDA_PARTITION(lambdaSelection1);
-  o2::framework::Preslice<FemtoLambdas> perColLambdas = o2::aod::femtobase::stored::fColId;
+  o2::framework::Partition<femtotables::FemtoLambdas> lambdaPartition = MAKE_LAMBDA_PARTITION(lambdaSelection1);
 
   v0builder::ConfK0shortSelection1 k0shortSelection1;
-  o2::framework::Partition<FemtoK0shorts> k0shortPartition = MAKE_K0SHORT_PARTITION(k0shortSelection1);
-  o2::framework::Preslice<FemtoK0shorts> perColK0shorts = o2::aod::femtobase::stored::fColId;
+  o2::framework::Partition<femtotables::FemtoK0shorts> k0shortPartition = MAKE_K0SHORT_PARTITION(k0shortSelection1);
 
   // two-track resonance builder
-  twotrackresonancebuilder::TwoTrackResonanceBuilderDerivedToDerived resonanceBuilder;
   twotrackresonancebuilder::TwoTrackResonanceBuilderDerivedToDerivedProducts resonanceBuilderProducts;
   twotrackresonancebuilder::ConfTwoTrackResonanceTablesDerivedToDerived confResonanceBuilder;
 
   twotrackresonancebuilder::ConfRho0Selection rho0Selection;
-  o2::framework::Partition<FemtoRho0s> rho0Partition = MAKE_RESONANCE_0_PARTITON(rho0Selection);
-  o2::framework::Preslice<FemtoRho0s> perColRho0s = o2::aod::femtobase::stored::fColId;
+  o2::framework::Partition<femtotables::FemtoRho0s> rho0Partition = MAKE_RESONANCE_0_PARTITON(rho0Selection);
 
   twotrackresonancebuilder::ConfPhiSelection phiSelection;
-  o2::framework::Partition<FemtoPhis> phiPartition = MAKE_RESONANCE_0_PARTITON(phiSelection);
-  o2::framework::Preslice<FemtoPhis> perColPhis = o2::aod::femtobase::stored::fColId;
+  o2::framework::Partition<femtotables::FemtoPhis> phiPartition = MAKE_RESONANCE_0_PARTITON(phiSelection);
 
   // kink builder
-  kinkbuilder::KinkBuilderDerivedToDerived kinkBuilder;
   kinkbuilder::KinkBuilderDerivedToDerivedProducts kinkBuilderProducts;
   kinkbuilder::ConfKinkTablesDerivedToDerived confKinkBuilder;
 
   kinkbuilder::ConfSigmaSelection1 sigmaSelection1;
-  o2::framework::Partition<FemtoSigma> sigmaPartition = MAKE_SIGMA_PARTITION(sigmaSelection1);
-  o2::framework::Preslice<FemtoSigma> perColSigma = o2::aod::femtobase::stored::fColId;
+  o2::framework::Partition<femtotables::FemtoSigma> sigmaPartition = MAKE_SIGMA_PARTITION(sigmaSelection1);
 
   kinkbuilder::ConfSigmaPlusSelection1 sigmaPlusSelection1;
-  o2::framework::Partition<FemtoSigmaPlus> sigmaPlusPartition = MAKE_SIGMAPLUS_PARTITION(sigmaPlusSelection1);
-  o2::framework::Preslice<FemtoSigmaPlus> perColSigmaPlus = o2::aod::femtobase::stored::fColId;
-  o2::framework::Partition<FemtoSigmaPlusExtended> sigmaPlusExtendedPartition = MAKE_SIGMAPLUS_PARTITION(sigmaPlusSelection1);
-  o2::framework::Preslice<FemtoSigmaPlusExtended> perColSigmaPlusExtended = o2::aod::femtobase::stored::fColId;
+  o2::framework::Partition<femtotables::FemtoSigmaPlus> sigmaPlusPartition = MAKE_SIGMAPLUS_PARTITION(sigmaPlusSelection1);
+  o2::framework::Partition<femtotables::FemtoSigmaPlusExtended> sigmaPlusExtendedPartition = MAKE_SIGMAPLUS_PARTITION(sigmaPlusSelection1);
 
   // cascade builder
-  cascadebuilder::CascadeBuilderDerivedToDerived cascadeBuilder;
   cascadebuilder::CascadeBuilderDerivedToDerivedProducts cascadeBuilderProducts;
   cascadebuilder::ConfCascadeTablesDerivedToDerived confCascadeBuilder;
 
   cascadebuilder::ConfXiSelection xiSelection;
-  o2::framework::Partition<FemtoXis> xiPartition = MAKE_CASCADE_PARTITION(xiSelection);
-  o2::framework::Preslice<FemtoXis> perColXis = o2::aod::femtobase::stored::fColId;
+  o2::framework::Partition<femtotables::FemtoXis> xiPartition = MAKE_CASCADE_PARTITION(xiSelection);
 
   cascadebuilder::ConfOmegaSelection omegaSelection;
-  o2::framework::Partition<FemtoOmegas> omegaPartition = MAKE_CASCADE_PARTITION(omegaSelection);
-  o2::framework::Preslice<FemtoOmegas> perColOmegas = o2::aod::femtobase::stored::fColId;
+  o2::framework::Partition<femtotables::FemtoOmegas> omegaPartition = MAKE_CASCADE_PARTITION(omegaSelection);
 
   // mc builder
-  mcbuilder::McBuilderDerivedToDerived mcBuilder;
   mcbuilder::McBuilderDerivedToDerivedProducts mcBuilderProducts;
   mcbuilder::ConfMcTablesDerivedToDerived confMcBuilder;
 
-  o2::framework::Partition<FemtoMcTracks> mcTrackPartition1 = MAKE_TRACK_PARTITION(trackSelections1);
-  o2::framework::Partition<FemtoMcTracks> mcTrackPartition2 = MAKE_TRACK_PARTITION(trackSelections2);
-  o2::framework::Preslice<FemtoMcTracks> perColMcTracks = o2::aod::femtobase::stored::fColId;
+  o2::framework::Partition<femtotables::FemtoMcTracks> mcTrackPartition1 = MAKE_TRACK_PARTITION(trackSelections1);
+  o2::framework::Partition<femtotables::FemtoMcTracks> mcTrackPartition2 = MAKE_TRACK_PARTITION(trackSelections2);
 
-  o2::framework::Partition<FemtoMcSigma> mcSigmaPartition = MAKE_SIGMA_PARTITION(sigmaSelection1);
-  o2::framework::Preslice<FemtoMcSigma> perColMcSigma = o2::aod::femtobase::stored::fColId;
+  o2::framework::Partition<femtotables::FemtoMcSigma> mcSigmaPartition = MAKE_SIGMA_PARTITION(sigmaSelection1);
 
-  o2::framework::Partition<FemtoMcSigmaPlus> mcSigmaPlusPartition = MAKE_SIGMAPLUS_PARTITION(sigmaPlusSelection1);
-  o2::framework::Preslice<FemtoMcSigmaPlus> perColMcSigmaPlus = o2::aod::femtobase::stored::fColId;
-  o2::framework::Partition<FemtoMcSigmaPlusExtended> mcSigmaPlusExtendedPartition = MAKE_SIGMAPLUS_PARTITION(sigmaPlusSelection1);
-  o2::framework::Preslice<FemtoMcSigmaPlusExtended> perColMcSigmaPlusExtended = o2::aod::femtobase::stored::fColId;
+  o2::framework::Partition<femtotables::FemtoMcSigmaPlus> mcSigmaPlusPartition = MAKE_SIGMAPLUS_PARTITION(sigmaPlusSelection1);
+  o2::framework::Partition<femtotables::FemtoMcSigmaPlusExtended> mcSigmaPlusExtendedPartition = MAKE_SIGMAPLUS_PARTITION(sigmaPlusSelection1);
 
   void init(o2::framework::InitContext& /*context*/)
   {
@@ -179,176 +194,176 @@ struct FemtoProducerDerivedToDerived {
       LOG(fatal) << "Exactly one process function must be activated (got " << activeProcesses << ").";
     }
 
-    trackBuilder.init(confTrackBuilder);
-    v0Builder.init(confV0Builder);
-    cascadeBuilder.init(confCascadeBuilder);
-    kinkBuilder.init(confKinkBuilder);
-    resonanceBuilder.init(confResonanceBuilder);
-    mcBuilder.init(confMcBuilder);
+    builders.trackBuilder.init(confTrackBuilder);
+    builders.v0Builder.init(confV0Builder);
+    builders.cascadeBuilder.init(confCascadeBuilder);
+    builders.kinkBuilder.init(confKinkBuilder);
+    builders.resonanceBuilder.init(confResonanceBuilder);
+    builders.mcBuilder.init(confMcBuilder);
   }
 
   // process functions
-  void processTracks(FilteredFemtoCollision const& col, FemtoTracks const& tracks)
+  void processTracks(femtotables::FilteredFemtoCollision const& col, femtotables::FemtoTracks const& tracks)
   {
-    if (trackBuilder.collisionHasTooFewTracks(col, tracks, trackPartition1, trackPartition2, cache)) {
+    if (builders.trackBuilder.collisionHasTooFewTracks(col, tracks, trackPartition1, trackPartition2, cache)) {
       return;
     }
-    trackBuilder.reset(tracks);
-    collisionBuilder.processCollision(col, collisionBuilderProducts);
-    trackBuilder.processTracks(col, tracks, trackPartition1, trackPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
+    builders.trackBuilder.reset(tracks);
+    builders.collisionBuilder.processCollision(col, collisionBuilderProducts);
+    builders.trackBuilder.processTracks(col, tracks, trackPartition1, trackPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
   }
   PROCESS_SWITCH(FemtoProducerDerivedToDerived, processTracks, "Process tracks", true);
 
-  void processTracksWithMass(FilteredFemtoCollision const& col, FemtoTracksWithMass const& tracks)
+  void processTracksWithMass(femtotables::FilteredFemtoCollision const& col, femtotables::FemtoTracksWithMass const& tracks)
   {
-    if (trackBuilder.collisionHasTooFewTracks(col, tracks, trackWithMassPartition1, trackWithMassPartition2, cache)) {
+    if (builders.trackBuilder.collisionHasTooFewTracks(col, tracks, trackWithMassPartition1, trackWithMassPartition2, cache)) {
       return;
     }
-    trackBuilder.reset(tracks);
-    collisionBuilder.processCollision(col, collisionBuilderProducts);
-    trackBuilder.processTracks(col, tracks, trackWithMassPartition1, trackWithMassPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
+    builders.trackBuilder.reset(tracks);
+    builders.collisionBuilder.processCollision(col, collisionBuilderProducts);
+    builders.trackBuilder.processTracks(col, tracks, trackWithMassPartition1, trackWithMassPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
   }
   PROCESS_SWITCH(FemtoProducerDerivedToDerived, processTracksWithMass, "Process tracks with mass", false);
 
-  void processTracksWithPurity(FilteredFemtoCollision const& col, FemtoTracksWithPurity const& tracks)
+  void processTracksWithPurity(femtotables::FilteredFemtoCollision const& col, femtotables::FemtoTracksWithPurity const& tracks)
   {
-    if (trackBuilder.collisionHasTooFewTracks(col, tracks, trackWithPurityPartition1, trackWithPurityPartition2, cache)) {
+    if (builders.trackBuilder.collisionHasTooFewTracks(col, tracks, trackWithPurityPartition1, trackWithPurityPartition2, cache)) {
       return;
     }
-    trackBuilder.reset(tracks);
-    collisionBuilder.processCollision(col, collisionBuilderProducts);
-    trackBuilder.processTracks(col, tracks, trackWithPurityPartition1, trackWithPurityPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
+    builders.trackBuilder.reset(tracks);
+    builders.collisionBuilder.processCollision(col, collisionBuilderProducts);
+    builders.trackBuilder.processTracks(col, tracks, trackWithPurityPartition1, trackWithPurityPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
   }
   PROCESS_SWITCH(FemtoProducerDerivedToDerived, processTracksWithPurity, "Process tracks, carrying through purity/fraction tables", false);
 
-  void processTracksLambdas(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoLambdas const& lambdas)
+  void processTracksLambdas(femtotables::FilteredFemtoCollision const& col, femtotables::FemtoTracks const& tracks, femtotables::FemtoLambdas const& lambdas)
   {
-    if (trackBuilder.collisionHasTooFewTracks(col, tracks, trackPartition1, trackPartition2, cache) || v0Builder.collisionHasTooFewLambdas(col, lambdas, lambdaPartition, cache)) {
+    if (builders.trackBuilder.collisionHasTooFewTracks(col, tracks, trackPartition1, trackPartition2, cache) || builders.v0Builder.collisionHasTooFewLambdas(col, lambdas, lambdaPartition, cache)) {
       return;
     }
-    trackBuilder.reset(tracks);
-    collisionBuilder.processCollision(col, collisionBuilderProducts);
-    trackBuilder.processTracks(col, tracks, trackPartition1, trackPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
-    v0Builder.processLambdas(col, lambdas, tracks, lambdaPartition, trackBuilder, cache, v0BuilderProducts, trackBuilderProducts, collisionBuilderProducts);
+    builders.trackBuilder.reset(tracks);
+    builders.collisionBuilder.processCollision(col, collisionBuilderProducts);
+    builders.trackBuilder.processTracks(col, tracks, trackPartition1, trackPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
+    builders.v0Builder.processLambdas(col, lambdas, tracks, lambdaPartition, builders.trackBuilder, cache, v0BuilderProducts, trackBuilderProducts, collisionBuilderProducts);
   }
   PROCESS_SWITCH(FemtoProducerDerivedToDerived, processTracksLambdas, "Process lambdas and tracks", false);
 
-  void processTracksWithMassLambdas(FilteredFemtoCollision const& col, FemtoTracksWithMass const& tracks, FemtoLambdas const& lambdas)
+  void processTracksWithMassLambdas(femtotables::FilteredFemtoCollision const& col, femtotables::FemtoTracksWithMass const& tracks, femtotables::FemtoLambdas const& lambdas)
   {
-    if (trackBuilder.collisionHasTooFewTracks(col, tracks, trackWithMassPartition1, trackWithMassPartition2, cache) || v0Builder.collisionHasTooFewLambdas(col, lambdas, lambdaPartition, cache)) {
+    if (builders.trackBuilder.collisionHasTooFewTracks(col, tracks, trackWithMassPartition1, trackWithMassPartition2, cache) || builders.v0Builder.collisionHasTooFewLambdas(col, lambdas, lambdaPartition, cache)) {
       return;
     }
-    trackBuilder.reset(tracks);
-    collisionBuilder.processCollision(col, collisionBuilderProducts);
-    trackBuilder.processTracks(col, tracks, trackWithMassPartition1, trackWithMassPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
-    v0Builder.processLambdas(col, lambdas, tracks, lambdaPartition, trackBuilder, cache, v0BuilderProducts, trackBuilderProducts, collisionBuilderProducts);
+    builders.trackBuilder.reset(tracks);
+    builders.collisionBuilder.processCollision(col, collisionBuilderProducts);
+    builders.trackBuilder.processTracks(col, tracks, trackWithMassPartition1, trackWithMassPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
+    builders.v0Builder.processLambdas(col, lambdas, tracks, lambdaPartition, builders.trackBuilder, cache, v0BuilderProducts, trackBuilderProducts, collisionBuilderProducts);
   }
   PROCESS_SWITCH(FemtoProducerDerivedToDerived, processTracksWithMassLambdas, "Process lambdas and tracks with mass", false);
 
-  void processLambdas(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoLambdas const& lambdas)
+  void processLambdas(femtotables::FilteredFemtoCollision const& col, femtotables::FemtoTracks const& tracks, femtotables::FemtoLambdas const& lambdas)
   {
-    if (v0Builder.collisionHasTooFewLambdas(col, lambdas, lambdaPartition, cache)) {
+    if (builders.v0Builder.collisionHasTooFewLambdas(col, lambdas, lambdaPartition, cache)) {
       return;
     }
-    trackBuilder.reset(tracks);
-    collisionBuilder.processCollision(col, collisionBuilderProducts);
-    v0Builder.processLambdas(col, lambdas, tracks, lambdaPartition, trackBuilder, cache, v0BuilderProducts, trackBuilderProducts, collisionBuilderProducts);
+    builders.trackBuilder.reset(tracks);
+    builders.collisionBuilder.processCollision(col, collisionBuilderProducts);
+    builders.v0Builder.processLambdas(col, lambdas, tracks, lambdaPartition, builders.trackBuilder, cache, v0BuilderProducts, trackBuilderProducts, collisionBuilderProducts);
   }
   PROCESS_SWITCH(FemtoProducerDerivedToDerived, processLambdas, "Process lambdas only (produced track table contains daughers only)", false);
 
-  void processTracksXis(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoXis const& xis)
+  void processTracksXis(femtotables::FilteredFemtoCollision const& col, femtotables::FemtoTracks const& tracks, femtotables::FemtoXis const& xis)
   {
-    if (trackBuilder.collisionHasTooFewTracks(col, tracks, trackPartition1, trackPartition2, cache) || cascadeBuilder.collisionHasTooFewXis(col, xis, xiPartition, cache)) {
+    if (builders.trackBuilder.collisionHasTooFewTracks(col, tracks, trackPartition1, trackPartition2, cache) || builders.cascadeBuilder.collisionHasTooFewXis(col, xis, xiPartition, cache)) {
       return;
     }
-    trackBuilder.reset(tracks);
-    collisionBuilder.processCollision(col, collisionBuilderProducts);
-    trackBuilder.processTracks(col, tracks, trackPartition1, trackPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
-    cascadeBuilder.processXis(col, xis, tracks, xiPartition, trackBuilder, cache, cascadeBuilderProducts, trackBuilderProducts, collisionBuilderProducts);
+    builders.trackBuilder.reset(tracks);
+    builders.collisionBuilder.processCollision(col, collisionBuilderProducts);
+    builders.trackBuilder.processTracks(col, tracks, trackPartition1, trackPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
+    builders.cascadeBuilder.processXis(col, xis, tracks, xiPartition, builders.trackBuilder, cache, cascadeBuilderProducts, trackBuilderProducts, collisionBuilderProducts);
   }
   PROCESS_SWITCH(FemtoProducerDerivedToDerived, processTracksXis, "Process tracks and xis", false);
 
-  void processTracksOmegas(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoOmegas const& omegas)
+  void processTracksOmegas(femtotables::FilteredFemtoCollision const& col, femtotables::FemtoTracks const& tracks, femtotables::FemtoOmegas const& omegas)
   {
-    if (trackBuilder.collisionHasTooFewTracks(col, tracks, trackPartition1, trackPartition2, cache) || cascadeBuilder.collisionHasTooFewOmegas(col, omegas, omegaPartition, cache)) {
+    if (builders.trackBuilder.collisionHasTooFewTracks(col, tracks, trackPartition1, trackPartition2, cache) || builders.cascadeBuilder.collisionHasTooFewOmegas(col, omegas, omegaPartition, cache)) {
       return;
     }
-    trackBuilder.reset(tracks);
-    collisionBuilder.processCollision(col, collisionBuilderProducts);
-    trackBuilder.processTracks(col, tracks, trackPartition1, trackPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
-    cascadeBuilder.processOmegas(col, omegas, tracks, omegaPartition, trackBuilder, cache, cascadeBuilderProducts, trackBuilderProducts, collisionBuilderProducts);
+    builders.trackBuilder.reset(tracks);
+    builders.collisionBuilder.processCollision(col, collisionBuilderProducts);
+    builders.trackBuilder.processTracks(col, tracks, trackPartition1, trackPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
+    builders.cascadeBuilder.processOmegas(col, omegas, tracks, omegaPartition, builders.trackBuilder, cache, cascadeBuilderProducts, trackBuilderProducts, collisionBuilderProducts);
   }
   PROCESS_SWITCH(FemtoProducerDerivedToDerived, processTracksOmegas, "Process tracks and omegas", false);
 
-  void processTracksK0shorts(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoK0shorts const& k0shorts)
+  void processTracksK0shorts(femtotables::FilteredFemtoCollision const& col, femtotables::FemtoTracks const& tracks, femtotables::FemtoK0shorts const& k0shorts)
   {
-    if (trackBuilder.collisionHasTooFewTracks(col, tracks, trackPartition1, trackPartition2, cache) || v0Builder.collisionHasTooFewK0shorts(col, k0shorts, k0shortPartition, cache)) {
+    if (builders.trackBuilder.collisionHasTooFewTracks(col, tracks, trackPartition1, trackPartition2, cache) || builders.v0Builder.collisionHasTooFewK0shorts(col, k0shorts, k0shortPartition, cache)) {
       return;
     }
-    trackBuilder.reset(tracks);
-    collisionBuilder.processCollision(col, collisionBuilderProducts);
-    trackBuilder.processTracks(col, tracks, trackPartition1, trackPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
-    v0Builder.processK0shorts(col, k0shorts, tracks, k0shortPartition, trackBuilder, cache, v0BuilderProducts, trackBuilderProducts, collisionBuilderProducts);
+    builders.trackBuilder.reset(tracks);
+    builders.collisionBuilder.processCollision(col, collisionBuilderProducts);
+    builders.trackBuilder.processTracks(col, tracks, trackPartition1, trackPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
+    builders.v0Builder.processK0shorts(col, k0shorts, tracks, k0shortPartition, builders.trackBuilder, cache, v0BuilderProducts, trackBuilderProducts, collisionBuilderProducts);
   }
   PROCESS_SWITCH(FemtoProducerDerivedToDerived, processTracksK0shorts, "Process k0short and tracks", false);
 
-  void processTracksSigma(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoSigma const& sigma)
+  void processTracksSigma(femtotables::FilteredFemtoCollision const& col, femtotables::FemtoTracks const& tracks, femtotables::FemtoSigma const& sigma)
   {
-    if (trackBuilder.collisionHasTooFewTracks(col, tracks, trackPartition1, trackPartition2, cache) || kinkBuilder.collisionHasTooFewSigma(col, sigma, sigmaPartition, cache)) {
+    if (builders.trackBuilder.collisionHasTooFewTracks(col, tracks, trackPartition1, trackPartition2, cache) || builders.kinkBuilder.collisionHasTooFewSigma(col, sigma, sigmaPartition, cache)) {
       return;
     }
-    trackBuilder.reset(tracks);
-    collisionBuilder.processCollision(col, collisionBuilderProducts);
-    trackBuilder.processTracks(col, tracks, trackPartition1, trackPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
-    kinkBuilder.processSigma(col, sigma, tracks, sigmaPartition, trackBuilder, cache, kinkBuilderProducts, trackBuilderProducts, collisionBuilderProducts);
+    builders.trackBuilder.reset(tracks);
+    builders.collisionBuilder.processCollision(col, collisionBuilderProducts);
+    builders.trackBuilder.processTracks(col, tracks, trackPartition1, trackPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
+    builders.kinkBuilder.processSigma(col, sigma, tracks, sigmaPartition, builders.trackBuilder, cache, kinkBuilderProducts, trackBuilderProducts, collisionBuilderProducts);
   }
   PROCESS_SWITCH(FemtoProducerDerivedToDerived, processTracksSigma, "Process sigma and tracks", false);
 
-  void processTracksSigmaPlus(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoSigmaPlus const& sigmaplus)
+  void processTracksSigmaPlus(femtotables::FilteredFemtoCollision const& col, femtotables::FemtoTracks const& tracks, femtotables::FemtoSigmaPlus const& sigmaplus)
   {
-    if (trackBuilder.collisionHasTooFewTracks(col, tracks, trackPartition1, trackPartition2, cache) || kinkBuilder.collisionHasTooFewSigmaPlus(col, sigmaplus, sigmaPlusPartition, cache)) {
+    if (builders.trackBuilder.collisionHasTooFewTracks(col, tracks, trackPartition1, trackPartition2, cache) || builders.kinkBuilder.collisionHasTooFewSigmaPlus(col, sigmaplus, sigmaPlusPartition, cache)) {
       return;
     }
-    trackBuilder.reset(tracks);
-    collisionBuilder.processCollision(col, collisionBuilderProducts);
-    trackBuilder.processTracks(col, tracks, trackPartition1, trackPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
-    kinkBuilder.processSigmaPlus(col, sigmaplus, tracks, sigmaPlusPartition, trackBuilder, cache, kinkBuilderProducts, trackBuilderProducts, collisionBuilderProducts);
+    builders.trackBuilder.reset(tracks);
+    builders.collisionBuilder.processCollision(col, collisionBuilderProducts);
+    builders.trackBuilder.processTracks(col, tracks, trackPartition1, trackPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
+    builders.kinkBuilder.processSigmaPlus(col, sigmaplus, tracks, sigmaPlusPartition, builders.trackBuilder, cache, kinkBuilderProducts, trackBuilderProducts, collisionBuilderProducts);
   }
   PROCESS_SWITCH(FemtoProducerDerivedToDerived, processTracksSigmaPlus, "Process sigmaPlus and tracks", false);
 
-  void processTracksSigmaPlusExtended(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoSigmaPlusExtended const& sigmaplus)
+  void processTracksSigmaPlusExtended(femtotables::FilteredFemtoCollision const& col, femtotables::FemtoTracks const& tracks, femtotables::FemtoSigmaPlusExtended const& sigmaplus)
   {
-    if (trackBuilder.collisionHasTooFewTracks(col, tracks, trackPartition1, trackPartition2, cache) || kinkBuilder.collisionHasTooFewSigmaPlus(col, sigmaplus, sigmaPlusExtendedPartition, cache)) {
+    if (builders.trackBuilder.collisionHasTooFewTracks(col, tracks, trackPartition1, trackPartition2, cache) || builders.kinkBuilder.collisionHasTooFewSigmaPlus(col, sigmaplus, sigmaPlusExtendedPartition, cache)) {
       return;
     }
-    trackBuilder.reset(tracks);
-    collisionBuilder.processCollision(col, collisionBuilderProducts);
-    trackBuilder.processTracks(col, tracks, trackPartition1, trackPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
-    kinkBuilder.processSigmaPlus(col, sigmaplus, tracks, sigmaPlusExtendedPartition, trackBuilder, cache, kinkBuilderProducts, trackBuilderProducts, collisionBuilderProducts);
+    builders.trackBuilder.reset(tracks);
+    builders.collisionBuilder.processCollision(col, collisionBuilderProducts);
+    builders.trackBuilder.processTracks(col, tracks, trackPartition1, trackPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
+    builders.kinkBuilder.processSigmaPlus(col, sigmaplus, tracks, sigmaPlusExtendedPartition, builders.trackBuilder, cache, kinkBuilderProducts, trackBuilderProducts, collisionBuilderProducts);
   }
   PROCESS_SWITCH(FemtoProducerDerivedToDerived, processTracksSigmaPlusExtended, "Process sigmaPlus (with SigmaPlusExtras) and tracks", false);
 
-  void processTracksRho0(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoRho0s const& rho0s)
+  void processTracksRho0(femtotables::FilteredFemtoCollision const& col, femtotables::FemtoTracks const& tracks, femtotables::FemtoRho0s const& rho0s)
   {
-    if (trackBuilder.collisionHasTooFewTracks(col, tracks, trackPartition1, trackPartition2, cache) || resonanceBuilder.collisionHasTooFewRho0s(col, rho0s, rho0Partition, cache)) {
+    if (builders.trackBuilder.collisionHasTooFewTracks(col, tracks, trackPartition1, trackPartition2, cache) || builders.resonanceBuilder.collisionHasTooFewRho0s(col, rho0s, rho0Partition, cache)) {
       return;
     }
-    trackBuilder.reset(tracks);
-    collisionBuilder.processCollision(col, collisionBuilderProducts);
-    trackBuilder.processTracks(col, tracks, trackPartition1, trackPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
-    resonanceBuilder.processRho0s(col, rho0s, tracks, rho0Partition, trackBuilder, cache, resonanceBuilderProducts, trackBuilderProducts, collisionBuilderProducts);
+    builders.trackBuilder.reset(tracks);
+    builders.collisionBuilder.processCollision(col, collisionBuilderProducts);
+    builders.trackBuilder.processTracks(col, tracks, trackPartition1, trackPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
+    builders.resonanceBuilder.processRho0s(col, rho0s, tracks, rho0Partition, builders.trackBuilder, cache, resonanceBuilderProducts, trackBuilderProducts, collisionBuilderProducts);
   }
   PROCESS_SWITCH(FemtoProducerDerivedToDerived, processTracksRho0, "Process rho0 and tracks", false);
 
-  void processTracksPhi(FilteredFemtoCollision const& col, FemtoTracks const& tracks, FemtoPhis const& phis)
+  void processTracksPhi(femtotables::FilteredFemtoCollision const& col, femtotables::FemtoTracks const& tracks, femtotables::FemtoPhis const& phis)
   {
-    if (trackBuilder.collisionHasTooFewTracks(col, tracks, trackPartition1, trackPartition2, cache) || resonanceBuilder.collisionHasTooFewPhis(col, phis, phiPartition, cache)) {
+    if (builders.trackBuilder.collisionHasTooFewTracks(col, tracks, trackPartition1, trackPartition2, cache) || builders.resonanceBuilder.collisionHasTooFewPhis(col, phis, phiPartition, cache)) {
       return;
     }
-    trackBuilder.reset(tracks);
-    collisionBuilder.processCollision(col, collisionBuilderProducts);
-    trackBuilder.processTracks(col, tracks, trackPartition1, trackPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
-    resonanceBuilder.processPhis(col, phis, tracks, phiPartition, trackBuilder, cache, resonanceBuilderProducts, trackBuilderProducts, collisionBuilderProducts);
+    builders.trackBuilder.reset(tracks);
+    builders.collisionBuilder.processCollision(col, collisionBuilderProducts);
+    builders.trackBuilder.processTracks(col, tracks, trackPartition1, trackPartition2, cache, trackBuilderProducts, collisionBuilderProducts);
+    builders.resonanceBuilder.processPhis(col, phis, tracks, phiPartition, builders.trackBuilder, cache, resonanceBuilderProducts, trackBuilderProducts, collisionBuilderProducts);
   }
   PROCESS_SWITCH(FemtoProducerDerivedToDerived, processTracksPhi, "Process phi and tracks", false);
 
@@ -356,105 +371,105 @@ struct FemtoProducerDerivedToDerived {
   //   // NOTE: unlike the other process functions, this one subscribes to the full
   // collision table and iterates manually. The MC index maps are keyed by source
   // global index and must live for the whole dataframe
-  void processTracksMc(FilteredFemtoMcCollisions const& cols,
-                       FemtoMcTracks const& tracks,
+  void processTracksMc(femtotables::FilteredFemtoMcCollisions const& cols,
+                       femtotables::FemtoMcTracks const& tracks,
                        o2::aod::FMcCols const& mcCols,
-                       FemtoMcParticles const& mcParticles,
+                       femtotables::FemtoMcParticles const& mcParticles,
                        o2::aod::FMcMothers const& mcMothers,
                        o2::aod::FMcPartMoths const& mcPartonicMothers)
   {
     // once per dataframe
-    mcBuilder.reset(mcCols, mcParticles);
+    builders.mcBuilder.reset(mcCols, mcParticles);
 
     for (auto const& col : cols) {
-      if (trackBuilder.collisionHasTooFewTracks(col, tracks, mcTrackPartition1, mcTrackPartition2, cache)) {
+      if (builders.trackBuilder.collisionHasTooFewTracks(col, tracks, mcTrackPartition1, mcTrackPartition2, cache)) {
         continue;
       }
       // track indexMap is per collision by construction, so it resets here
-      trackBuilder.reset(tracks);
-      collisionBuilder.processCollision(col, collisionBuilderProducts);
-      mcBuilder.fillCollisionWithLabel(col, mcCols, mcBuilderProducts);
-      trackBuilder.processTracksWithMc(col, tracks, mcTrackPartition1, mcTrackPartition2, cache,
-                                       trackBuilderProducts, collisionBuilderProducts,
-                                       mcBuilder, mcCols, mcParticles, mcMothers, mcPartonicMothers, mcBuilderProducts);
+      builders.trackBuilder.reset(tracks);
+      builders.collisionBuilder.processCollision(col, collisionBuilderProducts);
+      builders.mcBuilder.fillCollisionWithLabel(col, mcCols, mcBuilderProducts);
+      builders.trackBuilder.processTracksWithMc(col, tracks, mcTrackPartition1, mcTrackPartition2, cache,
+                                                trackBuilderProducts, collisionBuilderProducts,
+                                                builders.mcBuilder, mcCols, mcParticles, mcMothers, mcPartonicMothers, mcBuilderProducts);
     }
   }
   PROCESS_SWITCH(FemtoProducerDerivedToDerived, processTracksMc, "Process tracks with MC information", false);
 
-  void processTracksSigmaMc(FilteredFemtoMcCollisions const& cols,
-                            FemtoMcTracks const& tracks,
-                            FemtoMcSigma const& sigma,
+  void processTracksSigmaMc(femtotables::FilteredFemtoMcCollisions const& cols,
+                            femtotables::FemtoMcTracks const& tracks,
+                            femtotables::FemtoMcSigma const& sigma,
                             o2::aod::FMcCols const& mcCols,
-                            FemtoMcParticles const& mcParticles,
+                            femtotables::FemtoMcParticles const& mcParticles,
                             o2::aod::FMcMothers const& mcMothers,
                             o2::aod::FMcPartMoths const& mcPartonicMothers)
   {
-    mcBuilder.reset(mcCols, mcParticles);
+    builders.mcBuilder.reset(mcCols, mcParticles);
 
     for (auto const& col : cols) {
-      if (trackBuilder.collisionHasTooFewTracks(col, tracks, mcTrackPartition1, mcTrackPartition2, cache) || kinkBuilder.collisionHasTooFewSigma(col, sigma, mcSigmaPartition, cache)) {
+      if (builders.trackBuilder.collisionHasTooFewTracks(col, tracks, mcTrackPartition1, mcTrackPartition2, cache) || builders.kinkBuilder.collisionHasTooFewSigma(col, sigma, mcSigmaPartition, cache)) {
         continue;
       }
-      trackBuilder.reset(tracks);
-      collisionBuilder.processCollision(col, collisionBuilderProducts);
-      mcBuilder.fillCollisionWithLabel(col, mcCols, mcBuilderProducts);
-      trackBuilder.processTracksWithMc(col, tracks, mcTrackPartition1, mcTrackPartition2, cache,
-                                       trackBuilderProducts, collisionBuilderProducts,
-                                       mcBuilder, mcCols, mcParticles, mcMothers, mcPartonicMothers, mcBuilderProducts);
-      kinkBuilder.processSigmaWithMc(col, sigma, tracks, mcSigmaPartition, trackBuilder, cache, kinkBuilderProducts, trackBuilderProducts, collisionBuilderProducts,
-                                     mcBuilder, mcCols, mcParticles, mcMothers, mcPartonicMothers, mcBuilderProducts);
+      builders.trackBuilder.reset(tracks);
+      builders.collisionBuilder.processCollision(col, collisionBuilderProducts);
+      builders.mcBuilder.fillCollisionWithLabel(col, mcCols, mcBuilderProducts);
+      builders.trackBuilder.processTracksWithMc(col, tracks, mcTrackPartition1, mcTrackPartition2, cache,
+                                                trackBuilderProducts, collisionBuilderProducts,
+                                                builders.mcBuilder, mcCols, mcParticles, mcMothers, mcPartonicMothers, mcBuilderProducts);
+      builders.kinkBuilder.processSigmaWithMc(col, sigma, tracks, mcSigmaPartition, builders.trackBuilder, cache, kinkBuilderProducts, trackBuilderProducts, collisionBuilderProducts,
+                                              builders.mcBuilder, mcCols, mcParticles, mcMothers, mcPartonicMothers, mcBuilderProducts);
     }
   }
   PROCESS_SWITCH(FemtoProducerDerivedToDerived, processTracksSigmaMc, "Process sigma and tracks with MC information", false);
 
-  void processTracksSigmaPlusMc(FilteredFemtoMcCollisions const& cols,
-                                FemtoMcTracks const& tracks,
-                                FemtoMcSigmaPlus const& sigmaplus,
+  void processTracksSigmaPlusMc(femtotables::FilteredFemtoMcCollisions const& cols,
+                                femtotables::FemtoMcTracks const& tracks,
+                                femtotables::FemtoMcSigmaPlus const& sigmaplus,
                                 o2::aod::FMcCols const& mcCols,
-                                FemtoMcParticles const& mcParticles,
+                                femtotables::FemtoMcParticles const& mcParticles,
                                 o2::aod::FMcMothers const& mcMothers,
                                 o2::aod::FMcPartMoths const& mcPartonicMothers)
   {
-    mcBuilder.reset(mcCols, mcParticles);
+    builders.mcBuilder.reset(mcCols, mcParticles);
 
     for (auto const& col : cols) {
-      if (trackBuilder.collisionHasTooFewTracks(col, tracks, mcTrackPartition1, mcTrackPartition2, cache) || kinkBuilder.collisionHasTooFewSigmaPlus(col, sigmaplus, mcSigmaPlusPartition, cache)) {
+      if (builders.trackBuilder.collisionHasTooFewTracks(col, tracks, mcTrackPartition1, mcTrackPartition2, cache) || builders.kinkBuilder.collisionHasTooFewSigmaPlus(col, sigmaplus, mcSigmaPlusPartition, cache)) {
         continue;
       }
-      trackBuilder.reset(tracks);
-      collisionBuilder.processCollision(col, collisionBuilderProducts);
-      mcBuilder.fillCollisionWithLabel(col, mcCols, mcBuilderProducts);
-      trackBuilder.processTracksWithMc(col, tracks, mcTrackPartition1, mcTrackPartition2, cache,
-                                       trackBuilderProducts, collisionBuilderProducts,
-                                       mcBuilder, mcCols, mcParticles, mcMothers, mcPartonicMothers, mcBuilderProducts);
-      kinkBuilder.processSigmaPlusWithMc(col, sigmaplus, tracks, mcSigmaPlusPartition, trackBuilder, cache, kinkBuilderProducts, trackBuilderProducts, collisionBuilderProducts,
-                                         mcBuilder, mcCols, mcParticles, mcMothers, mcPartonicMothers, mcBuilderProducts);
+      builders.trackBuilder.reset(tracks);
+      builders.collisionBuilder.processCollision(col, collisionBuilderProducts);
+      builders.mcBuilder.fillCollisionWithLabel(col, mcCols, mcBuilderProducts);
+      builders.trackBuilder.processTracksWithMc(col, tracks, mcTrackPartition1, mcTrackPartition2, cache,
+                                                trackBuilderProducts, collisionBuilderProducts,
+                                                builders.mcBuilder, mcCols, mcParticles, mcMothers, mcPartonicMothers, mcBuilderProducts);
+      builders.kinkBuilder.processSigmaPlusWithMc(col, sigmaplus, tracks, mcSigmaPlusPartition, builders.trackBuilder, cache, kinkBuilderProducts, trackBuilderProducts, collisionBuilderProducts,
+                                                  builders.mcBuilder, mcCols, mcParticles, mcMothers, mcPartonicMothers, mcBuilderProducts);
     }
   }
   PROCESS_SWITCH(FemtoProducerDerivedToDerived, processTracksSigmaPlusMc, "Process sigmaPlus and tracks with MC information", false);
 
-  void processTracksSigmaPlusExtendedMc(FilteredFemtoMcCollisions const& cols,
-                                        FemtoMcTracks const& tracks,
-                                        FemtoMcSigmaPlusExtended const& sigmaplus,
+  void processTracksSigmaPlusExtendedMc(femtotables::FilteredFemtoMcCollisions const& cols,
+                                        femtotables::FemtoMcTracks const& tracks,
+                                        femtotables::FemtoMcSigmaPlusExtended const& sigmaplus,
                                         o2::aod::FMcCols const& mcCols,
-                                        FemtoMcParticles const& mcParticles,
+                                        femtotables::FemtoMcParticles const& mcParticles,
                                         o2::aod::FMcMothers const& mcMothers,
                                         o2::aod::FMcPartMoths const& mcPartonicMothers)
   {
-    mcBuilder.reset(mcCols, mcParticles);
+    builders.mcBuilder.reset(mcCols, mcParticles);
 
     for (auto const& col : cols) {
-      if (trackBuilder.collisionHasTooFewTracks(col, tracks, mcTrackPartition1, mcTrackPartition2, cache) || kinkBuilder.collisionHasTooFewSigmaPlus(col, sigmaplus, mcSigmaPlusExtendedPartition, cache)) {
+      if (builders.trackBuilder.collisionHasTooFewTracks(col, tracks, mcTrackPartition1, mcTrackPartition2, cache) || builders.kinkBuilder.collisionHasTooFewSigmaPlus(col, sigmaplus, mcSigmaPlusExtendedPartition, cache)) {
         continue;
       }
-      trackBuilder.reset(tracks);
-      collisionBuilder.processCollision(col, collisionBuilderProducts);
-      mcBuilder.fillCollisionWithLabel(col, mcCols, mcBuilderProducts);
-      trackBuilder.processTracksWithMc(col, tracks, mcTrackPartition1, mcTrackPartition2, cache,
-                                       trackBuilderProducts, collisionBuilderProducts,
-                                       mcBuilder, mcCols, mcParticles, mcMothers, mcPartonicMothers, mcBuilderProducts);
-      kinkBuilder.processSigmaPlusWithMc(col, sigmaplus, tracks, mcSigmaPlusExtendedPartition, trackBuilder, cache, kinkBuilderProducts, trackBuilderProducts, collisionBuilderProducts,
-                                         mcBuilder, mcCols, mcParticles, mcMothers, mcPartonicMothers, mcBuilderProducts);
+      builders.trackBuilder.reset(tracks);
+      builders.collisionBuilder.processCollision(col, collisionBuilderProducts);
+      builders.mcBuilder.fillCollisionWithLabel(col, mcCols, mcBuilderProducts);
+      builders.trackBuilder.processTracksWithMc(col, tracks, mcTrackPartition1, mcTrackPartition2, cache,
+                                                trackBuilderProducts, collisionBuilderProducts,
+                                                builders.mcBuilder, mcCols, mcParticles, mcMothers, mcPartonicMothers, mcBuilderProducts);
+      builders.kinkBuilder.processSigmaPlusWithMc(col, sigmaplus, tracks, mcSigmaPlusExtendedPartition, builders.trackBuilder, cache, kinkBuilderProducts, trackBuilderProducts, collisionBuilderProducts,
+                                                  builders.mcBuilder, mcCols, mcParticles, mcMothers, mcPartonicMothers, mcBuilderProducts);
     }
   }
   PROCESS_SWITCH(FemtoProducerDerivedToDerived, processTracksSigmaPlusExtendedMc, "Process sigmaPlus (with SigmaPlusExtras) and tracks with MC information", false);