diff --git a/PWGCF/TwoParticleCorrelations/Tasks/lambdaSpinPolarization.cxx b/PWGCF/TwoParticleCorrelations/Tasks/lambdaSpinPolarization.cxx
index f1b3fddd1c5..91fc6b6ec3a 100644
--- a/PWGCF/TwoParticleCorrelations/Tasks/lambdaSpinPolarization.cxx
+++ b/PWGCF/TwoParticleCorrelations/Tasks/lambdaSpinPolarization.cxx
@@ -51,6 +51,7 @@
 
 #include <array>
 #include <cmath>
+#include <cstddef>
 #include <cstdint>
 #include <string>
 #include <string_view>
@@ -73,25 +74,18 @@ DECLARE_SOA_COLUMN(TimeStamp, timeStamp, uint64_t);
 } // namespace lambdacollision
 
 DECLARE_SOA_TABLE(LambdaCollisions, "AOD", "LAMBDACOLS", o2::soa::Index<>,
-                  lambdacollision::Cent,
-                  lambdacollision::Mult,
-                  aod::collision::PosX,
-                  aod::collision::PosY,
-                  aod::collision::PosZ,
-                  lambdacollision::TimeStamp
-                  //, lambdacollision::CollisionId
-);
+                  lambdacollision::Cent, lambdacollision::Mult,
+                  aod::collision::PosX, aod::collision::PosY,
+                  aod::collision::PosZ, lambdacollision::TimeStamp);
 using LambdaCollision = LambdaCollisions::iterator;
 
 namespace lambdamcgencollision
 {
 }
 DECLARE_SOA_TABLE(LambdaMcGenCollisions, "AOD", "LMCGENCOLS", o2::soa::Index<>,
-                  lambdacollision::Cent,
-                  lambdacollision::Mult,
-                  o2::aod::mccollision::PosX,
-                  o2::aod::mccollision::PosY,
-                  o2::aod::mccollision::PosZ);
+                  lambdacollision::Cent, lambdacollision::Mult,
+                  o2::aod::mccollision::PosX, o2::aod::mccollision::PosY,
+                  o2::aod::mccollision::PosZ, lambdacollision::TimeStamp);
 using LambdaMcGenCollision = LambdaMcGenCollisions::iterator;
 
 namespace lambdatrack
@@ -117,31 +111,21 @@ DECLARE_SOA_COLUMN(V0PrmScd, v0PrmScd, int8_t);
 DECLARE_SOA_COLUMN(CorrFact, corrFact, float);
 } // namespace lambdatrack
 DECLARE_SOA_TABLE(LambdaTracks, "AOD", "LAMBDATRACKS", o2::soa::Index<>,
-                  lambdatrack::LambdaCollisionId,
-                  lambdatrack::Px,
-                  lambdatrack::Py,
-                  lambdatrack::Pz,
-                  lambdatrack::Pt,
-                  lambdatrack::Eta,
-                  lambdatrack::Phi,
-                  lambdatrack::Rap,
-                  lambdatrack::Mass,
-                  lambdatrack::PrPx,
-                  lambdatrack::PrPy,
-                  lambdatrack::PrPz,
-                  lambdatrack::PosTrackId,
-                  lambdatrack::NegTrackId,
-                  lambdatrack::CosPA,
-                  lambdatrack::DcaDau,
-                  lambdatrack::V0Type,
-                  lambdatrack::V0PrmScd,
-                  lambdatrack::CorrFact);
+                  lambdatrack::LambdaCollisionId, lambdatrack::Px,
+                  lambdatrack::Py, lambdatrack::Pz, lambdatrack::Pt,
+                  lambdatrack::Eta, lambdatrack::Phi, lambdatrack::Rap,
+                  lambdatrack::Mass, lambdatrack::PrPx, lambdatrack::PrPy,
+                  lambdatrack::PrPz, lambdatrack::PosTrackId,
+                  lambdatrack::NegTrackId, lambdatrack::CosPA,
+                  lambdatrack::DcaDau, lambdatrack::V0Type,
+                  lambdatrack::V0PrmScd, lambdatrack::CorrFact);
 using LambdaTrack = LambdaTracks::iterator;
 
 namespace lambdatrackext
 {
 DECLARE_SOA_COLUMN(LambdaSharingDaughter, lambdaSharingDaughter, bool);
-DECLARE_SOA_COLUMN(LambdaSharingDauIds, lambdaSharingDauIds, std::vector<int64_t>);
+DECLARE_SOA_COLUMN(LambdaSharingDauIds, lambdaSharingDauIds,
+                   std::vector<int64_t>);
 DECLARE_SOA_COLUMN(TrueLambdaFlag, trueLambdaFlag, bool);
 } // namespace lambdatrackext
 
@@ -157,24 +141,13 @@ DECLARE_SOA_INDEX_COLUMN(LambdaMcGenCollision, lambdaMcGenCollision);
 }
 DECLARE_SOA_TABLE(LambdaMcGenTracks, "AOD", "LMCGENTRACKS", o2::soa::Index<>,
                   lambdamcgentrack::LambdaMcGenCollisionId,
-                  o2::aod::mcparticle::Px,
-                  o2::aod::mcparticle::Py,
-                  o2::aod::mcparticle::Pz,
-                  lambdatrack::Pt,
-                  lambdatrack::Eta,
-                  lambdatrack::Phi,
-                  lambdatrack::Rap,
-                  lambdatrack::Mass,
-                  lambdatrack::PrPx,
-                  lambdatrack::PrPy,
-                  lambdatrack::PrPz,
-                  lambdatrack::PosTrackId,
-                  lambdatrack::NegTrackId,
-                  lambdatrack::V0Type,
-                  lambdatrack::CosPA,
-                  lambdatrack::DcaDau,
-                  lambdatrack::V0PrmScd,
-                  lambdatrack::CorrFact);
+                  o2::aod::mcparticle::Px, o2::aod::mcparticle::Py,
+                  o2::aod::mcparticle::Pz, lambdatrack::Pt, lambdatrack::Eta,
+                  lambdatrack::Phi, lambdatrack::Rap, lambdatrack::Mass,
+                  lambdatrack::PrPx, lambdatrack::PrPy, lambdatrack::PrPz,
+                  lambdatrack::PosTrackId, lambdatrack::NegTrackId,
+                  lambdatrack::V0Type, lambdatrack::CosPA, lambdatrack::DcaDau,
+                  lambdatrack::V0PrmScd, lambdatrack::CorrFact);
 using LambdaMcGenTrack = LambdaMcGenTracks::iterator;
 
 namespace lambdamixeventcollision
@@ -182,44 +155,57 @@ namespace lambdamixeventcollision
 DECLARE_SOA_COLUMN(CollisionIndex, collisionIndex, int);
 } // namespace lambdamixeventcollision
 
-DECLARE_SOA_TABLE(LambdaMixEventCollisions, "AOD", "LAMBDAMIXCOLS", o2::soa::Index<>,
-                  lambdamixeventcollision::CollisionIndex,
-                  lambdacollision::Cent,
-                  aod::collision::PosZ,
+DECLARE_SOA_TABLE(LambdaMixEventCollisions, "AOD", "LAMBDAMIXCOLS",
+                  o2::soa::Index<>, lambdamixeventcollision::CollisionIndex,
+                  lambdacollision::Cent, aod::collision::PosZ,
                   lambdacollision::TimeStamp);
 using LambdaMixEventCollision = LambdaMixEventCollisions::iterator;
 
+namespace lambdamixeventmcgencollision
+{
+}
+DECLARE_SOA_TABLE(LambdaMixEventMcGenCollisions, "AOD", "LAMBDAMIXMGCOLS",
+                  o2::soa::Index<>, lambdamixeventcollision::CollisionIndex,
+                  lambdacollision::Cent, aod::collision::PosZ,
+                  lambdacollision::TimeStamp);
+using LambdaMixEventMcGenCollision = LambdaMixEventMcGenCollisions::iterator;
+
 namespace lambdamixeventtracks
 {
 // DECLARE_SOA_INDEX_COLUMN(LambdaMixEventCollision, lambdaMixEventCollision);
 DECLARE_SOA_COLUMN(LambdaMixEventCollisionIdx, lambdaMixEventCollisionIdx, int);
 DECLARE_SOA_COLUMN(LambdaMixEventTrackIdx, lambdaMixEventTrackIdx, int);
 DECLARE_SOA_COLUMN(LambdaMixEventTimeStamp, lambdaMixEventTimeStamp, uint64_t);
-
 } // namespace lambdamixeventtracks
 
-DECLARE_SOA_TABLE(LambdaMixEventTracks, "AOD", "LAMBDAMIXTRKS", o2::soa::Index<>,
+DECLARE_SOA_TABLE(LambdaMixEventTracks, "AOD", "LAMBDAMIXTRKS",
+                  o2::soa::Index<>,
                   // lambdamixeventtracks::LambdaMixEventCollisionId,
                   lambdamixeventtracks::LambdaMixEventCollisionIdx,
-                  lambdamixeventtracks::LambdaMixEventTrackIdx,
-                  lambdatrack::Px,
-                  lambdatrack::Py,
-                  lambdatrack::Pz,
-                  lambdatrack::Mass,
-                  lambdatrack::PrPx,
-                  lambdatrack::PrPy,
-                  lambdatrack::PrPz,
+                  lambdamixeventtracks::LambdaMixEventTrackIdx, lambdatrack::Px,
+                  lambdatrack::Py, lambdatrack::Pz, lambdatrack::Mass,
+                  lambdatrack::PrPx, lambdatrack::PrPy, lambdatrack::PrPz,
                   lambdatrack::V0Type,
                   lambdamixeventtracks::LambdaMixEventTimeStamp);
-
 using LambdaMixEventTrack = LambdaMixEventTracks::iterator;
+
+namespace lambdamixeventmcgentracks
+{
+}
+DECLARE_SOA_TABLE(LambdaMixEventMcGenTracks, "AOD", "LAMBDAMIXMGTRKS",
+                  o2::soa::Index<>,
+                  lambdamixeventtracks::LambdaMixEventCollisionIdx,
+                  lambdamixeventtracks::LambdaMixEventTrackIdx, lambdatrack::Px,
+                  lambdatrack::Py, lambdatrack::Pz, lambdatrack::Mass,
+                  lambdatrack::PrPx, lambdatrack::PrPy, lambdatrack::PrPz,
+                  lambdatrack::V0Type,
+                  lambdamixeventtracks::LambdaMixEventTimeStamp);
+using LambdaMixEventMcGenTrack = LambdaMixEventMcGenTracks::iterator;
 } // namespace o2::aod
 
-enum CollisionLabels {
-  kTotColBeforeHasMcCollision = 1,
-  kTotCol,
-  kPassSelCol
-};
+enum CollisionLabels { kTotColBeforeHasMcCollision = 1,
+                       kTotCol,
+                       kPassSelCol };
 
 enum TrackLabels {
   kTracksBeforeHasMcParticle = 1,
@@ -250,20 +236,14 @@ enum TrackLabels {
   kGenLambdaToPrPi
 };
 
-enum CentEstType {
-  kCentFT0M = 0,
-  kCentFT0C
-};
+enum CentEstType { kCentFT0M = 0,
+                   kCentFT0C };
 
-enum RunType {
-  kRun3 = 0,
-  kRun2
-};
+enum RunType { kRun3 = 0,
+               kRun2 };
 
-enum ParticleType {
-  kLambda = 0,
-  kAntiLambda
-};
+enum ParticleType { kLambda = 0,
+                    kAntiLambda };
 
 enum ParticlePairType {
 
@@ -283,38 +263,29 @@ enum ParticlePairType {
   kAntiLambdaSBSBAntiLambda = 11
 };
 
-enum ShareDauLambda {
-  kUniqueLambda = 0,
-  kLambdaShareDau
-};
+enum ShareDauLambda { kUniqueLambda = 0,
+                      kLambdaShareDau };
 
-enum RecGenType {
-  kRec = 0,
-  kGen
-};
+enum RecGenType { kRec = 0,
+                  kGen };
 
-enum DMCType {
-  kData = 0,
-  kMC
-};
+enum DMCType { kData = 0,
+               kMC };
 
-enum CorrHistDim {
-  OneDimCorr = 1,
-  TwoDimCorr,
-  ThreeDimCorr
-};
+enum CorrHistDim { OneDimCorr = 1,
+                   TwoDimCorr,
+                   ThreeDimCorr };
 
-enum PrmScdType {
-  kPrimary = 0,
-  kSecondary
-};
+enum PrmScdType { kPrimary = 0,
+                  kSecondary };
 
-enum PrmScdPairType {
-  kPP = 0,
-  kPS,
-  kSP,
-  kSS
-};
+enum PrmScdPairType { kPP = 0,
+                      kPS,
+                      kSP,
+                      kSS };
+
+// Number of daughters of the two-body decay Lambda -> p + pi
+static constexpr std::size_t NDaughtersTwoBody = 2;
 
 struct LambdaTableProducer {
 
@@ -323,7 +294,8 @@ struct LambdaTableProducer {
   Produces<aod::LambdaMcGenCollisions> lambdaMCGenCollisionTable;
   Produces<aod::LambdaMcGenTracks> lambdaMCGenTrackTable;
 
-  Configurable<int> cCentEstimator{"cCentEstimator", 0, "Centrality Estimator: 0=FT0M, 1=FT0C"};
+  Configurable<int> cCentEstimator{"cCentEstimator", 0,
+                                   "Centrality Estimator: 0=FT0M, 1=FT0C"};
   Configurable<float> cMinZVtx{"cMinZVtx", -10.0, "Min VtxZ (cm)"};
   Configurable<float> cMaxZVtx{"cMaxZVtx", 10.0, "Max VtxZ (cm)"};
   Configurable<float> cMinMult{"cMinMult", 0.0, "Min centrality percentile"};
@@ -331,38 +303,58 @@ struct LambdaTableProducer {
   Configurable<bool> cSel8Trig{"cSel8Trig", true, "Sel8 (T0A+T0C) Run3"};
   Configurable<bool> cInt7Trig{"cInt7Trig", false, "kINT7 MB Trigger"};
   Configurable<bool> cSel7Trig{"cSel7Trig", false, "Sel7 (V0A+V0C) Run2"};
-  Configurable<bool> cTriggerTvxSel{"cTriggerTvxSel", false, "TVX Trigger Selection"};
-  Configurable<bool> cTFBorder{"cTFBorder", false, "Timeframe Border Selection"};
-  Configurable<bool> cNoItsROBorder{"cNoItsROBorder", false, "No ITSRO Border Cut"};
-  Configurable<bool> cItsTpcVtx{"cItsTpcVtx", false, "ITS+TPC Vertex Selection"};
+  Configurable<bool> cTriggerTvxSel{"cTriggerTvxSel", false,
+                                    "TVX Trigger Selection"};
+  Configurable<bool> cTFBorder{"cTFBorder", false,
+                               "Timeframe Border Selection"};
+  Configurable<bool> cNoItsROBorder{"cNoItsROBorder", false,
+                                    "No ITSRO Border Cut"};
+  Configurable<bool> cItsTpcVtx{"cItsTpcVtx", false,
+                                "ITS+TPC Vertex Selection"};
   Configurable<bool> cPileupReject{"cPileupReject", false, "Pileup rejection"};
-  Configurable<bool> cZVtxTimeDiff{"cZVtxTimeDiff", false, "z-vtx time diff selection"};
-  Configurable<bool> cIsGoodITSLayers{"cIsGoodITSLayers", false, "Good ITS Layers All"};
+  Configurable<bool> cZVtxTimeDiff{"cZVtxTimeDiff", false,
+                                   "z-vtx time diff selection"};
+  Configurable<bool> cIsGoodITSLayers{"cIsGoodITSLayers", false,
+                                      "Good ITS Layers All"};
 
   // Tracks
   Configurable<float> cTrackMinPt{"cTrackMinPt", 0.15, "p_{T} minimum"};
   Configurable<float> cTrackMaxPt{"cTrackMaxPt", 999.0, "p_{T} maximum"};
   Configurable<float> cTrackEtaCut{"cTrackEtaCut", 0.8, "Pseudorapidity cut"};
-  Configurable<int> cMinTpcCrossedRows{"cMinTpcCrossedRows", 70, "TPC Min Crossed Rows"};
-  Configurable<float> cMinTpcCROverCls{"cMinTpcCROverCls", 0.8, "TPC Min CR/Findable Cls"};
-  Configurable<float> cMaxTpcSharedClusters{"cMaxTpcSharedClusters", 0.4, "TPC Max Shared Clusters"};
+  Configurable<int> cMinTpcCrossedRows{"cMinTpcCrossedRows", 70,
+                                       "TPC Min Crossed Rows"};
+  Configurable<float> cMinTpcCROverCls{"cMinTpcCROverCls", 0.8,
+                                       "TPC Min CR/Findable Cls"};
+  Configurable<float> cMaxTpcSharedClusters{"cMaxTpcSharedClusters", 0.4,
+                                            "TPC Max Shared Clusters"};
   Configurable<float> cMaxChi2Tpc{"cMaxChi2Tpc", 4, "Max TPC Chi2/ndf"};
-  Configurable<double> cTpcNsigmaCut{"cTpcNsigmaCut", 3.0, "TPC nSigma PID cut"};
-  Configurable<bool> cRemoveAmbiguousTracks{"cRemoveAmbiguousTracks", false, "Remove Ambiguous Tracks"};
-
-  Configurable<double> cMinDcaProtonToPV{"cMinDcaProtonToPV", 0.02, "Min proton DCA to PV (cm)"};
-  Configurable<double> cMinDcaPionToPV{"cMinDcaPionToPV", 0.06, "Min pion DCA to PV (cm)"};
-  Configurable<double> cMinV0DcaDaughters{"cMinV0DcaDaughters", 0., "Min DCA between V0 daughters"};
-  Configurable<double> cMaxV0DcaDaughters{"cMaxV0DcaDaughters", 1., "Max DCA between V0 daughters"};
+  Configurable<double> cTpcNsigmaCut{"cTpcNsigmaCut", 3.0,
+                                     "TPC nSigma PID cut"};
+  Configurable<bool> cRemoveAmbiguousTracks{"cRemoveAmbiguousTracks", false,
+                                            "Remove Ambiguous Tracks"};
+
+  Configurable<double> cMinDcaProtonToPV{"cMinDcaProtonToPV", 0.02,
+                                         "Min proton DCA to PV (cm)"};
+  Configurable<double> cMinDcaPionToPV{"cMinDcaPionToPV", 0.06,
+                                       "Min pion DCA to PV (cm)"};
+  Configurable<double> cMinV0DcaDaughters{"cMinV0DcaDaughters", 0.,
+                                          "Min DCA between V0 daughters"};
+  Configurable<double> cMaxV0DcaDaughters{"cMaxV0DcaDaughters", 1.,
+                                          "Max DCA between V0 daughters"};
   Configurable<double> cMinDcaV0ToPV{"cMinDcaV0ToPV", 0.0, "Min DCA V0 to PV"};
-  Configurable<double> cMaxDcaV0ToPV{"cMaxDcaV0ToPV", 999.0, "Max DCA V0 to PV"};
-  Configurable<double> cMinV0TransRadius{"cMinV0TransRadius", 0.5, "Min V0 decay radius (cm)"};
-  Configurable<double> cMaxV0TransRadius{"cMaxV0TransRadius", 999.0, "Max V0 decay radius (cm)"};
+  Configurable<double> cMaxDcaV0ToPV{"cMaxDcaV0ToPV", 999.0,
+                                     "Max DCA V0 to PV"};
+  Configurable<double> cMinV0TransRadius{"cMinV0TransRadius", 0.5,
+                                         "Min V0 decay radius (cm)"};
+  Configurable<double> cMaxV0TransRadius{"cMaxV0TransRadius", 999.0,
+                                         "Max V0 decay radius (cm)"};
   Configurable<double> cMinV0CTau{"cMinV0CTau", 0.0, "Min cTau (cm)"};
   Configurable<double> cMaxV0CTau{"cMaxV0CTau", 30.0, "Max cTau (cm)"};
   Configurable<double> cMinV0CosPA{"cMinV0CosPA", 0.995, "Min V0 cos(PA)"};
-  Configurable<double> cKshortRejMassWindow{"cKshortRejMassWindow", 0.01, "K0s mass rejection window"};
-  Configurable<bool> cKshortRejFlag{"cKshortRejFlag", true, "K0s mass rejection flag"};
+  Configurable<double> cKshortRejMassWindow{"cKshortRejMassWindow", 0.01,
+                                            "K0s mass rejection window"};
+  Configurable<bool> cKshortRejFlag{"cKshortRejFlag", true,
+                                    "K0s mass rejection flag"};
 
   // V0s kinmatic acceptance
   Configurable<float> cMinV0Mass{"cMinV0Mass", 1.10, "V0 Mass Min"};
@@ -371,25 +363,38 @@ struct LambdaTableProducer {
   Configurable<float> cMaxV0Pt{"cMaxV0Pt", 4.2, "Minimum V0 pT"};
   Configurable<float> cMaxV0Rap{"cMaxV0Rap", 0.5, "|rap| cut"};
   Configurable<bool> cDoEtaAnalysis{"cDoEtaAnalysis", false, "Do Eta Analysis"};
-  Configurable<bool> cV0TypeSelFlag{"cV0TypeSelFlag", false, "V0 Type Selection Flag"};
-  Configurable<int> cV0TypeSelection{"cV0TypeSelection", 1, "V0 Type Selection"};
+  Configurable<bool> cV0TypeSelFlag{"cV0TypeSelFlag", false,
+                                    "V0 Type Selection Flag"};
+  Configurable<int> cV0TypeSelection{"cV0TypeSelection", 1,
+                                     "V0 Type Selection"};
 
   // V0s MC
   Configurable<bool> cHasMcFlag{"cHasMcFlag", true, "Has Mc Tag"};
-  Configurable<bool> cSelectTrueLambda{"cSelectTrueLambda", true, "Select True Lambda"};
-  Configurable<bool> cSelMCPSV0{"cSelMCPSV0", true, "Select Primary/Secondary V0"};
-  Configurable<bool> cCheckRecoDauFlag{"cCheckRecoDauFlag", true, "Check for reco daughter PID"};
-  Configurable<bool> cGenPrimaryLambda{"cGenPrimaryLambda", true, "Primary Generated Lambda"};
-  Configurable<bool> cGenSecondaryLambda{"cGenSecondaryLambda", false, "Secondary Generated Lambda"};
-  Configurable<bool> cGenDecayChannel{"cGenDecayChannel", true, "Gen Level Decay Channel Flag"};
+  Configurable<bool> cSelectTrueLambda{"cSelectTrueLambda", true,
+                                       "Select True Lambda"};
+  Configurable<bool> cSelMCPSV0{"cSelMCPSV0", true,
+                                "Select Primary/Secondary V0"};
+  Configurable<bool> cCheckRecoDauFlag{"cCheckRecoDauFlag", true,
+                                       "Check for reco daughter PID"};
+  Configurable<bool> cGenPrimaryLambda{"cGenPrimaryLambda", true,
+                                       "Primary Generated Lambda"};
+  Configurable<bool> cGenSecondaryLambda{"cGenSecondaryLambda", false,
+                                         "Secondary Generated Lambda"};
+  Configurable<bool> cGenDecayChannel{"cGenDecayChannel", true,
+                                      "Gen Level Decay Channel Flag"};
   Configurable<bool> cRecoMomResoFlag{"cRecoMomResoFlag", false, "Check effect of momentum space smearing on balance function"};
 
   // Efficiency Correction
-  Configurable<bool> cCorrectionFlag{"cCorrectionFlag", false, "Correction Flag"};
-  Configurable<bool> cGetEffFact{"cGetEffFact", false, "Get Efficiency Factor Flag"};
-  Configurable<bool> cGetPrimFrac{"cGetPrimFrac", false, "Get Primary Fraction Flag"};
-  Configurable<int> cCorrFactHist{"cCorrFactHist", 0, "Efficiency Factor Histogram"};
-  Configurable<int> cPrimFracHist{"cPrimFracHist", 0, "Primary Fraction Histogram"};
+  Configurable<bool> cCorrectionFlag{"cCorrectionFlag", false,
+                                     "Correction Flag"};
+  Configurable<bool> cGetEffFact{"cGetEffFact", false,
+                                 "Get Efficiency Factor Flag"};
+  Configurable<bool> cGetPrimFrac{"cGetPrimFrac", false,
+                                  "Get Primary Fraction Flag"};
+  Configurable<int> cCorrFactHist{"cCorrFactHist", 0,
+                                  "Efficiency Factor Histogram"};
+  Configurable<int> cPrimFracHist{"cPrimFracHist", 0,
+                                  "Primary Fraction Histogram"};
 
   // CCDB
   Configurable<std::string> cUrlCCDB{"cUrlCCDB", "http://ccdb-test.cern.ch:8080", "url of ccdb"};
@@ -399,17 +404,22 @@ struct LambdaTableProducer {
   Service<o2::ccdb::BasicCCDBManager> ccdb{};
 
   // Histogram Registry.
-  HistogramRegistry histos{"histos", {}, OutputObjHandlingPolicy::AnalysisObject};
+  HistogramRegistry histos{
+    "histos",
+    {},
+    OutputObjHandlingPolicy::AnalysisObject};
 
   // initialize corr_factor objects
-  std::vector<std::vector<std::string>> vCorrFactStrings = {{"hEffVsPtCentLambda", "hEffVsPtCentAntiLambda"},
-                                                            {"hEffVsPtYCentLambda", "hEffVsPtYCentAntiLambda"},
-                                                            {"hEffVsPtEtaCentLambda", "hEffVsPtEtaCentAntiLambda"}};
+  std::vector<std::vector<std::string>> vCorrFactStrings = {
+    {"hEffVsPtCentLambda", "hEffVsPtCentAntiLambda"},
+    {"hEffVsPtYCentLambda", "hEffVsPtYCentAntiLambda"},
+    {"hEffVsPtEtaCentLambda", "hEffVsPtEtaCentAntiLambda"}};
 
   // initialize corr_factor objects
-  std::vector<std::vector<std::string>> vPrimFracStrings = {{"hPrimFracVsPtCentLambda", "hPrimFracVsPtCentAntiLambda"},
-                                                            {"hPrimFracVsPtYCentLambda", "hPrimFracVsPtYCentAntiLambda"},
-                                                            {"hPrimFracVsPtEtaCentLambda", "hPrimFracVsPtEtaCentAntiLambda"}};
+  std::vector<std::vector<std::string>> vPrimFracStrings = {
+    {"hPrimFracVsPtCentLambda", "hPrimFracVsPtCentAntiLambda"},
+    {"hPrimFracVsPtYCentLambda", "hPrimFracVsPtYCentAntiLambda"},
+    {"hPrimFracVsPtEtaCentLambda", "hPrimFracVsPtEtaCentAntiLambda"}};
 
   // Initialize Global Variables
   float cent = 0., mult = 0.;
@@ -450,38 +460,65 @@ struct LambdaTableProducer {
 
     // Create Histograms.
     // Event histograms
-    histos.add("Events/h1f_collisions_info", "# of Collisions", kTH1F, {axisCols});
-    histos.add("Events/h1f_collision_posZ", "V_{z}-distribution", kTH1F, {axisVz});
+    histos.add("Events/h1f_collisions_info", "# of Collisions", kTH1F,
+               {axisCols});
+    histos.add("Events/h1f_collision_posZ", "V_{z}-distribution", kTH1F,
+               {axisVz});
 
     histos.add("Tracks/h1f_tracks_info", "# of tracks", kTH1F, {axisTrks});
-    histos.add("Tracks/h2f_armpod_before_sel", "Armenteros-Podolanski (before)", kTH2F, {axisAlpha, axisQtarm});
-    histos.add("Tracks/h2f_armpod_after_sel", "Armenteros-Podolanski (after)", kTH2F, {axisAlpha, axisQtarm});
-    histos.add("Tracks/h1f_lambda_pt_vs_invm", "p_{T} vs M_{#Lambda}", kTH2F, {axisV0Mass, axisV0Pt});
-    histos.add("Tracks/h1f_antilambda_pt_vs_invm", "p_{T} vs M_{#bar{#Lambda}}", kTH2F, {axisV0Mass, axisV0Pt});
-
-    histos.add("QA/Lambda/h2f_qt_vs_alpha", "Armenteros-Podolanski", kTH2F, {axisAlpha, axisQtarm});
-    histos.add("QA/Lambda/h1f_dca_V0_daughters", "DCA V0 daughters", kTH1F, {axisDcaDau});
-    histos.add("QA/Lambda/h1f_dca_pos_to_PV", "DCA pos-prong to PV", kTH1F, {axisDcaProngPV});
-    histos.add("QA/Lambda/h1f_dca_neg_to_PV", "DCA neg-prong to PV", kTH1F, {axisDcaProngPV});
-    histos.add("QA/Lambda/h1f_dca_V0_to_PV", "DCA V0 to PV", kTH1F, {axisDcaV0PV});
-    histos.add("QA/Lambda/h1f_V0_cospa", "cos(#theta_{PA})", kTH1F, {axisCosPA});
-    histos.add("QA/Lambda/h1f_V0_radius", "V0 decay radius", kTH1F, {axisRadius});
+    histos.add("Tracks/h2f_armpod_before_sel", "Armenteros-Podolanski (before)",
+               kTH2F, {axisAlpha, axisQtarm});
+    histos.add("Tracks/h2f_armpod_after_sel", "Armenteros-Podolanski (after)",
+               kTH2F, {axisAlpha, axisQtarm});
+    histos.add("Tracks/h1f_lambda_pt_vs_invm", "p_{T} vs M_{#Lambda}", kTH2F,
+               {axisV0Mass, axisV0Pt});
+    histos.add("Tracks/h1f_antilambda_pt_vs_invm", "p_{T} vs M_{#bar{#Lambda}}",
+               kTH2F, {axisV0Mass, axisV0Pt});
+
+    histos.add("QA/Lambda/h2f_qt_vs_alpha", "Armenteros-Podolanski", kTH2F,
+               {axisAlpha, axisQtarm});
+    histos.add("QA/Lambda/h1f_dca_V0_daughters", "DCA V0 daughters", kTH1F,
+               {axisDcaDau});
+    histos.add("QA/Lambda/h1f_dca_pos_to_PV", "DCA pos-prong to PV", kTH1F,
+               {axisDcaProngPV});
+    histos.add("QA/Lambda/h1f_dca_neg_to_PV", "DCA neg-prong to PV", kTH1F,
+               {axisDcaProngPV});
+    histos.add("QA/Lambda/h1f_dca_V0_to_PV", "DCA V0 to PV", kTH1F,
+               {axisDcaV0PV});
+    histos.add("QA/Lambda/h1f_V0_cospa", "cos(#theta_{PA})", kTH1F,
+               {axisCosPA});
+    histos.add("QA/Lambda/h1f_V0_radius", "V0 decay radius", kTH1F,
+               {axisRadius});
     histos.add("QA/Lambda/h1f_V0_ctau", "c#tau", kTH1F, {axisCTau});
     histos.add("QA/Lambda/h1f_V0_gctau", "#gammac#tau", kTH1F, {axisGCTau});
-    histos.add("QA/Lambda/h1f_pos_prong_pt", "Pos-prong p_{T}", kTH1F, {axisTrackPt});
-    histos.add("QA/Lambda/h1f_neg_prong_pt", "Neg-prong p_{T}", kTH1F, {axisTrackPt});
-    histos.add("QA/Lambda/h1f_pos_prong_eta", "Pos-prong #eta", kTH1F, {axisV0Eta});
-    histos.add("QA/Lambda/h1f_neg_prong_eta", "Neg-prong #eta", kTH1F, {axisV0Eta});
-    histos.add("QA/Lambda/h1f_pos_prong_phi", "Pos-prong #phi", kTH1F, {axisV0Phi});
-    histos.add("QA/Lambda/h1f_neg_prong_phi", "Neg-prong #phi", kTH1F, {axisV0Phi});
-    histos.add("QA/Lambda/h2f_pos_prong_dcaXY_vs_pt", "DCA vs p_{T}", kTH2F, {axisTrackPt, axisTrackDCA});
-    histos.add("QA/Lambda/h2f_neg_prong_dcaXY_vs_pt", "DCA vs p_{T}", kTH2F, {axisTrackPt, axisTrackDCA});
-    histos.add("QA/Lambda/h2f_pos_prong_dEdx_vs_p", "TPC dE/dx pos", kTH2F, {axisMomPID, axisdEdx});
-    histos.add("QA/Lambda/h2f_neg_prong_dEdx_vs_p", "TPC dE/dx neg", kTH2F, {axisMomPID, axisdEdx});
-    histos.add("QA/Lambda/h2f_pos_prong_tpc_nsigma_pr_vs_p", "TPC n#sigma_{p} pos", kTH2F, {axisMomPID, axisNsigma});
-    histos.add("QA/Lambda/h2f_neg_prong_tpc_nsigma_pr_vs_p", "TPC n#sigma_{p} neg", kTH2F, {axisMomPID, axisNsigma});
-    histos.add("QA/Lambda/h2f_pos_prong_tpc_nsigma_pi_vs_p", "TPC n#sigma_{#pi} pos", kTH2F, {axisMomPID, axisNsigma});
-    histos.add("QA/Lambda/h2f_neg_prong_tpc_nsigma_pi_vs_p", "TPC n#sigma_{#pi} neg", kTH2F, {axisMomPID, axisNsigma});
+    histos.add("QA/Lambda/h1f_pos_prong_pt", "Pos-prong p_{T}", kTH1F,
+               {axisTrackPt});
+    histos.add("QA/Lambda/h1f_neg_prong_pt", "Neg-prong p_{T}", kTH1F,
+               {axisTrackPt});
+    histos.add("QA/Lambda/h1f_pos_prong_eta", "Pos-prong #eta", kTH1F,
+               {axisV0Eta});
+    histos.add("QA/Lambda/h1f_neg_prong_eta", "Neg-prong #eta", kTH1F,
+               {axisV0Eta});
+    histos.add("QA/Lambda/h1f_pos_prong_phi", "Pos-prong #phi", kTH1F,
+               {axisV0Phi});
+    histos.add("QA/Lambda/h1f_neg_prong_phi", "Neg-prong #phi", kTH1F,
+               {axisV0Phi});
+    histos.add("QA/Lambda/h2f_pos_prong_dcaXY_vs_pt", "DCA vs p_{T}", kTH2F,
+               {axisTrackPt, axisTrackDCA});
+    histos.add("QA/Lambda/h2f_neg_prong_dcaXY_vs_pt", "DCA vs p_{T}", kTH2F,
+               {axisTrackPt, axisTrackDCA});
+    histos.add("QA/Lambda/h2f_pos_prong_dEdx_vs_p", "TPC dE/dx pos", kTH2F,
+               {axisMomPID, axisdEdx});
+    histos.add("QA/Lambda/h2f_neg_prong_dEdx_vs_p", "TPC dE/dx neg", kTH2F,
+               {axisMomPID, axisdEdx});
+    histos.add("QA/Lambda/h2f_pos_prong_tpc_nsigma_pr_vs_p",
+               "TPC n#sigma_{p} pos", kTH2F, {axisMomPID, axisNsigma});
+    histos.add("QA/Lambda/h2f_neg_prong_tpc_nsigma_pr_vs_p",
+               "TPC n#sigma_{p} neg", kTH2F, {axisMomPID, axisNsigma});
+    histos.add("QA/Lambda/h2f_pos_prong_tpc_nsigma_pi_vs_p",
+               "TPC n#sigma_{#pi} pos", kTH2F, {axisMomPID, axisNsigma});
+    histos.add("QA/Lambda/h2f_neg_prong_tpc_nsigma_pi_vs_p",
+               "TPC n#sigma_{#pi} neg", kTH2F, {axisMomPID, axisNsigma});
 
     histos.add("McRec/Lambda/hPt", "p_{T}", kTH1F, {axisV0Pt});
     histos.add("McRec/Lambda/hEta", "#eta", kTH1F, {axisV0Eta});
@@ -492,21 +529,31 @@ struct LambdaTableProducer {
     histos.addClone("QA/Lambda/", "QA/AntiLambda/");
     histos.addClone("McRec/Lambda/", "McRec/AntiLambda/");
 
-    if (doprocessMCRun3 || doprocessMCRun2) {
-      histos.add("Tracks/h2f_tracks_pid_before_sel", "PIDs before sel", kTH2F, {axisPID, axisV0Pt});
-      histos.add("Tracks/h2f_tracks_pid_after_sel", "PIDs after sel", kTH2F, {axisPID, axisV0Pt});
-      histos.add("Tracks/h2f_lambda_mothers_pdg", "Lambda mothers", kTH2F, {axisPID, axisV0Pt});
-
-      histos.add("McGen/h1f_collision_recgen", "RecGen collisions", kTH1F, {axisMult});
-      histos.add("McGen/h1f_collisions_info", "Collisions info", kTH1F, {axisCols});
-      histos.add("McGen/h2f_collision_posZ", "V_{z} rec vs gen", kTH2F, {axisVz, axisVz});
-      histos.add("McGen/h2f_collision_cent", "Centrality rec vs gen", kTH2F, {axisCent, axisCent});
-      histos.add("McGen/h1f_lambda_daughter_PDG", "Lambda dau PDG", kTH1F, {axisPID});
-      histos.add("McGen/h1f_antilambda_daughter_PDG", "AntiLambda dau PDG", kTH1F, {axisPID});
+    if (doprocessMCRun3) {
+      histos.add("Tracks/h2f_tracks_pid_before_sel", "PIDs before sel", kTH2F,
+                 {axisPID, axisV0Pt});
+      histos.add("Tracks/h2f_tracks_pid_after_sel", "PIDs after sel", kTH2F,
+                 {axisPID, axisV0Pt});
+      histos.add("Tracks/h2f_lambda_mothers_pdg", "Lambda mothers", kTH2F,
+                 {axisPID, axisV0Pt});
+
+      histos.add("McGen/h1f_collision_recgen", "RecGen collisions", kTH1F,
+                 {axisMult});
+      histos.add("McGen/h1f_collisions_info", "Collisions info", kTH1F,
+                 {axisCols});
+      histos.add("McGen/h2f_collision_posZ", "V_{z} rec vs gen", kTH2F,
+                 {axisVz, axisVz});
+      histos.add("McGen/h2f_collision_cent", "Centrality rec vs gen", kTH2F,
+                 {axisCent, axisCent});
+      histos.add("McGen/h1f_lambda_daughter_PDG", "Lambda dau PDG", kTH1F,
+                 {axisPID});
+      histos.add("McGen/h1f_antilambda_daughter_PDG", "AntiLambda dau PDG",
+                 kTH1F, {axisPID});
 
       histos.addClone("McRec/", "McGen/");
 
-      histos.add("McGen/Lambda/Proton/hPt", "Proton p_{T}", kTH1F, {axisTrackPt});
+      histos.add("McGen/Lambda/Proton/hPt", "Proton p_{T}", kTH1F,
+                 {axisTrackPt});
       histos.add("McGen/Lambda/Proton/hEta", "Proton #eta", kTH1F, {axisV0Eta});
       histos.add("McGen/Lambda/Proton/hRap", "Proton y", kTH1F, {axisV0Rap});
       histos.add("McGen/Lambda/Proton/hPhi", "Proton #phi", kTH1F, {axisV0Phi});
@@ -515,40 +562,110 @@ struct LambdaTableProducer {
       histos.addClone("McGen/Lambda/Pion/", "McGen/AntiLambda/Pion/");
 
       // set bin lables specific to MC
-      histos.get<TH1>(HIST("Events/h1f_collisions_info"))->GetXaxis()->SetBinLabel(CollisionLabels::kTotColBeforeHasMcCollision, "kTotColBeforeHasMcCollision");
-      histos.get<TH1>(HIST("McGen/h1f_collisions_info"))->GetXaxis()->SetBinLabel(CollisionLabels::kTotCol, "kTotCol");
-      histos.get<TH1>(HIST("McGen/h1f_collisions_info"))->GetXaxis()->SetBinLabel(CollisionLabels::kPassSelCol, "kPassSelCol");
-      histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kTracksBeforeHasMcParticle, "kTracksBeforeHasMcParticle");
-      histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kPrimaryLambda, "kPrimaryLambda");
-      histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kSecondaryLambda, "kSecondaryLambda");
-      histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kLambdaDauNotMcParticle, "kLambdaDauNotMcParticle");
-      histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kLambdaNotPrPiMinus, "kLambdaNotPrPiMinus");
-      histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kAntiLambdaNotAntiPrPiPlus, "kAntiLambdaNotAntiPrPiPlus");
-      histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kPassTrueLambdaSel, "kPassTrueLambdaSel");
-      histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kGenTotAccLambda, "kGenTotAccLambda");
-      histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kGenLambdaNoDau, "kGenLambdaNoDau");
-      histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kGenLambdaToPrPi, "kGenLambdaToPrPi");
+      histos.get<TH1>(HIST("Events/h1f_collisions_info"))
+        ->GetXaxis()
+        ->SetBinLabel(CollisionLabels::kTotColBeforeHasMcCollision,
+                      "kTotColBeforeHasMcCollision");
+      histos.get<TH1>(HIST("McGen/h1f_collisions_info"))
+        ->GetXaxis()
+        ->SetBinLabel(CollisionLabels::kTotCol, "kTotCol");
+      histos.get<TH1>(HIST("McGen/h1f_collisions_info"))
+        ->GetXaxis()
+        ->SetBinLabel(CollisionLabels::kPassSelCol, "kPassSelCol");
+      histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+        ->GetXaxis()
+        ->SetBinLabel(TrackLabels::kTracksBeforeHasMcParticle,
+                      "kTracksBeforeHasMcParticle");
+      histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+        ->GetXaxis()
+        ->SetBinLabel(TrackLabels::kPrimaryLambda, "kPrimaryLambda");
+      histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+        ->GetXaxis()
+        ->SetBinLabel(TrackLabels::kSecondaryLambda, "kSecondaryLambda");
+      histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+        ->GetXaxis()
+        ->SetBinLabel(TrackLabels::kLambdaDauNotMcParticle,
+                      "kLambdaDauNotMcParticle");
+      histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+        ->GetXaxis()
+        ->SetBinLabel(TrackLabels::kLambdaNotPrPiMinus,
+                      "kLambdaNotPrPiMinus");
+      histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+        ->GetXaxis()
+        ->SetBinLabel(TrackLabels::kAntiLambdaNotAntiPrPiPlus,
+                      "kAntiLambdaNotAntiPrPiPlus");
+      histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+        ->GetXaxis()
+        ->SetBinLabel(TrackLabels::kPassTrueLambdaSel, "kPassTrueLambdaSel");
+      histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+        ->GetXaxis()
+        ->SetBinLabel(TrackLabels::kGenTotAccLambda, "kGenTotAccLambda");
+      histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+        ->GetXaxis()
+        ->SetBinLabel(TrackLabels::kGenLambdaNoDau, "kGenLambdaNoDau");
+      histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+        ->GetXaxis()
+        ->SetBinLabel(TrackLabels::kGenLambdaToPrPi, "kGenLambdaToPrPi");
     }
 
     // set bin labels
-    histos.get<TH1>(HIST("Events/h1f_collisions_info"))->GetXaxis()->SetBinLabel(CollisionLabels::kTotCol, "kTotCol");
-    histos.get<TH1>(HIST("Events/h1f_collisions_info"))->GetXaxis()->SetBinLabel(CollisionLabels::kPassSelCol, "kPassSelCol");
-    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kAllV0Tracks, "kAllV0Tracks");
-    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kV0KShortMassRej, "kV0KShortMassRej");
-    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kNotLambdaNotAntiLambda, "kNotLambdaNotAntiLambda");
-    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kV0IsBothLambdaAntiLambda, "kV0IsBothLambdaAntiLambda");
-    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kNotLambdaAfterSel, "kNotLambdaAfterSel");
-    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kV0IsLambdaOrAntiLambda, "kV0IsLambdaOrAntiLambda");
-    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kPassV0DauTrackSel, "kPassV0DauTrackSel");
-    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kPassV0KinCuts, "kPassV0KinCuts");
-    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kPassV0TopoSel, "kPassV0TopoSel");
-    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kAllSelPassed, "kAllSelPassed");
-    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kEffCorrPtCent, "kEffCorrPtCent");
-    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kEffCorrPtRapCent, "kEffCorrPtRapCent");
-    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kNoEffCorr, "kNoEffCorr");
-    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kPFCorrPtCent, "kPFCorrPtCent");
-    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kPFCorrPtRapCent, "kPFCorrPtRapCent");
-    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))->GetXaxis()->SetBinLabel(TrackLabels::kNoPFCorr, "kNoPFCorr");
+    histos.get<TH1>(HIST("Events/h1f_collisions_info"))
+      ->GetXaxis()
+      ->SetBinLabel(CollisionLabels::kTotCol, "kTotCol");
+    histos.get<TH1>(HIST("Events/h1f_collisions_info"))
+      ->GetXaxis()
+      ->SetBinLabel(CollisionLabels::kPassSelCol, "kPassSelCol");
+    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+      ->GetXaxis()
+      ->SetBinLabel(TrackLabels::kAllV0Tracks, "kAllV0Tracks");
+    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+      ->GetXaxis()
+      ->SetBinLabel(TrackLabels::kV0KShortMassRej, "kV0KShortMassRej");
+    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+      ->GetXaxis()
+      ->SetBinLabel(TrackLabels::kNotLambdaNotAntiLambda,
+                    "kNotLambdaNotAntiLambda");
+    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+      ->GetXaxis()
+      ->SetBinLabel(TrackLabels::kV0IsBothLambdaAntiLambda,
+                    "kV0IsBothLambdaAntiLambda");
+    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+      ->GetXaxis()
+      ->SetBinLabel(TrackLabels::kNotLambdaAfterSel, "kNotLambdaAfterSel");
+    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+      ->GetXaxis()
+      ->SetBinLabel(TrackLabels::kV0IsLambdaOrAntiLambda,
+                    "kV0IsLambdaOrAntiLambda");
+    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+      ->GetXaxis()
+      ->SetBinLabel(TrackLabels::kPassV0DauTrackSel, "kPassV0DauTrackSel");
+    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+      ->GetXaxis()
+      ->SetBinLabel(TrackLabels::kPassV0KinCuts, "kPassV0KinCuts");
+    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+      ->GetXaxis()
+      ->SetBinLabel(TrackLabels::kPassV0TopoSel, "kPassV0TopoSel");
+    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+      ->GetXaxis()
+      ->SetBinLabel(TrackLabels::kAllSelPassed, "kAllSelPassed");
+    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+      ->GetXaxis()
+      ->SetBinLabel(TrackLabels::kEffCorrPtCent, "kEffCorrPtCent");
+    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+      ->GetXaxis()
+      ->SetBinLabel(TrackLabels::kEffCorrPtRapCent, "kEffCorrPtRapCent");
+    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+      ->GetXaxis()
+      ->SetBinLabel(TrackLabels::kNoEffCorr, "kNoEffCorr");
+    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+      ->GetXaxis()
+      ->SetBinLabel(TrackLabels::kPFCorrPtCent, "kPFCorrPtCent");
+    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+      ->GetXaxis()
+      ->SetBinLabel(TrackLabels::kPFCorrPtRapCent, "kPFCorrPtRapCent");
+    histos.get<TH1>(HIST("Tracks/h1f_tracks_info"))
+      ->GetXaxis()
+      ->SetBinLabel(TrackLabels::kNoPFCorr, "kNoPFCorr");
   }
 
   template <RunType run, typename C>
@@ -598,7 +715,8 @@ struct LambdaTableProducer {
     if (cZVtxTimeDiff && !col.selection_bit(aod::evsel::kIsGoodZvtxFT0vsPV)) {
       return false;
     }
-    if (cIsGoodITSLayers && !col.selection_bit(aod::evsel::kIsGoodITSLayersAll)) {
+    if (cIsGoodITSLayers &&
+        !col.selection_bit(aod::evsel::kIsGoodITSLayersAll)) {
       return false;
     }
 
@@ -607,7 +725,8 @@ struct LambdaTableProducer {
   }
 
   // Kinematic Selection
-  bool kinCutSelection(float const& pt, float const& rap, float const& ptMin, float const& ptMax, float const& rapMax)
+  bool kinCutSelection(float const& pt, float const& rap, float const& ptMin,
+                       float const& ptMax, float const& rapMax)
   {
     return pt > ptMin && pt < ptMax && rap < rapMax;
   }
@@ -616,7 +735,8 @@ struct LambdaTableProducer {
   template <typename T>
   bool selTrack(T const& track)
   {
-    if (!kinCutSelection(track.pt(), std::abs(track.eta()), cTrackMinPt, cTrackMaxPt, cTrackEtaCut)) {
+    if (!kinCutSelection(track.pt(), std::abs(track.eta()), cTrackMinPt,
+                         cTrackMaxPt, cTrackEtaCut)) {
       return false;
     }
     if (track.tpcNClsCrossedRows() <= cMinTpcCrossedRows) {
@@ -644,7 +764,8 @@ struct LambdaTableProducer {
       return false;
     }
 
-    // Apply DCA Selection on Daughter Tracks Based on Lambda/AntiLambda daughters
+    // Apply DCA Selection on Daughter Tracks Based on Lambda/AntiLambda
+    // daughters
     float dcaProton = 0., dcaPion = 0.;
     if (v0Type == kLambda) {
       dcaProton = std::abs(v0.dcapostopv());
@@ -662,17 +783,20 @@ struct LambdaTableProducer {
   template <typename C, typename V, typename T>
   bool topoCutSelection(C const& col, V const& v0, T const&)
   {
-    if (v0.dcaV0daughters() <= cMinV0DcaDaughters || v0.dcaV0daughters() >= cMaxV0DcaDaughters) {
+    if (v0.dcaV0daughters() <= cMinV0DcaDaughters ||
+        v0.dcaV0daughters() >= cMaxV0DcaDaughters) {
       return false;
     }
     if (v0.dcav0topv() <= cMinDcaV0ToPV || v0.dcav0topv() >= cMaxDcaV0ToPV) {
       return false;
     }
-    if (v0.v0radius() <= cMinV0TransRadius || v0.v0radius() >= cMaxV0TransRadius) {
+    if (v0.v0radius() <= cMinV0TransRadius ||
+        v0.v0radius() >= cMaxV0TransRadius) {
       return false;
     }
 
-    float ctau = v0.distovertotmom(col.posX(), col.posY(), col.posZ()) * MassLambda0;
+    float ctau =
+      v0.distovertotmom(col.posX(), col.posY(), col.posZ()) * MassLambda0;
     if (ctau <= cMinV0CTau || ctau >= cMaxV0CTau) {
       return false;
     }
@@ -693,14 +817,16 @@ struct LambdaTableProducer {
       tpcNSigmaPr = negtrack.tpcNSigmaPr();
       tpcNSigmaPi = postrack.tpcNSigmaPi();
     }
-    return (std::abs(tpcNSigmaPr) < cTpcNsigmaCut && std::abs(tpcNSigmaPi) < cTpcNsigmaCut);
+    return (std::abs(tpcNSigmaPr) < cTpcNsigmaCut &&
+            std::abs(tpcNSigmaPi) < cTpcNsigmaCut);
   }
 
   template <typename V, typename T>
   bool selLambdaMassWindow(V const& v0, T const&, ParticleType& v0type)
   {
     // Kshort mass rejection hypothesis
-    if (cKshortRejFlag && (std::abs(v0.mK0Short() - MassK0Short) <= cKshortRejMassWindow)) {
+    if (cKshortRejFlag &&
+        (std::abs(v0.mK0Short() - MassK0Short) <= cKshortRejMassWindow)) {
       histos.fill(HIST("Tracks/h1f_tracks_info"), kV0KShortMassRej);
       return false;
     }
@@ -735,7 +861,8 @@ struct LambdaTableProducer {
   }
 
   template <typename C, typename V, typename T>
-  bool selV0Particle(C const& col, V const& v0, T const& tracks, ParticleType& v0Type)
+  bool selV0Particle(C const& col, V const& v0, T const& tracks,
+                     ParticleType& v0Type)
   {
     if (!selLambdaMassWindow(v0, tracks, v0Type)) {
       return false;
@@ -809,13 +936,16 @@ struct LambdaTableProducer {
       auto mcpostrack = postrack.template mcParticle_as<aod::McParticles>();
       auto mcnegtrack = negtrack.template mcParticle_as<aod::McParticles>();
       if (mcpart.pdgCode() == kLambda0) {
-        if (mcpostrack.pdgCode() != kProton || mcnegtrack.pdgCode() != kPiMinus) {
+        if (mcpostrack.pdgCode() != kProton ||
+            mcnegtrack.pdgCode() != kPiMinus) {
           histos.fill(HIST("Tracks/h1f_tracks_info"), kLambdaNotPrPiMinus);
           return false;
         }
       } else if (mcpart.pdgCode() == kLambda0Bar) {
-        if (mcpostrack.pdgCode() != kPiPlus || mcnegtrack.pdgCode() != kProtonBar) {
-          histos.fill(HIST("Tracks/h1f_tracks_info"), kAntiLambdaNotAntiPrPiPlus);
+        if (mcpostrack.pdgCode() != kPiPlus ||
+            mcnegtrack.pdgCode() != kProtonBar) {
+          histos.fill(HIST("Tracks/h1f_tracks_info"),
+                      kAntiLambdaNotAntiPrPiPlus);
           return false;
         }
       }
@@ -842,14 +972,16 @@ struct LambdaTableProducer {
 
     // Get Efficiency Factor
     if (cGetEffFact) {
-      auto* objEff = ccdbObj->FindObject(Form("%s", vCorrFactStrings[cCorrFactHist][part].c_str()));
+      auto* objEff = ccdbObj->FindObject(
+        Form("%s", vCorrFactStrings[cCorrFactHist][part].c_str()));
       auto* histEff = dynamic_cast<TH1*>(objEff->Clone());
       if (histEff->GetDimension() == TwoDimCorr) {
         histos.fill(HIST("Tracks/h1f_tracks_info"), kEffCorrPtCent);
         effCorrFact = histEff->GetBinContent(histEff->FindBin(cent, v0.pt()));
       } else if (histEff->GetDimension() == ThreeDimCorr) {
         histos.fill(HIST("Tracks/h1f_tracks_info"), kEffCorrPtRapCent);
-        effCorrFact = histEff->GetBinContent(histEff->FindBin(cent, v0.pt(), rap));
+        effCorrFact =
+          histEff->GetBinContent(histEff->FindBin(cent, v0.pt(), rap));
       } else {
         histos.fill(HIST("Tracks/h1f_tracks_info"), kNoEffCorr);
         LOGF(warning, "CCDB: not a histogram!");
@@ -858,7 +990,8 @@ struct LambdaTableProducer {
       delete histEff;
     }
     if (cGetPrimFrac) {
-      auto* objPrm = ccdbObj->FindObject(Form("%s", vPrimFracStrings[cPrimFracHist][part].c_str()));
+      auto* objPrm = ccdbObj->FindObject(
+        Form("%s", vPrimFracStrings[cPrimFracHist][part].c_str()));
       auto* histPrm = dynamic_cast<TH1*>(objPrm->Clone());
       if (histPrm->GetDimension() == TwoDimCorr) {
         histos.fill(HIST("Tracks/h1f_tracks_info"), kPFCorrPtCent);
@@ -881,26 +1014,33 @@ struct LambdaTableProducer {
   {
     auto mcpart = v0.template mcParticle_as<aod::McParticles>();
     auto lambdaMothers = mcpart.template mothers_as<aod::McParticles>();
-    histos.fill(HIST("Tracks/h2f_lambda_mothers_pdg"), lambdaMothers[0].pdgCode(), v0.pt());
+    histos.fill(HIST("Tracks/h2f_lambda_mothers_pdg"),
+                lambdaMothers[0].pdgCode(), v0.pt());
   }
 
   template <ParticleType part, typename C, typename V, typename T>
   void fillLambdaQAHistos(C const& col, V const& v0, T const&)
   {
-    static constexpr std::array<std::string_view, 2> SubDir = {"QA/Lambda/", "QA/AntiLambda/"};
+    static constexpr std::array<std::string_view, 2> SubDir = {
+      "QA/Lambda/", "QA/AntiLambda/"};
     auto postrack = v0.template posTrack_as<T>();
     auto negtrack = v0.template negTrack_as<T>();
     float mass = (part == kLambda) ? v0.mLambda() : v0.mAntiLambda();
 
     float e = RecoDecay::e(v0.px(), v0.py(), v0.pz(), mass);
     float gamma = e / mass;
-    float ctau = v0.distovertotmom(col.posX(), col.posY(), col.posZ()) * MassLambda0;
+    float ctau =
+      v0.distovertotmom(col.posX(), col.posY(), col.posZ()) * MassLambda0;
     float gctau = ctau * gamma;
 
-    histos.fill(HIST(SubDir[part]) + HIST("h2f_qt_vs_alpha"), v0.alpha(), v0.qtarm());
-    histos.fill(HIST(SubDir[part]) + HIST("h1f_dca_V0_daughters"), v0.dcaV0daughters());
-    histos.fill(HIST(SubDir[part]) + HIST("h1f_dca_pos_to_PV"), v0.dcapostopv());
-    histos.fill(HIST(SubDir[part]) + HIST("h1f_dca_neg_to_PV"), v0.dcanegtopv());
+    histos.fill(HIST(SubDir[part]) + HIST("h2f_qt_vs_alpha"), v0.alpha(),
+                v0.qtarm());
+    histos.fill(HIST(SubDir[part]) + HIST("h1f_dca_V0_daughters"),
+                v0.dcaV0daughters());
+    histos.fill(HIST(SubDir[part]) + HIST("h1f_dca_pos_to_PV"),
+                v0.dcapostopv());
+    histos.fill(HIST(SubDir[part]) + HIST("h1f_dca_neg_to_PV"),
+                v0.dcanegtopv());
     histos.fill(HIST(SubDir[part]) + HIST("h1f_dca_V0_to_PV"), v0.dcav0topv());
     histos.fill(HIST(SubDir[part]) + HIST("h1f_V0_cospa"), v0.v0cosPA());
     histos.fill(HIST(SubDir[part]) + HIST("h1f_V0_radius"), v0.v0radius());
@@ -912,30 +1052,45 @@ struct LambdaTableProducer {
     histos.fill(HIST(SubDir[part]) + HIST("h1f_neg_prong_eta"), negtrack.eta());
     histos.fill(HIST(SubDir[part]) + HIST("h1f_pos_prong_phi"), postrack.phi());
     histos.fill(HIST(SubDir[part]) + HIST("h1f_neg_prong_phi"), negtrack.phi());
-    histos.fill(HIST(SubDir[part]) + HIST("h2f_pos_prong_dcaXY_vs_pt"), postrack.pt(), postrack.dcaXY());
-    histos.fill(HIST(SubDir[part]) + HIST("h2f_neg_prong_dcaXY_vs_pt"), negtrack.pt(), negtrack.dcaXY());
-    histos.fill(HIST(SubDir[part]) + HIST("h2f_pos_prong_dEdx_vs_p"), postrack.tpcInnerParam(), postrack.tpcSignal());
-    histos.fill(HIST(SubDir[part]) + HIST("h2f_neg_prong_dEdx_vs_p"), negtrack.tpcInnerParam(), negtrack.tpcSignal());
-    histos.fill(HIST(SubDir[part]) + HIST("h2f_pos_prong_tpc_nsigma_pr_vs_p"), postrack.tpcInnerParam(), postrack.tpcNSigmaPr());
-    histos.fill(HIST(SubDir[part]) + HIST("h2f_neg_prong_tpc_nsigma_pr_vs_p"), negtrack.tpcInnerParam(), negtrack.tpcNSigmaPr());
-    histos.fill(HIST(SubDir[part]) + HIST("h2f_pos_prong_tpc_nsigma_pi_vs_p"), postrack.tpcInnerParam(), postrack.tpcNSigmaPi());
-    histos.fill(HIST(SubDir[part]) + HIST("h2f_neg_prong_tpc_nsigma_pi_vs_p"), negtrack.tpcInnerParam(), negtrack.tpcNSigmaPi());
+    histos.fill(HIST(SubDir[part]) + HIST("h2f_pos_prong_dcaXY_vs_pt"),
+                postrack.pt(), postrack.dcaXY());
+    histos.fill(HIST(SubDir[part]) + HIST("h2f_neg_prong_dcaXY_vs_pt"),
+                negtrack.pt(), negtrack.dcaXY());
+    histos.fill(HIST(SubDir[part]) + HIST("h2f_pos_prong_dEdx_vs_p"),
+                postrack.tpcInnerParam(), postrack.tpcSignal());
+    histos.fill(HIST(SubDir[part]) + HIST("h2f_neg_prong_dEdx_vs_p"),
+                negtrack.tpcInnerParam(), negtrack.tpcSignal());
+    histos.fill(HIST(SubDir[part]) + HIST("h2f_pos_prong_tpc_nsigma_pr_vs_p"),
+                postrack.tpcInnerParam(), postrack.tpcNSigmaPr());
+    histos.fill(HIST(SubDir[part]) + HIST("h2f_neg_prong_tpc_nsigma_pr_vs_p"),
+                negtrack.tpcInnerParam(), negtrack.tpcNSigmaPr());
+    histos.fill(HIST(SubDir[part]) + HIST("h2f_pos_prong_tpc_nsigma_pi_vs_p"),
+                postrack.tpcInnerParam(), postrack.tpcNSigmaPi());
+    histos.fill(HIST(SubDir[part]) + HIST("h2f_neg_prong_tpc_nsigma_pi_vs_p"),
+                negtrack.tpcInnerParam(), negtrack.tpcNSigmaPi());
   }
 
   template <RecGenType rg, ParticleType part>
-  void fillKinematicHists(float const& pt, float const& eta, float const& y, float const& phi)
+  void fillKinematicHists(float const& pt, float const& eta, float const& y,
+                          float const& phi)
   {
-    static constexpr std::array<std::string_view, 2> SubDirRG = {"McRec/", "McGen/"};
-    static constexpr std::array<std::string_view, 2> SubDirPart = {"Lambda/", "AntiLambda/"};
+    static constexpr std::array<std::string_view, 2> SubDirRG = {"McRec/",
+                                                                 "McGen/"};
+    static constexpr std::array<std::string_view, 2> SubDirPart = {
+      "Lambda/", "AntiLambda/"};
 
     histos.fill(HIST(SubDirRG[rg]) + HIST(SubDirPart[part]) + HIST("hPt"), pt);
-    histos.fill(HIST(SubDirRG[rg]) + HIST(SubDirPart[part]) + HIST("hEta"), eta);
+    histos.fill(HIST(SubDirRG[rg]) + HIST(SubDirPart[part]) + HIST("hEta"),
+                eta);
     histos.fill(HIST(SubDirRG[rg]) + HIST(SubDirPart[part]) + HIST("hRap"), y);
-    histos.fill(HIST(SubDirRG[rg]) + HIST(SubDirPart[part]) + HIST("hPhi"), phi);
+    histos.fill(HIST(SubDirRG[rg]) + HIST(SubDirPart[part]) + HIST("hPhi"),
+                phi);
   }
 
-  template <RunType run, DMCType dmc, typename C, typename B, typename V, typename T>
-  void fillLambdaRecoTables(C const& collision, B const& bc, V const& v0tracks, T const& tracks)
+  template <RunType run, DMCType dmc, typename C, typename B, typename V,
+            typename T>
+  void fillLambdaRecoTables(C const& collision, B const& bc, V const& v0tracks,
+                            T const& tracks)
   {
     histos.fill(HIST("Events/h1f_collisions_info"), kTotCol);
 
@@ -949,7 +1104,8 @@ struct LambdaTableProducer {
     histos.fill(HIST("Events/h1f_collision_posZ"), collision.posZ());
 
     // Fill Collision Table
-    lambdaCollisionTable(cent, mult, collision.posX(), collision.posY(), collision.posZ(), bc.timestamp());
+    lambdaCollisionTable(cent, mult, collision.posX(), collision.posY(),
+                         collision.posZ(), bc.timestamp());
 
     // initialize v0track objects
     ParticleType v0Type = kLambda;
@@ -991,7 +1147,8 @@ struct LambdaTableProducer {
       phi = v0.phi();
 
       if constexpr (dmc == kMC) {
-        histos.fill(HIST("Tracks/h2f_tracks_pid_before_sel"), v0.mcParticle().pdgCode(), v0.pt());
+        histos.fill(HIST("Tracks/h2f_tracks_pid_before_sel"),
+                    v0.mcParticle().pdgCode(), v0.pt());
         if (cSelMCPSV0) {
           v0PrmScdType = isPrimaryV0(v0);
         }
@@ -1002,7 +1159,8 @@ struct LambdaTableProducer {
           fillLambdaMothers(v0, tracks);
         }
         histos.fill(HIST("Tracks/h1f_tracks_info"), kPassTrueLambdaSel);
-        histos.fill(HIST("Tracks/h2f_tracks_pid_after_sel"), v0.mcParticle().pdgCode(), v0.pt());
+        histos.fill(HIST("Tracks/h2f_tracks_pid_after_sel"),
+                    v0.mcParticle().pdgCode(), v0.pt());
         if (cRecoMomResoFlag) {
           auto mc = v0.template mcParticle_as<aod::McParticles>();
           pt = mc.pt();
@@ -1010,14 +1168,16 @@ struct LambdaTableProducer {
           rap = mc.y();
           phi = mc.phi();
           float y = cDoEtaAnalysis ? eta : rap;
-          if (!kinCutSelection(pt, std::abs(y), cMinV0Pt, cMaxV0Pt, cMaxV0Rap)) {
+          if (!kinCutSelection(pt, std::abs(y), cMinV0Pt, cMaxV0Pt,
+                               cMaxV0Rap)) {
             continue;
           }
         }
       }
 
       histos.fill(HIST("Tracks/h2f_armpod_after_sel"), v0.alpha(), v0.qtarm());
-      corr_fact = (v0Type == kLambda) ? getCorrectionFactors<kLambda>(v0) : getCorrectionFactors<kAntiLambda>(v0);
+      corr_fact = (v0Type == kLambda) ? getCorrectionFactors<kLambda>(v0)
+                                      : getCorrectionFactors<kAntiLambda>(v0);
 
       if (v0Type == kLambda) {
         prPx = v0.template posTrack_as<T>().px();
@@ -1025,28 +1185,34 @@ struct LambdaTableProducer {
         prPz = v0.template posTrack_as<T>().pz();
         histos.fill(HIST("Tracks/h1f_lambda_pt_vs_invm"), mass, v0.pt());
         fillLambdaQAHistos<kLambda>(collision, v0, tracks);
-        fillKinematicHists<kRec, kLambda>(v0.pt(), v0.eta(), v0.yLambda(), v0.phi());
+        fillKinematicHists<kRec, kLambda>(v0.pt(), v0.eta(), v0.yLambda(),
+                                          v0.phi());
       } else {
         prPx = v0.template negTrack_as<T>().px();
         prPy = v0.template negTrack_as<T>().py();
         prPz = v0.template negTrack_as<T>().pz();
         histos.fill(HIST("Tracks/h1f_antilambda_pt_vs_invm"), mass, v0.pt());
         fillLambdaQAHistos<kAntiLambda>(collision, v0, tracks);
-        fillKinematicHists<kRec, kAntiLambda>(v0.pt(), v0.eta(), v0.yLambda(), v0.phi());
+        fillKinematicHists<kRec, kAntiLambda>(v0.pt(), v0.eta(), v0.yLambda(),
+                                              v0.phi());
       }
 
-      lambdaTrackTable(lambdaCollisionTable.lastIndex(),
-                       v0.px(), v0.py(), v0.pz(), pt, eta, phi, rap, mass,
-                       prPx, prPy, prPz,
-                       v0.template posTrack_as<T>().index(), v0.template negTrack_as<T>().index(),
-                       v0.v0cosPA(), v0.dcaV0daughters(), (int8_t)v0Type, v0PrmScdType, corr_fact);
+      lambdaTrackTable(lambdaCollisionTable.lastIndex(), v0.px(), v0.py(),
+                       v0.pz(), pt, eta, phi, rap, mass, prPx, prPy, prPz,
+                       v0.template posTrack_as<T>().index(),
+                       v0.template negTrack_as<T>().index(), v0.v0cosPA(),
+                       v0.dcaV0daughters(), (int8_t)v0Type, v0PrmScdType,
+                       corr_fact);
     }
   }
 
-  template <RunType run, typename C, typename M>
-  void fillLambdaMcGenTables(C const& mcCollision, M const& mcParticles)
+  template <RunType run, typename B, typename C, typename M>
+  void fillLambdaMcGenTables(B const& bc, C const& mcCollision,
+                             M const& mcParticles)
   {
-    lambdaMCGenCollisionTable(cent, mult, mcCollision.posX(), mcCollision.posY(), mcCollision.posZ());
+    lambdaMCGenCollisionTable(cent, mult, mcCollision.posX(),
+                              mcCollision.posY(), mcCollision.posZ(),
+                              bc.timestamp());
 
     ParticleType v0Type = kLambda;
     PrmScdType v0PrmScdType = kPrimary;
@@ -1064,7 +1230,8 @@ struct LambdaTableProducer {
 
       v0PrmScdType = mcpart.isPhysicalPrimary() ? kPrimary : kSecondary;
       rap = cDoEtaAnalysis ? mcpart.eta() : mcpart.y();
-      if (!kinCutSelection(mcpart.pt(), std::abs(rap), cMinV0Pt, cMaxV0Pt, cMaxV0Rap)) {
+      if (!kinCutSelection(mcpart.pt(), std::abs(rap), cMinV0Pt, cMaxV0Pt,
+                           cMaxV0Rap)) {
         continue;
       }
       histos.fill(HIST("Tracks/h1f_tracks_info"), kGenTotAccLambda);
@@ -1088,62 +1255,78 @@ struct LambdaTableProducer {
         vDauPy.push_back(dautrack.py());
         vDauPz.push_back(dautrack.pz());
       }
-      if (cGenDecayChannel) {
-        if (v0Type == kLambda && (daughterPDGs[0] != kProton || daughterPDGs[1] != kPiMinus)) {
-          continue;
-        }
-        if (v0Type == kAntiLambda && (daughterPDGs[0] != kProtonBar || daughterPDGs[1] != kPiPlus)) {
-          continue;
+
+      int prIdx = -1, piIdx = -1;
+      int const prPdg = (v0Type == kLambda) ? kProton : kProtonBar;
+      int const piPdg = (v0Type == kLambda) ? kPiMinus : kPiPlus;
+      for (std::size_t i = 0; i < daughterPDGs.size(); ++i) {
+        if (daughterPDGs[i] == prPdg) {
+          prIdx = static_cast<int>(i);
+        } else if (daughterPDGs[i] == piPdg) {
+          piIdx = static_cast<int>(i);
         }
       }
+      if (prIdx < 0 || piIdx < 0) {
+        continue;
+      }
+      if (cGenDecayChannel && daughterPDGs.size() != NDaughtersTwoBody) {
+        continue;
+      }
       histos.fill(HIST("Tracks/h1f_tracks_info"), kGenLambdaToPrPi);
 
+      prPx = vDauPx[prIdx];
+      prPy = vDauPy[prIdx];
+      prPz = vDauPz[prIdx];
+
+      int const posDauIdx = (v0Type == kLambda) ? prIdx : piIdx;
+      int const negDauIdx = (v0Type == kLambda) ? piIdx : prIdx;
+
       if (v0Type == kLambda) {
-        prPx = vDauPx[0];
-        prPy = vDauPy[0];
-        prPz = vDauPz[0];
-        histos.fill(HIST("McGen/h1f_lambda_daughter_PDG"), daughterPDGs[0]);
-        histos.fill(HIST("McGen/h1f_lambda_daughter_PDG"), daughterPDGs[1]);
+        histos.fill(HIST("McGen/h1f_lambda_daughter_PDG"), daughterPDGs[prIdx]);
+        histos.fill(HIST("McGen/h1f_lambda_daughter_PDG"), daughterPDGs[piIdx]);
         histos.fill(HIST("McGen/h1f_lambda_daughter_PDG"), mcpart.pdgCode());
-        histos.fill(HIST("McGen/Lambda/Proton/hPt"), vDauPt[0]);
-        histos.fill(HIST("McGen/Lambda/Proton/hEta"), vDauEta[0]);
-        histos.fill(HIST("McGen/Lambda/Proton/hRap"), vDauRap[0]);
-        histos.fill(HIST("McGen/Lambda/Proton/hPhi"), vDauPhi[0]);
-        histos.fill(HIST("McGen/Lambda/Pion/hPt"), vDauPt[1]);
-        histos.fill(HIST("McGen/Lambda/Pion/hEta"), vDauEta[1]);
-        histos.fill(HIST("McGen/Lambda/Pion/hRap"), vDauRap[1]);
-        histos.fill(HIST("McGen/Lambda/Pion/hPhi"), vDauPhi[1]);
-        fillKinematicHists<kGen, kLambda>(mcpart.pt(), mcpart.eta(), mcpart.y(), mcpart.phi());
+        histos.fill(HIST("McGen/Lambda/Proton/hPt"), vDauPt[prIdx]);
+        histos.fill(HIST("McGen/Lambda/Proton/hEta"), vDauEta[prIdx]);
+        histos.fill(HIST("McGen/Lambda/Proton/hRap"), vDauRap[prIdx]);
+        histos.fill(HIST("McGen/Lambda/Proton/hPhi"), vDauPhi[prIdx]);
+        histos.fill(HIST("McGen/Lambda/Pion/hPt"), vDauPt[piIdx]);
+        histos.fill(HIST("McGen/Lambda/Pion/hEta"), vDauEta[piIdx]);
+        histos.fill(HIST("McGen/Lambda/Pion/hRap"), vDauRap[piIdx]);
+        histos.fill(HIST("McGen/Lambda/Pion/hPhi"), vDauPhi[piIdx]);
+        fillKinematicHists<kGen, kLambda>(mcpart.pt(), mcpart.eta(), mcpart.y(),
+                                          mcpart.phi());
       } else {
-        prPx = vDauPx[1];
-        prPy = vDauPy[1];
-        prPz = vDauPz[1];
-        histos.fill(HIST("McGen/h1f_antilambda_daughter_PDG"), daughterPDGs[0]);
-        histos.fill(HIST("McGen/h1f_antilambda_daughter_PDG"), daughterPDGs[1]);
-        histos.fill(HIST("McGen/h1f_antilambda_daughter_PDG"), mcpart.pdgCode());
-        histos.fill(HIST("McGen/AntiLambda/Pion/hPt"), vDauPt[0]);
-        histos.fill(HIST("McGen/AntiLambda/Pion/hEta"), vDauEta[0]);
-        histos.fill(HIST("McGen/AntiLambda/Pion/hRap"), vDauRap[0]);
-        histos.fill(HIST("McGen/AntiLambda/Pion/hPhi"), vDauPhi[0]);
-        histos.fill(HIST("McGen/AntiLambda/Proton/hPt"), vDauPt[1]);
-        histos.fill(HIST("McGen/AntiLambda/Proton/hEta"), vDauEta[1]);
-        histos.fill(HIST("McGen/AntiLambda/Proton/hRap"), vDauRap[1]);
-        histos.fill(HIST("McGen/AntiLambda/Proton/hPhi"), vDauPhi[1]);
-        fillKinematicHists<kGen, kAntiLambda>(mcpart.pt(), mcpart.eta(), mcpart.y(), mcpart.phi());
+        histos.fill(HIST("McGen/h1f_antilambda_daughter_PDG"),
+                    daughterPDGs[prIdx]);
+        histos.fill(HIST("McGen/h1f_antilambda_daughter_PDG"),
+                    daughterPDGs[piIdx]);
+        histos.fill(HIST("McGen/h1f_antilambda_daughter_PDG"),
+                    mcpart.pdgCode());
+        histos.fill(HIST("McGen/AntiLambda/Proton/hPt"), vDauPt[prIdx]);
+        histos.fill(HIST("McGen/AntiLambda/Proton/hEta"), vDauEta[prIdx]);
+        histos.fill(HIST("McGen/AntiLambda/Proton/hRap"), vDauRap[prIdx]);
+        histos.fill(HIST("McGen/AntiLambda/Proton/hPhi"), vDauPhi[prIdx]);
+        histos.fill(HIST("McGen/AntiLambda/Pion/hPt"), vDauPt[piIdx]);
+        histos.fill(HIST("McGen/AntiLambda/Pion/hEta"), vDauEta[piIdx]);
+        histos.fill(HIST("McGen/AntiLambda/Pion/hRap"), vDauRap[piIdx]);
+        histos.fill(HIST("McGen/AntiLambda/Pion/hPhi"), vDauPhi[piIdx]);
+        fillKinematicHists<kGen, kAntiLambda>(mcpart.pt(), mcpart.eta(),
+                                              mcpart.y(), mcpart.phi());
       }
 
-      lambdaMCGenTrackTable(lambdaMCGenCollisionTable.lastIndex(),
-                            mcpart.px(), mcpart.py(), mcpart.pz(),
-                            mcpart.pt(), mcpart.eta(), mcpart.phi(), mcpart.y(),
-                            RecoDecay::m(mcpart.p(), mcpart.e()),
-                            prPx, prPy, prPz,
-                            daughterIDs[0], daughterIDs[1],
-                            (int8_t)v0Type, -999., -999., v0PrmScdType, 1.);
+      lambdaMCGenTrackTable(
+        lambdaMCGenCollisionTable.lastIndex(), mcpart.px(), mcpart.py(),
+        mcpart.pz(), mcpart.pt(), mcpart.eta(), mcpart.phi(), mcpart.y(),
+        RecoDecay::m(mcpart.p(), mcpart.e()), prPx, prPy, prPz,
+        daughterIDs[posDauIdx], daughterIDs[negDauIdx], (int8_t)v0Type, -999.,
+        -999., v0PrmScdType, 1.);
     }
   }
 
-  template <RunType run, DMCType dmc, typename M, typename C, typename V, typename T, typename P>
-  void analyzeMcRecoGen(M const& mcCollision, C const& collisions, V const& /*V0s*/, T const& /*tracks*/, P const& mcParticles)
+  template <RunType run, DMCType dmc, typename M, typename C, typename B,
+            typename V, typename T, typename P>
+  void analyzeMcRecoGen(M const& mcCollision, C const& collisions, B const&,
+                        V const& V0s, T const& tracks, P const& mcParticles)
   {
     int nRecCols = collisions.size();
     if (nRecCols != 0) {
@@ -1160,59 +1343,79 @@ struct LambdaTableProducer {
       return;
     }
     histos.fill(HIST("McGen/h1f_collisions_info"), kPassSelCol);
-    histos.fill(HIST("McGen/h2f_collision_posZ"), mcCollision.posZ(), collisions.begin().posZ());
-    fillLambdaMcGenTables<run>(mcCollision, mcParticles);
+    histos.fill(HIST("McGen/h2f_collision_posZ"), mcCollision.posZ(),
+                collisions.begin().posZ());
+
+    auto const& recCollision = collisions.begin();
+    auto bc = recCollision.template bc_as<B>();
+    auto v0sThisCollision =
+      V0s.sliceBy(perCollision, recCollision.globalIndex());
+
+    fillLambdaRecoTables<run, dmc>(recCollision, bc, v0sThisCollision, tracks);
+    fillLambdaMcGenTables<run>(bc, mcCollision, mcParticles);
   }
 
   SliceCache cache;
-  Preslice<soa::Join<aod::V0Datas, aod::McV0Labels>> perCollision = aod::v0data::collisionId;
-
-  using CollisionsRun3 = soa::Join<aod::Collisions, aod::EvSels, aod::CentFT0Ms, aod::CentFT0Cs, aod::PVMults>;
-  using CollisionsRun2 = soa::Join<aod::Collisions, aod::EvSels, aod::CentRun2V0Ms, aod::PVMults>;
-  using Tracks = soa::Join<aod::Tracks, aod::TrackSelection, aod::TracksExtra, aod::TracksDCA, aod::pidTPCPi, aod::pidTPCPr, aod::TrackCompColls>;
-  using TracksRun2 = soa::Join<aod::Tracks, aod::TrackSelection, aod::TracksExtra, aod::TracksDCA, aod::pidTPCPi, aod::pidTPCPr>;
+  Preslice<soa::Join<aod::V0Datas, aod::McV0Labels>> perCollision =
+    aod::v0data::collisionId;
+
+  using CollisionsRun3 = soa::Join<aod::Collisions, aod::EvSels, aod::CentFT0Ms,
+                                   aod::CentFT0Cs, aod::PVMults>;
+  using CollisionsRun2 =
+    soa::Join<aod::Collisions, aod::EvSels, aod::CentRun2V0Ms, aod::PVMults>;
+  using Tracks = soa::Join<aod::Tracks, aod::TrackSelection, aod::TracksExtra,
+                           aod::TracksDCA, aod::pidTPCPi, aod::pidTPCPr,
+                           aod::TrackCompColls>;
+  using TracksRun2 =
+    soa::Join<aod::Tracks, aod::TrackSelection, aod::TracksExtra,
+              aod::TracksDCA, aod::pidTPCPi, aod::pidTPCPr>;
   using TracksMC = soa::Join<Tracks, aod::McTrackLabels>;
   using TracksMCRun2 = soa::Join<TracksRun2, aod::McTrackLabels>;
   using McV0Tracks = soa::Join<aod::V0Datas, aod::McV0Labels>;
 
-  void processDataRun3(CollisionsRun3::iterator const& collision, aod::BCsWithTimestamps const&,
-                       aod::V0Datas const& V0s, Tracks const& tracks)
+  void processDataRun3(CollisionsRun3::iterator const& collision,
+                       aod::BCsWithTimestamps const&, aod::V0Datas const& V0s,
+                       Tracks const& tracks)
   {
     auto bc = collision.bc_as<aod::BCsWithTimestamps>();
     fillLambdaRecoTables<kRun3, kData>(collision, bc, V0s, tracks);
   }
-  PROCESS_SWITCH(LambdaTableProducer, processDataRun3, "Process for Run3 DATA", true);
-
-  void processMCRun3(aod::McCollisions::iterator const& mcCollision,
-                     soa::SmallGroups<soa::Join<CollisionsRun3, aod::McCollisionLabels>> const& collisions,
-                     McV0Tracks const& V0s, TracksMC const& tracks, aod::McParticles const& mcParticles)
-  {
-    analyzeMcRecoGen<kRun3, kMC>(mcCollision, collisions, V0s, tracks, mcParticles);
-  }
-  PROCESS_SWITCH(LambdaTableProducer, processMCRun3, "Process for Run3 MC RecoGen", false);
-
-  void processMCRun2(aod::McCollisions::iterator const& mcCollision,
-                     soa::SmallGroups<soa::Join<CollisionsRun2, aod::McCollisionLabels>> const& collisions,
-                     McV0Tracks const& V0s, TracksMCRun2 const& tracks, aod::McParticles const& mcParticles)
+  PROCESS_SWITCH(LambdaTableProducer, processDataRun3, "Process for Run3 DATA",
+                 true);
+
+  void processMCRun3(
+    aod::McCollisions::iterator const& mcCollision,
+    soa::SmallGroups<soa::Join<CollisionsRun3, aod::McCollisionLabels>> const& collisions,
+    aod::BCsWithTimestamps const& bcts, McV0Tracks const& V0s,
+    TracksMC const& tracks, aod::McParticles const& mcParticles)
   {
-    analyzeMcRecoGen<kRun2, kMC>(mcCollision, collisions, V0s, tracks, mcParticles);
+    analyzeMcRecoGen<kRun3, kMC>(mcCollision, collisions, bcts, V0s, tracks,
+                                 mcParticles);
   }
-  PROCESS_SWITCH(LambdaTableProducer, processMCRun2, "Process for Run2 MC RecoGen", false);
+  PROCESS_SWITCH(LambdaTableProducer, processMCRun3,
+                 "Process for Run3 MC RecoGen", false);
 };
 
 struct LambdaTracksExtProducer {
 
   Produces<aod::LambdaTracksExt> lambdaTrackExtTable;
 
-  Configurable<bool> cAcceptAllLambda{"cAcceptAllLambda", false, "Accept all lambda (ignore sharing)"};
-  Configurable<bool> cRejAllLambdaShaDau{"cRejAllLambdaShaDau", true, "Reject lambda sharing daughters"};
-  Configurable<bool> cSelLambdaMassPdg{"cSelLambdaMassPdg", false, "Select lambda closest to PDG mass"};
-  Configurable<bool> cSelLambdaTScore{"cSelLambdaTScore", false, "Select lambda by t-score"};
+  Configurable<bool> cAcceptAllLambda{"cAcceptAllLambda", false,
+                                      "Accept all lambda (ignore sharing)"};
+  Configurable<bool> cRejAllLambdaShaDau{"cRejAllLambdaShaDau", true,
+                                         "Reject lambda sharing daughters"};
+  Configurable<bool> cSelLambdaMassPdg{"cSelLambdaMassPdg", false,
+                                       "Select lambda closest to PDG mass"};
+  Configurable<bool> cSelLambdaTScore{"cSelLambdaTScore", false,
+                                      "Select lambda by t-score"};
   Configurable<float> cA{"cA", 0.6, "t-score weight: |mass - PDGmass|"};
   Configurable<float> cB{"cB", 0.6, "t-score weight: DCA daughters"};
   Configurable<float> cC{"cC", 0.6, "t-score weight: |cosPA - 1|"};
 
-  HistogramRegistry histos{"histos", {}, OutputObjHandlingPolicy::AnalysisObject};
+  HistogramRegistry histos{
+    "histos",
+    {},
+    OutputObjHandlingPolicy::AnalysisObject};
 
   void init(InitContext const&)
   {
@@ -1227,36 +1430,48 @@ struct LambdaTracksExtProducer {
     histos.add("h1i_totantilambda_mult", "Multiplicity", kTH1I, {axisMult});
     histos.add("h1i_lambda_mult", "Multiplicity", kTH1I, {axisMult});
     histos.add("h1i_antilambda_mult", "Multiplicity", kTH1I, {axisMult});
-    histos.add("h2d_n2_etaphi_LaP_LaM", "#rho_{2}^{Share} #Lambda#bar{#Lambda}", kTH2D, {axisDEta, axisDPhi});
-    histos.add("h2d_n2_etaphi_LaM_LaP", "#rho_{2}^{Share} #bar{#Lambda}#Lambda", kTH2D, {axisDEta, axisDPhi});
-    histos.add("h2d_n2_etaphi_LaP_LaP", "#rho_{2}^{Share} #Lambda#Lambda", kTH2D, {axisDEta, axisDPhi});
-    histos.add("h2d_n2_etaphi_LaM_LaM", "#rho_{2}^{Share} #bar{#Lambda}#bar{#Lambda}", kTH2D, {axisDEta, axisDPhi});
+    histos.add("h2d_n2_etaphi_LaP_LaM", "#rho_{2}^{Share} #Lambda#bar{#Lambda}",
+               kTH2D, {axisDEta, axisDPhi});
+    histos.add("h2d_n2_etaphi_LaM_LaP", "#rho_{2}^{Share} #bar{#Lambda}#Lambda",
+               kTH2D, {axisDEta, axisDPhi});
+    histos.add("h2d_n2_etaphi_LaP_LaP", "#rho_{2}^{Share} #Lambda#Lambda",
+               kTH2D, {axisDEta, axisDPhi});
+    histos.add("h2d_n2_etaphi_LaM_LaM",
+               "#rho_{2}^{Share} #bar{#Lambda}#bar{#Lambda}", kTH2D,
+               {axisDEta, axisDPhi});
 
     histos.add("Reco/h1f_lambda_invmass", "M_{#Lambda}", kTH1F, {axisMass});
     histos.add("Reco/h1f_lambda_cospa", "cos(PA)", kTH1F, {axisCPA});
     histos.add("Reco/h1f_lambda_dcadau", "DCA daughters", kTH1F, {axisDcaDau});
-    histos.add("Reco/h1f_antilambda_invmass", "M_{#bar{#Lambda}}", kTH1F, {axisMass});
+    histos.add("Reco/h1f_antilambda_invmass", "M_{#bar{#Lambda}}", kTH1F,
+               {axisMass});
     histos.add("Reco/h1f_antilambda_cospa", "cos(PA)", kTH1F, {axisCPA});
-    histos.add("Reco/h1f_antilambda_dcadau", "DCA daughters", kTH1F, {axisDcaDau});
+    histos.add("Reco/h1f_antilambda_dcadau", "DCA daughters", kTH1F,
+               {axisDcaDau});
     histos.addClone("Reco/", "SharingDau/");
   }
 
   template <ShareDauLambda sd, typename T>
   void fillHistos(T const& track)
   {
-    static constexpr std::array<std::string_view, 2> SubDir = {"Reco/", "SharingDau/"};
+    static constexpr std::array<std::string_view, 2> SubDir = {"Reco/",
+                                                               "SharingDau/"};
     if (track.v0Type() == kLambda) {
       histos.fill(HIST(SubDir[sd]) + HIST("h1f_lambda_invmass"), track.mass());
       histos.fill(HIST(SubDir[sd]) + HIST("h1f_lambda_dcadau"), track.dcaDau());
       histos.fill(HIST(SubDir[sd]) + HIST("h1f_lambda_cospa"), track.cosPA());
     } else {
-      histos.fill(HIST(SubDir[sd]) + HIST("h1f_antilambda_invmass"), track.mass());
-      histos.fill(HIST(SubDir[sd]) + HIST("h1f_antilambda_dcadau"), track.dcaDau());
-      histos.fill(HIST(SubDir[sd]) + HIST("h1f_antilambda_cospa"), track.cosPA());
+      histos.fill(HIST(SubDir[sd]) + HIST("h1f_antilambda_invmass"),
+                  track.mass());
+      histos.fill(HIST(SubDir[sd]) + HIST("h1f_antilambda_dcadau"),
+                  track.dcaDau());
+      histos.fill(HIST(SubDir[sd]) + HIST("h1f_antilambda_cospa"),
+                  track.cosPA());
     }
   }
 
-  void process(aod::LambdaCollisions::iterator const&, aod::LambdaTracks const& tracks)
+  void process(aod::LambdaCollisions::iterator const&,
+               aod::LambdaTracks const& tracks)
   {
     int nTotLambda = 0, nTotAntiLambda = 0, nSelLambda = 0, nSelAntiLambda = 0;
 
@@ -1273,39 +1488,49 @@ struct LambdaTracksExtProducer {
       }
 
       tLambda = (cA * std::abs(lambda.mass() - MassLambda0)) +
-                (cB * lambda.dcaDau()) +
-                (cC * std::abs(lambda.cosPA() - 1.));
+                (cB * lambda.dcaDau()) + (cC * std::abs(lambda.cosPA() - 1.));
 
       for (auto const& track : tracks) {
         if (lambda.index() == track.index()) {
           continue;
         }
 
-        if (lambda.posTrackId() == track.posTrackId() || lambda.negTrackId() == track.negTrackId()) {
+        if (lambda.posTrackId() == track.posTrackId() ||
+            lambda.negTrackId() == track.negTrackId()) {
           vSharedDauLambdaIndex.push_back(track.index());
           lambdaSharingDauFlag = true;
 
           if (lambda.v0Type() == kLambda && track.v0Type() == kAntiLambda) {
-            histos.fill(HIST("h2d_n2_etaphi_LaP_LaM"), lambda.eta() - track.eta(),
-                        RecoDecay::constrainAngle((lambda.phi() - track.phi()), -PIHalf));
-          } else if (lambda.v0Type() == kAntiLambda && track.v0Type() == kLambda) {
-            histos.fill(HIST("h2d_n2_etaphi_LaM_LaP"), lambda.eta() - track.eta(),
-                        RecoDecay::constrainAngle((lambda.phi() - track.phi()), -PIHalf));
+            histos.fill(HIST("h2d_n2_etaphi_LaP_LaM"),
+                        lambda.eta() - track.eta(),
+                        RecoDecay::constrainAngle((lambda.phi() - track.phi()),
+                                                  -PIHalf));
+          } else if (lambda.v0Type() == kAntiLambda &&
+                     track.v0Type() == kLambda) {
+            histos.fill(HIST("h2d_n2_etaphi_LaM_LaP"),
+                        lambda.eta() - track.eta(),
+                        RecoDecay::constrainAngle((lambda.phi() - track.phi()),
+                                                  -PIHalf));
           } else if (lambda.v0Type() == kLambda && track.v0Type() == kLambda) {
-            histos.fill(HIST("h2d_n2_etaphi_LaP_LaP"), lambda.eta() - track.eta(),
-                        RecoDecay::constrainAngle((lambda.phi() - track.phi()), -PIHalf));
-          } else if (lambda.v0Type() == kAntiLambda && track.v0Type() == kAntiLambda) {
-            histos.fill(HIST("h2d_n2_etaphi_LaM_LaM"), lambda.eta() - track.eta(),
-                        RecoDecay::constrainAngle((lambda.phi() - track.phi()), -PIHalf));
+            histos.fill(HIST("h2d_n2_etaphi_LaP_LaP"),
+                        lambda.eta() - track.eta(),
+                        RecoDecay::constrainAngle((lambda.phi() - track.phi()),
+                                                  -PIHalf));
+          } else if (lambda.v0Type() == kAntiLambda &&
+                     track.v0Type() == kAntiLambda) {
+            histos.fill(HIST("h2d_n2_etaphi_LaM_LaM"),
+                        lambda.eta() - track.eta(),
+                        RecoDecay::constrainAngle((lambda.phi() - track.phi()),
+                                                  -PIHalf));
           }
 
-          if (std::abs(lambda.mass() - MassLambda0) > std::abs(track.mass() - MassLambda0)) {
+          if (std::abs(lambda.mass() - MassLambda0) >
+              std::abs(track.mass() - MassLambda0)) {
             lambdaMinDeltaMassFlag = false;
           }
 
           tTrack = (cA * std::abs(track.mass() - MassLambda0)) +
-                   (cB * track.dcaDau()) +
-                   (cC * std::abs(track.cosPA() - 1.));
+                   (cB * track.dcaDau()) + (cC * std::abs(track.cosPA() - 1.));
           if (tLambda > tTrack) {
             lambdaMinTScoreFlag = false;
           }
@@ -1318,8 +1543,7 @@ struct LambdaTracksExtProducer {
         fillHistos<kUniqueLambda>(lambda);
       }
 
-      if (cAcceptAllLambda ||
-          (cRejAllLambdaShaDau && !lambdaSharingDauFlag) ||
+      if (cAcceptAllLambda || (cRejAllLambdaShaDau && !lambdaSharingDauFlag) ||
           (cSelLambdaMassPdg && lambdaMinDeltaMassFlag) ||
           (cSelLambdaTScore && lambdaMinTScoreFlag)) {
         trueLambdaFlag = true;
@@ -1333,7 +1557,8 @@ struct LambdaTracksExtProducer {
         }
       }
 
-      lambdaTrackExtTable(lambdaSharingDauFlag, vSharedDauLambdaIndex, trueLambdaFlag);
+      lambdaTrackExtTable(lambdaSharingDauFlag, vSharedDauLambdaIndex,
+                          trueLambdaFlag);
     }
 
     if (nTotLambda != 0) {
@@ -1352,9 +1577,11 @@ struct LambdaTracksExtProducer {
 };
 
 struct LambdaSpinPolarization {
-
+  // Table producer
   Produces<aod::LambdaMixEventCollisions> lambdaMixEvtCol;
   Produces<aod::LambdaMixEventTracks> lambdaMixEvtTrk;
+  Produces<aod::LambdaMixEventMcGenCollisions> lambdaMixEvtMGCol;
+  Produces<aod::LambdaMixEventMcGenTracks> lambdaMixEvtMGTrk;
 
   Configurable<int> cNPtBins{"cNPtBins", 30, "N pT bins"};
   Configurable<float> cMinPt{"cMinPt", 0.5f, "pT min (GeV/c)"};
@@ -1366,22 +1593,33 @@ struct LambdaSpinPolarization {
   Configurable<int> cNBinsCosTS{"cNBinsCosTS", 10, "N costheta* bins"};
   Configurable<int> cNBinsDeltaR{"cNBinsDeltaR", 20, "N DeltaR bins"};
 
-  Configurable<float> cMassHistMin{"cMassHistMin", 1.08f, "Mass histogram min (GeV/c2)"};
-  Configurable<float> cMassHistMax{"cMassHistMax", 1.20f, "Mass histogram max (GeV/c2)"};
+  Configurable<float> cMassHistMin{"cMassHistMin", 1.08f,
+                                   "Mass histogram min (GeV/c2)"};
+  Configurable<float> cMassHistMax{"cMassHistMax", 1.20f,
+                                   "Mass histogram max (GeV/c2)"};
   Configurable<int> cNMassBins{"cNMassBins", 120, "Mass histogram N bins"};
 
-  Configurable<float> cSigMinLambda{"cSigMinLambda", 1.108f, "Signal region min (GeV/c2)"};
-  Configurable<float> cSigMaxLambda{"cSigMaxLambda", 1.123f, "Signal region max (GeV/c2)"};
-  Configurable<float> cSbLeftMin{"cSbLeftMin", 1.080f, "Left sideband min (GeV/c2)"};
-  Configurable<float> cSbLeftMax{"cSbLeftMax", 1.100f, "Left sideband max (GeV/c2)"};
-  Configurable<float> cSbRightMin{"cSbRightMin", 1.135f, "Right sideband min (GeV/c2)"};
-  Configurable<float> cSbRightMax{"cSbRightMax", 1.155f, "Right sideband max (GeV/c2)"};
+  Configurable<float> cSigMinLambda{"cSigMinLambda", 1.108f,
+                                    "Signal region min (GeV/c2)"};
+  Configurable<float> cSigMaxLambda{"cSigMaxLambda", 1.123f,
+                                    "Signal region max (GeV/c2)"};
+  Configurable<float> cSbLeftMin{"cSbLeftMin", 1.080f,
+                                 "Left sideband min (GeV/c2)"};
+  Configurable<float> cSbLeftMax{"cSbLeftMax", 1.100f,
+                                 "Left sideband max (GeV/c2)"};
+  Configurable<float> cSbRightMin{"cSbRightMin", 1.135f,
+                                  "Right sideband min (GeV/c2)"};
+  Configurable<float> cSbRightMax{"cSbRightMax", 1.155f,
+                                  "Right sideband max (GeV/c2)"};
 
   Configurable<bool> cInvBoostFlag{"cInvBoostFlag", true, "Inverse boost flag"};
-  Configurable<bool> cDoAtlasMethod{"cDoAtlasMethod", false, "Fill pair-boost (ATLAS) histograms"};
-  Configurable<bool> cDoStarMethod{"cDoStarMethod", true, "Fill lab-boost (STAR) histograms"};
+  Configurable<bool> cDoAtlasMethod{"cDoAtlasMethod", false,
+                                    "Fill pair-boost (ATLAS) histograms"};
+  Configurable<bool> cDoStarMethod{"cDoStarMethod", true,
+                                   "Fill lab-boost (STAR) histograms"};
   Configurable<int> mixingParameter{"mixingParameter", 5, "ME pool depth"};
-  Configurable<int> cMEMode{"cMEMode", 1, "ME mode: 0=standard, 1=kinematicConstrained"};
+  Configurable<int> cMEMode{"cMEMode", 1,
+                            "ME mode: 0=standard, 1=kinematicConstrained"};
 
   ConfigurableAxis cMultBins{"cMultBins", {VARIABLE_WIDTH, 0.f, 10.f, 30.f, 50.f, 80.f, 100.f}, "Multiplicity bins"};
   ConfigurableAxis axisCentME{"axisCentME", {VARIABLE_WIDTH, 0, 10, 30, 50, 100}, "ME centrality bins"};
@@ -1391,7 +1629,10 @@ struct LambdaSpinPolarization {
   Configurable<float> cMaxDeltaPhi{"cMaxDeltaPhi", 0.1f, "Kinematic ME: max |deltaPhi(SE)-deltaPhi(ME)| (rad)"};
   Configurable<float> cMaxDeltaRap{"cMaxDeltaRap", 0.1f, "Kinematic ME: max |deltaRap(SE)-deltaRap(ME)|"};
 
-  HistogramRegistry histos{"histos", {}, OutputObjHandlingPolicy::AnalysisObject};
+  HistogramRegistry histos{
+    "histos",
+    {},
+    OutputObjHandlingPolicy::AnalysisObject};
 
   float cent = 0.;
   struct PoolTrack {
@@ -1412,9 +1653,8 @@ struct LambdaSpinPolarization {
   template <typename T>
   PoolTrack toPoolTrack(T const& trk)
   {
-    return PoolTrack{trk.px(), trk.py(), trk.pz(), trk.pt(),
-                     trk.rap(), trk.phi(), trk.mass(),
-                     trk.prPx(), trk.prPy(), trk.prPz()};
+    return PoolTrack{trk.px(), trk.py(), trk.pz(), trk.pt(), trk.rap(),
+                     trk.phi(), trk.mass(), trk.prPx(), trk.prPy(), trk.prPz()};
   }
 
   void init(InitContext const&)
@@ -1422,36 +1662,66 @@ struct LambdaSpinPolarization {
     const AxisSpec axisCheck(1, 0, 1, "");
     const AxisSpec axisCent(cMultBins, "FT0M (%)");
 
-    const AxisSpec axisMass(cNMassBins, cMassHistMin, cMassHistMax, "M_{#Lambda} (GeV/#it{c}^{2})");
+    const AxisSpec axisMass(cNMassBins, cMassHistMin, cMassHistMax,
+                            "M_{#Lambda} (GeV/#it{c}^{2})");
     const AxisSpec axisPt(cNPtBins, cMinPt, cMaxPt, "p_{T} (GeV/#it{c})");
-    const AxisSpec axisDRap(2 * cNRapBins, cMinRap - cMaxRap, cMaxRap - cMinRap, "#Deltay");
+    const AxisSpec axisDRap(2 * cNRapBins, cMinRap - cMaxRap, cMaxRap - cMinRap,
+                            "#Deltay");
     const AxisSpec axisDPhi(cNPhiBins, -PI, PI, "#Delta#varphi");
     const AxisSpec axisCosTS(cNBinsCosTS, -1, 1, "cos(#theta*)");
     const AxisSpec axisDR(cNBinsDeltaR, 0, 3.5, "#DeltaR");
     const AxisSpec axisPosZ(200, -10, 10, "V_{z} (cm)");
     const AxisSpec axisMult(10, 0, 10, "N_{#Lambda}");
 
-    histos.add("QA/ME/hPoolCentVz", "ME pool;cent (%);V_{z}", kTH2F, {axisCentME, axisVtxZME});
-    histos.add("QA/ME/hLambdaMultVsCent", "ME #Lambda mult;cent;N", kTH2F, {axisCentME, {50, 0, 50}});
-    histos.add("QA/ME/hAntiLambdaMultVsCent", "ME #bar{#Lambda} mult;cent;N", kTH2F, {axisCentME, {50, 0, 50}});
-
-    const std::vector<AxisSpec> massSparseAxes = {axisCent, axisMass, axisMass, axisPt, axisPt,
-                                                  axisDRap, axisDPhi, axisDR, axisCosTS};
-
-    histos.add("SE/Reco/Star/h2f_n2_mass_LaPLaM", "M_{inv}: #Lambda#bar{#Lambda} inclusive", kTHnSparseF, massSparseAxes);
-    histos.add("SE/Reco/Star/h2f_n2_mass_LaMLaP", "M_{inv}: #bar{#Lambda}#Lambda inclusive", kTHnSparseF, massSparseAxes);
-    histos.add("SE/Reco/Star/h2f_n2_mass_LaPLaP", "M_{inv}: #Lambda#Lambda inclusive", kTHnSparseF, massSparseAxes);
-    histos.add("SE/Reco/Star/h2f_n2_mass_LaMLaM", "M_{inv}: #bar{#Lambda}#bar{#Lambda} inclusive", kTHnSparseF, massSparseAxes);
-
-    histos.add("SE/RecoBkgSigSB/Star/h2f_n2_mass_LaPLaM", "M_{inv}: #Lambda#bar{#Lambda} Sig#timesSB", kTHnSparseF, massSparseAxes);
-    histos.add("SE/RecoBkgSigSB/Star/h2f_n2_mass_LaMLaP", "M_{inv}: #bar{#Lambda}#Lambda Sig#timesSB", kTHnSparseF, massSparseAxes);
-    histos.add("SE/RecoBkgSigSB/Star/h2f_n2_mass_LaPLaP", "M_{inv}: #Lambda#Lambda Sig#timesSB", kTHnSparseF, massSparseAxes);
-    histos.add("SE/RecoBkgSigSB/Star/h2f_n2_mass_LaMLaM", "M_{inv}: #bar{#Lambda}#bar{#Lambda} Sig#timesSB", kTHnSparseF, massSparseAxes);
-
-    histos.add("SE/RecoBkgSBSB/Star/h2f_n2_mass_LaPLaM", "M_{inv}: #Lambda#bar{#Lambda} SB#timesSB", kTHnSparseF, massSparseAxes);
-    histos.add("SE/RecoBkgSBSB/Star/h2f_n2_mass_LaMLaP", "M_{inv}: #bar{#Lambda}#Lambda SB#timesSB", kTHnSparseF, massSparseAxes);
-    histos.add("SE/RecoBkgSBSB/Star/h2f_n2_mass_LaPLaP", "M_{inv}: #Lambda#Lambda SB#timesSB", kTHnSparseF, massSparseAxes);
-    histos.add("SE/RecoBkgSBSB/Star/h2f_n2_mass_LaMLaM", "M_{inv}: #bar{#Lambda}#bar{#Lambda} SB#timesSB", kTHnSparseF, massSparseAxes);
+    histos.add("QA/ME/hPoolCentVz", "ME pool;cent (%);V_{z}", kTH2F,
+               {axisCentME, axisVtxZME});
+    histos.add("QA/ME/hLambdaMultVsCent", "ME #Lambda mult;cent;N", kTH2F,
+               {axisCentME, {50, 0, 50}});
+    histos.add("QA/ME/hAntiLambdaMultVsCent", "ME #bar{#Lambda} mult;cent;N",
+               kTH2F, {axisCentME, {50, 0, 50}});
+
+    const std::vector<AxisSpec> massSparseAxes = {
+      axisCent, axisMass, axisMass, axisPt, axisPt,
+      axisDRap, axisDPhi, axisDR, axisCosTS};
+
+    histos.add("SE/Reco/Star/h2f_n2_mass_LaPLaM",
+               "M_{inv}: #Lambda#bar{#Lambda} inclusive", kTHnSparseF,
+               massSparseAxes);
+    histos.add("SE/Reco/Star/h2f_n2_mass_LaMLaP",
+               "M_{inv}: #bar{#Lambda}#Lambda inclusive", kTHnSparseF,
+               massSparseAxes);
+    histos.add("SE/Reco/Star/h2f_n2_mass_LaPLaP",
+               "M_{inv}: #Lambda#Lambda inclusive", kTHnSparseF,
+               massSparseAxes);
+    histos.add("SE/Reco/Star/h2f_n2_mass_LaMLaM",
+               "M_{inv}: #bar{#Lambda}#bar{#Lambda} inclusive", kTHnSparseF,
+               massSparseAxes);
+
+    histos.add("SE/RecoBkgSigSB/Star/h2f_n2_mass_LaPLaM",
+               "M_{inv}: #Lambda#bar{#Lambda} Sig#timesSB", kTHnSparseF,
+               massSparseAxes);
+    histos.add("SE/RecoBkgSigSB/Star/h2f_n2_mass_LaMLaP",
+               "M_{inv}: #bar{#Lambda}#Lambda Sig#timesSB", kTHnSparseF,
+               massSparseAxes);
+    histos.add("SE/RecoBkgSigSB/Star/h2f_n2_mass_LaPLaP",
+               "M_{inv}: #Lambda#Lambda Sig#timesSB", kTHnSparseF,
+               massSparseAxes);
+    histos.add("SE/RecoBkgSigSB/Star/h2f_n2_mass_LaMLaM",
+               "M_{inv}: #bar{#Lambda}#bar{#Lambda} Sig#timesSB", kTHnSparseF,
+               massSparseAxes);
+
+    histos.add("SE/RecoBkgSBSB/Star/h2f_n2_mass_LaPLaM",
+               "M_{inv}: #Lambda#bar{#Lambda} SB#timesSB", kTHnSparseF,
+               massSparseAxes);
+    histos.add("SE/RecoBkgSBSB/Star/h2f_n2_mass_LaMLaP",
+               "M_{inv}: #bar{#Lambda}#Lambda SB#timesSB", kTHnSparseF,
+               massSparseAxes);
+    histos.add("SE/RecoBkgSBSB/Star/h2f_n2_mass_LaPLaP",
+               "M_{inv}: #Lambda#Lambda SB#timesSB", kTHnSparseF,
+               massSparseAxes);
+    histos.add("SE/RecoBkgSBSB/Star/h2f_n2_mass_LaMLaM",
+               "M_{inv}: #bar{#Lambda}#bar{#Lambda} SB#timesSB", kTHnSparseF,
+               massSparseAxes);
 
     histos.addClone("SE/Reco/Star/", "SE/Reco/Atlas/");
     histos.addClone("SE/RecoBkgSigSB/Star/", "SE/RecoBkgSigSB/Atlas/");
@@ -1461,45 +1731,109 @@ struct LambdaSpinPolarization {
     histos.addClone("SE/RecoBkgSigSB/", "ME/RecoBkgSigSB/");
     histos.addClone("SE/RecoBkgSBSB/", "ME/RecoBkgSBSB/");
 
-    histos.add("SE/RecoCorr/Star/h2f_n2_dltaR_LaPLaM", "#rho_{2} #Lambda#bar{#Lambda} [Star]", kTHnSparseF, {axisCent, axisDR, axisCosTS});
-    histos.add("SE/RecoCorr/Star/h2f_n2_dltaR_LaMLaP", "#rho_{2} #bar{#Lambda}#Lambda [Star]", kTHnSparseF, {axisCent, axisDR, axisCosTS});
-    histos.add("SE/RecoCorr/Star/h2f_n2_dltaR_LaPLaP", "#rho_{2} #Lambda#Lambda [Star]", kTHnSparseF, {axisCent, axisDR, axisCosTS});
-    histos.add("SE/RecoCorr/Star/h2f_n2_dltaR_LaMLaM", "#rho_{2} #bar{#Lambda}#bar{#Lambda} [Star]", kTHnSparseF, {axisCent, axisDR, axisCosTS});
-
-    histos.add("SE/RecoCorr/Star/h2f_n2_ctheta_LaPLaM", "#rho_{2} #Lambda#bar{#Lambda} [Star]", kTHnSparseF, {axisCent, axisDRap, axisDPhi, axisCosTS});
-    histos.add("SE/RecoCorr/Star/h2f_n2_ctheta_LaMLaP", "#rho_{2} #bar{#Lambda}#Lambda [Star]", kTHnSparseF, {axisCent, axisDRap, axisDPhi, axisCosTS});
-    histos.add("SE/RecoCorr/Star/h2f_n2_ctheta_LaPLaP", "#rho_{2} #Lambda#Lambda [Star]", kTHnSparseF, {axisCent, axisDRap, axisDPhi, axisCosTS});
-    histos.add("SE/RecoCorr/Star/h2f_n2_ctheta_LaMLaM", "#rho_{2} #bar{#Lambda}#bar{#Lambda} [Star]", kTHnSparseF, {axisCent, axisDRap, axisDPhi, axisCosTS});
-
-    histos.add("SE/RecoCorr/Atlas/h2f_n2_dltaR_LaPLaM", "#rho_{2} #Lambda#bar{#Lambda} [Atlas]", kTHnSparseF, {axisCent, axisDR, axisCosTS});
-    histos.add("SE/RecoCorr/Atlas/h2f_n2_dltaR_LaMLaP", "#rho_{2} #bar{#Lambda}#Lambda [Atlas]", kTHnSparseF, {axisCent, axisDR, axisCosTS});
-    histos.add("SE/RecoCorr/Atlas/h2f_n2_dltaR_LaPLaP", "#rho_{2} #Lambda#Lambda [Atlas]", kTHnSparseF, {axisCent, axisDR, axisCosTS});
-    histos.add("SE/RecoCorr/Atlas/h2f_n2_dltaR_LaMLaM", "#rho_{2} #bar{#Lambda}#bar{#Lambda} [Atlas]", kTHnSparseF, {axisCent, axisDR, axisCosTS});
-
-    histos.add("SE/RecoCorr/Atlas/h2f_n2_ctheta_LaPLaM", "#rho_{2} #Lambda#bar{#Lambda} [Atlas]", kTHnSparseF, {axisCent, axisDRap, axisDPhi, axisCosTS});
-    histos.add("SE/RecoCorr/Atlas/h2f_n2_ctheta_LaMLaP", "#rho_{2} #bar{#Lambda}#Lambda [Atlas]", kTHnSparseF, {axisCent, axisDRap, axisDPhi, axisCosTS});
-    histos.add("SE/RecoCorr/Atlas/h2f_n2_ctheta_LaPLaP", "#rho_{2} #Lambda#Lambda [Atlas]", kTHnSparseF, {axisCent, axisDRap, axisDPhi, axisCosTS});
-    histos.add("SE/RecoCorr/Atlas/h2f_n2_ctheta_LaMLaM", "#rho_{2} #bar{#Lambda}#bar{#Lambda} [Atlas]", kTHnSparseF, {axisCent, axisDRap, axisDPhi, axisCosTS});
-
-    histos.add("ME/RecoCorr/Star/h2f_n2_dltaR_LaPLaM", "#rho_{2} #Lambda#bar{#Lambda} [Star]", kTHnSparseF, {axisCent, axisDR, axisCosTS});
-    histos.add("ME/RecoCorr/Star/h2f_n2_dltaR_LaMLaP", "#rho_{2} #bar{#Lambda}#Lambda [Star]", kTHnSparseF, {axisCent, axisDR, axisCosTS});
-    histos.add("ME/RecoCorr/Star/h2f_n2_dltaR_LaPLaP", "#rho_{2} #Lambda#Lambda [Star]", kTHnSparseF, {axisCent, axisDR, axisCosTS});
-    histos.add("ME/RecoCorr/Star/h2f_n2_dltaR_LaMLaM", "#rho_{2} #bar{#Lambda}#bar{#Lambda} [Star]", kTHnSparseF, {axisCent, axisDR, axisCosTS});
-
-    histos.add("ME/RecoCorr/Star/h2f_n2_ctheta_LaPLaM", "#rho_{2} #Lambda#bar{#Lambda} [Star]", kTHnSparseF, {axisCent, axisDRap, axisDPhi, axisCosTS});
-    histos.add("ME/RecoCorr/Star/h2f_n2_ctheta_LaMLaP", "#rho_{2} #bar{#Lambda}#Lambda [Star]", kTHnSparseF, {axisCent, axisDRap, axisDPhi, axisCosTS});
-    histos.add("ME/RecoCorr/Star/h2f_n2_ctheta_LaPLaP", "#rho_{2} #Lambda#Lambda [Star]", kTHnSparseF, {axisCent, axisDRap, axisDPhi, axisCosTS});
-    histos.add("ME/RecoCorr/Star/h2f_n2_ctheta_LaMLaM", "#rho_{2} #bar{#Lambda}#bar{#Lambda} [Star]", kTHnSparseF, {axisCent, axisDRap, axisDPhi, axisCosTS});
-
-    histos.add("ME/RecoCorr/Atlas/h2f_n2_dltaR_LaPLaM", "#rho_{2} #Lambda#bar{#Lambda} [Atlas]", kTHnSparseF, {axisCent, axisDR, axisCosTS});
-    histos.add("ME/RecoCorr/Atlas/h2f_n2_dltaR_LaMLaP", "#rho_{2} #bar{#Lambda}#Lambda [Atlas]", kTHnSparseF, {axisCent, axisDR, axisCosTS});
-    histos.add("ME/RecoCorr/Atlas/h2f_n2_dltaR_LaPLaP", "#rho_{2} #Lambda#Lambda [Atlas]", kTHnSparseF, {axisCent, axisDR, axisCosTS});
-    histos.add("ME/RecoCorr/Atlas/h2f_n2_dltaR_LaMLaM", "#rho_{2} #bar{#Lambda}#bar{#Lambda} [Atlas]", kTHnSparseF, {axisCent, axisDR, axisCosTS});
-
-    histos.add("ME/RecoCorr/Atlas/h2f_n2_ctheta_LaPLaM", "#rho_{2} #Lambda#bar{#Lambda} [Atlas]", kTHnSparseF, {axisCent, axisDRap, axisDPhi, axisCosTS});
-    histos.add("ME/RecoCorr/Atlas/h2f_n2_ctheta_LaMLaP", "#rho_{2} #bar{#Lambda}#Lambda [Atlas]", kTHnSparseF, {axisCent, axisDRap, axisDPhi, axisCosTS});
-    histos.add("ME/RecoCorr/Atlas/h2f_n2_ctheta_LaPLaP", "#rho_{2} #Lambda#Lambda [Atlas]", kTHnSparseF, {axisCent, axisDRap, axisDPhi, axisCosTS});
-    histos.add("ME/RecoCorr/Atlas/h2f_n2_ctheta_LaMLaM", "#rho_{2} #bar{#Lambda}#bar{#Lambda} [Atlas]", kTHnSparseF, {axisCent, axisDRap, axisDPhi, axisCosTS});
+    histos.add("SE/RecoCorr/Star/h2f_n2_dltaR_LaPLaM",
+               "#rho_{2} #Lambda#bar{#Lambda} [Star]", kTHnSparseF,
+               {axisCent, axisDR, axisCosTS});
+    histos.add("SE/RecoCorr/Star/h2f_n2_dltaR_LaMLaP",
+               "#rho_{2} #bar{#Lambda}#Lambda [Star]", kTHnSparseF,
+               {axisCent, axisDR, axisCosTS});
+    histos.add("SE/RecoCorr/Star/h2f_n2_dltaR_LaPLaP",
+               "#rho_{2} #Lambda#Lambda [Star]", kTHnSparseF,
+               {axisCent, axisDR, axisCosTS});
+    histos.add("SE/RecoCorr/Star/h2f_n2_dltaR_LaMLaM",
+               "#rho_{2} #bar{#Lambda}#bar{#Lambda} [Star]", kTHnSparseF,
+               {axisCent, axisDR, axisCosTS});
+
+    histos.add("SE/RecoCorr/Star/h2f_n2_ctheta_LaPLaM",
+               "#rho_{2} #Lambda#bar{#Lambda} [Star]", kTHnSparseF,
+               {axisCent, axisDRap, axisDPhi, axisCosTS});
+    histos.add("SE/RecoCorr/Star/h2f_n2_ctheta_LaMLaP",
+               "#rho_{2} #bar{#Lambda}#Lambda [Star]", kTHnSparseF,
+               {axisCent, axisDRap, axisDPhi, axisCosTS});
+    histos.add("SE/RecoCorr/Star/h2f_n2_ctheta_LaPLaP",
+               "#rho_{2} #Lambda#Lambda [Star]", kTHnSparseF,
+               {axisCent, axisDRap, axisDPhi, axisCosTS});
+    histos.add("SE/RecoCorr/Star/h2f_n2_ctheta_LaMLaM",
+               "#rho_{2} #bar{#Lambda}#bar{#Lambda} [Star]", kTHnSparseF,
+               {axisCent, axisDRap, axisDPhi, axisCosTS});
+
+    histos.add("SE/RecoCorr/Atlas/h2f_n2_dltaR_LaPLaM",
+               "#rho_{2} #Lambda#bar{#Lambda} [Atlas]", kTHnSparseF,
+               {axisCent, axisDR, axisCosTS});
+    histos.add("SE/RecoCorr/Atlas/h2f_n2_dltaR_LaMLaP",
+               "#rho_{2} #bar{#Lambda}#Lambda [Atlas]", kTHnSparseF,
+               {axisCent, axisDR, axisCosTS});
+    histos.add("SE/RecoCorr/Atlas/h2f_n2_dltaR_LaPLaP",
+               "#rho_{2} #Lambda#Lambda [Atlas]", kTHnSparseF,
+               {axisCent, axisDR, axisCosTS});
+    histos.add("SE/RecoCorr/Atlas/h2f_n2_dltaR_LaMLaM",
+               "#rho_{2} #bar{#Lambda}#bar{#Lambda} [Atlas]", kTHnSparseF,
+               {axisCent, axisDR, axisCosTS});
+
+    histos.add("SE/RecoCorr/Atlas/h2f_n2_ctheta_LaPLaM",
+               "#rho_{2} #Lambda#bar{#Lambda} [Atlas]", kTHnSparseF,
+               {axisCent, axisDRap, axisDPhi, axisCosTS});
+    histos.add("SE/RecoCorr/Atlas/h2f_n2_ctheta_LaMLaP",
+               "#rho_{2} #bar{#Lambda}#Lambda [Atlas]", kTHnSparseF,
+               {axisCent, axisDRap, axisDPhi, axisCosTS});
+    histos.add("SE/RecoCorr/Atlas/h2f_n2_ctheta_LaPLaP",
+               "#rho_{2} #Lambda#Lambda [Atlas]", kTHnSparseF,
+               {axisCent, axisDRap, axisDPhi, axisCosTS});
+    histos.add("SE/RecoCorr/Atlas/h2f_n2_ctheta_LaMLaM",
+               "#rho_{2} #bar{#Lambda}#bar{#Lambda} [Atlas]", kTHnSparseF,
+               {axisCent, axisDRap, axisDPhi, axisCosTS});
+
+    histos.add("ME/RecoCorr/Star/h2f_n2_dltaR_LaPLaM",
+               "#rho_{2} #Lambda#bar{#Lambda} [Star]", kTHnSparseF,
+               {axisCent, axisDR, axisCosTS});
+    histos.add("ME/RecoCorr/Star/h2f_n2_dltaR_LaMLaP",
+               "#rho_{2} #bar{#Lambda}#Lambda [Star]", kTHnSparseF,
+               {axisCent, axisDR, axisCosTS});
+    histos.add("ME/RecoCorr/Star/h2f_n2_dltaR_LaPLaP",
+               "#rho_{2} #Lambda#Lambda [Star]", kTHnSparseF,
+               {axisCent, axisDR, axisCosTS});
+    histos.add("ME/RecoCorr/Star/h2f_n2_dltaR_LaMLaM",
+               "#rho_{2} #bar{#Lambda}#bar{#Lambda} [Star]", kTHnSparseF,
+               {axisCent, axisDR, axisCosTS});
+
+    histos.add("ME/RecoCorr/Star/h2f_n2_ctheta_LaPLaM",
+               "#rho_{2} #Lambda#bar{#Lambda} [Star]", kTHnSparseF,
+               {axisCent, axisDRap, axisDPhi, axisCosTS});
+    histos.add("ME/RecoCorr/Star/h2f_n2_ctheta_LaMLaP",
+               "#rho_{2} #bar{#Lambda}#Lambda [Star]", kTHnSparseF,
+               {axisCent, axisDRap, axisDPhi, axisCosTS});
+    histos.add("ME/RecoCorr/Star/h2f_n2_ctheta_LaPLaP",
+               "#rho_{2} #Lambda#Lambda [Star]", kTHnSparseF,
+               {axisCent, axisDRap, axisDPhi, axisCosTS});
+    histos.add("ME/RecoCorr/Star/h2f_n2_ctheta_LaMLaM",
+               "#rho_{2} #bar{#Lambda}#bar{#Lambda} [Star]", kTHnSparseF,
+               {axisCent, axisDRap, axisDPhi, axisCosTS});
+
+    histos.add("ME/RecoCorr/Atlas/h2f_n2_dltaR_LaPLaM",
+               "#rho_{2} #Lambda#bar{#Lambda} [Atlas]", kTHnSparseF,
+               {axisCent, axisDR, axisCosTS});
+    histos.add("ME/RecoCorr/Atlas/h2f_n2_dltaR_LaMLaP",
+               "#rho_{2} #bar{#Lambda}#Lambda [Atlas]", kTHnSparseF,
+               {axisCent, axisDR, axisCosTS});
+    histos.add("ME/RecoCorr/Atlas/h2f_n2_dltaR_LaPLaP",
+               "#rho_{2} #Lambda#Lambda [Atlas]", kTHnSparseF,
+               {axisCent, axisDR, axisCosTS});
+    histos.add("ME/RecoCorr/Atlas/h2f_n2_dltaR_LaMLaM",
+               "#rho_{2} #bar{#Lambda}#bar{#Lambda} [Atlas]", kTHnSparseF,
+               {axisCent, axisDR, axisCosTS});
+
+    histos.add("ME/RecoCorr/Atlas/h2f_n2_ctheta_LaPLaM",
+               "#rho_{2} #Lambda#bar{#Lambda} [Atlas]", kTHnSparseF,
+               {axisCent, axisDRap, axisDPhi, axisCosTS});
+    histos.add("ME/RecoCorr/Atlas/h2f_n2_ctheta_LaMLaP",
+               "#rho_{2} #bar{#Lambda}#Lambda [Atlas]", kTHnSparseF,
+               {axisCent, axisDRap, axisDPhi, axisCosTS});
+    histos.add("ME/RecoCorr/Atlas/h2f_n2_ctheta_LaPLaP",
+               "#rho_{2} #Lambda#Lambda [Atlas]", kTHnSparseF,
+               {axisCent, axisDRap, axisDPhi, axisCosTS});
+    histos.add("ME/RecoCorr/Atlas/h2f_n2_ctheta_LaMLaM",
+               "#rho_{2} #bar{#Lambda}#bar{#Lambda} [Atlas]", kTHnSparseF,
+               {axisCent, axisDRap, axisDPhi, axisCosTS});
 
     histos.addClone("SE/RecoCorr/Star/", "SE/RecoCorrBkgSigSB/Star/");
     histos.addClone("SE/RecoCorr/Atlas/", "SE/RecoCorrBkgSigSB/Atlas/");
@@ -1526,7 +1860,8 @@ struct LambdaSpinPolarization {
     return (m >= cMassHistMin.value && m <= cMassHistMax.value);
   }
 
-  void getBoostVector(std::array<float, 4> const& p, std::array<float, 3>& v, bool inverseBoostFlag = true)
+  void getBoostVector(std::array<float, 4> const& p, std::array<float, 3>& v,
+                      bool inverseBoostFlag = true)
   {
     int n = p.size();
     for (int i = 0; i < n - 1; ++i) {
@@ -1551,7 +1886,8 @@ struct LambdaSpinPolarization {
   }
 
   // cos of the opening angle between the two proton three-momenta.
-  static float cosOpeningAngle(std::array<float, 4> const& a, std::array<float, 4> const& b)
+  static float cosOpeningAngle(std::array<float, 4> const& a,
+                               std::array<float, 4> const& b)
   {
     std::array<float, 3> n1 = {a[0], a[1], a[2]}, n2 = {b[0], b[1], b[2]};
     return RecoDecay::dotProd(n1, n2) /
@@ -1559,18 +1895,22 @@ struct LambdaSpinPolarization {
             RecoDecay::sqrtSumOfSquares(n2[0], n2[1], n2[2]));
   }
 
-  float cosThetaStarAtlas(std::array<float, 4> const& l1, std::array<float, 4> const& l2,
-                          std::array<float, 4> const& pr1, std::array<float, 4> const& pr2)
+  float cosThetaStarAtlas(std::array<float, 4> const& l1,
+                          std::array<float, 4> const& l2,
+                          std::array<float, 4> const& pr1,
+                          std::array<float, 4> const& pr2)
   {
     auto l1a = l1;
     auto l2a = l2;
     auto pr1a = pr1;
     auto pr2a = pr2;
 
-    const float mPair = RecoDecay::m(std::array{std::array{l1a[0], l1a[1], l1a[2]},
-                                                std::array{l2a[0], l2a[1], l2a[2]}},
-                                     std::array{l1a[3], l2a[3]});
-    std::array<float, 4> llpair = {l1a[0] + l2a[0], l1a[1] + l2a[1], l1a[2] + l2a[2], mPair};
+    const float mPair =
+      RecoDecay::m(std::array{std::array{l1a[0], l1a[1], l1a[2]},
+                              std::array{l2a[0], l2a[1], l2a[2]}},
+                   std::array{l1a[3], l2a[3]});
+    std::array<float, 4> llpair = {l1a[0] + l2a[0], l1a[1] + l2a[1],
+                                   l1a[2] + l2a[2], mPair};
     std::array<float, 3> vPair{};
     getBoostVector(llpair, vPair, cInvBoostFlag);
     boost(l1a, vPair);
@@ -1585,8 +1925,10 @@ struct LambdaSpinPolarization {
     return cosOpeningAngle(pr1a, pr2a);
   }
 
-  float cosThetaStarStar(std::array<float, 4> const& l1, std::array<float, 4> const& l2,
-                         std::array<float, 4> const& pr1, std::array<float, 4> const& pr2)
+  float cosThetaStarStar(std::array<float, 4> const& l1,
+                         std::array<float, 4> const& l2,
+                         std::array<float, 4> const& pr1,
+                         std::array<float, 4> const& pr2)
   {
     auto pr1s = pr1;
     auto pr2s = pr2;
@@ -1601,16 +1943,16 @@ struct LambdaSpinPolarization {
   template <ParticlePairType part_pair, typename U>
   void fillPairHistos(U const& p1, U const& p2)
   {
-    static constexpr std::array<std::string_view, 4> SubDir = {"LaPLaM", "LaMLaP", "LaPLaP", "LaMLaM"};
+    static constexpr std::array<std::string_view, 4> SubDir = {
+      "LaPLaM", "LaMLaP", "LaPLaP", "LaMLaM"};
 
-    constexpr bool IsSigSB = (part_pair == kLambdaSBAntiLambda ||
-                              part_pair == kAntiLambdaSBLambda ||
-                              part_pair == kLambdaSBLambda ||
-                              part_pair == kAntiLambdaSBAntiLambda);
-    constexpr bool IsSBSB = (part_pair == kLambdaSBSBAntiLambda ||
-                             part_pair == kAntiLambdaSBSBLambda ||
-                             part_pair == kLambdaSBSBLambda ||
-                             part_pair == kAntiLambdaSBSBAntiLambda);
+    constexpr bool IsSigSB =
+      (part_pair == kLambdaSBAntiLambda || part_pair == kAntiLambdaSBLambda ||
+       part_pair == kLambdaSBLambda || part_pair == kAntiLambdaSBAntiLambda);
+    constexpr bool IsSBSB =
+      (part_pair == kLambdaSBSBAntiLambda ||
+       part_pair == kAntiLambdaSBSBLambda || part_pair == kLambdaSBSBLambda ||
+       part_pair == kAntiLambdaSBSBAntiLambda);
 
     constexpr int Idx = IsSigSB  ? static_cast<int>(part_pair) - 4
                         : IsSBSB ? static_cast<int>(part_pair) - 8
@@ -1629,56 +1971,85 @@ struct LambdaSpinPolarization {
       float ctheta = cosThetaStarAtlas(l1, l2, pr1, pr2);
       if constexpr (!IsSigSB && !IsSBSB) {
         histos.fill(HIST("SE/Reco/Atlas/h2f_n2_mass_") + HIST(SubDir[Idx]),
-                    cent, p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi, dR, ctheta);
-        histos.fill(HIST("SE/RecoCorr/Atlas/h2f_n2_ctheta_") + HIST(SubDir[Idx]), cent, drap, dphi, ctheta);
-        histos.fill(HIST("SE/RecoCorr/Atlas/h2f_n2_dltaR_") + HIST(SubDir[Idx]), cent, dR, ctheta);
+                    cent, p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi,
+                    dR, ctheta);
+        histos.fill(HIST("SE/RecoCorr/Atlas/h2f_n2_ctheta_") +
+                      HIST(SubDir[Idx]),
+                    cent, drap, dphi, ctheta);
+        histos.fill(HIST("SE/RecoCorr/Atlas/h2f_n2_dltaR_") + HIST(SubDir[Idx]),
+                    cent, dR, ctheta);
       } else if constexpr (IsSigSB) {
-        histos.fill(HIST("SE/RecoBkgSigSB/Atlas/h2f_n2_mass_") + HIST(SubDir[Idx]),
-                    cent, p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi, dR, ctheta);
-        histos.fill(HIST("SE/RecoCorrBkgSigSB/Atlas/h2f_n2_ctheta_") + HIST(SubDir[Idx]), cent, drap, dphi, ctheta);
-        histos.fill(HIST("SE/RecoCorrBkgSigSB/Atlas/h2f_n2_dltaR_") + HIST(SubDir[Idx]), cent, dR, ctheta);
+        histos.fill(HIST("SE/RecoBkgSigSB/Atlas/h2f_n2_mass_") +
+                      HIST(SubDir[Idx]),
+                    cent, p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi,
+                    dR, ctheta);
+        histos.fill(HIST("SE/RecoCorrBkgSigSB/Atlas/h2f_n2_ctheta_") +
+                      HIST(SubDir[Idx]),
+                    cent, drap, dphi, ctheta);
+        histos.fill(HIST("SE/RecoCorrBkgSigSB/Atlas/h2f_n2_dltaR_") +
+                      HIST(SubDir[Idx]),
+                    cent, dR, ctheta);
       } else {
-        histos.fill(HIST("SE/RecoBkgSBSB/Atlas/h2f_n2_mass_") + HIST(SubDir[Idx]),
-                    cent, p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi, dR, ctheta);
-        histos.fill(HIST("SE/RecoCorrBkgSBSB/Atlas/h2f_n2_ctheta_") + HIST(SubDir[Idx]), cent, drap, dphi, ctheta);
-        histos.fill(HIST("SE/RecoCorrBkgSBSB/Atlas/h2f_n2_dltaR_") + HIST(SubDir[Idx]), cent, dR, ctheta);
+        histos.fill(
+          HIST("SE/RecoBkgSBSB/Atlas/h2f_n2_mass_") + HIST(SubDir[Idx]), cent,
+          p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi, dR, ctheta);
+        histos.fill(HIST("SE/RecoCorrBkgSBSB/Atlas/h2f_n2_ctheta_") +
+                      HIST(SubDir[Idx]),
+                    cent, drap, dphi, ctheta);
+        histos.fill(HIST("SE/RecoCorrBkgSBSB/Atlas/h2f_n2_dltaR_") +
+                      HIST(SubDir[Idx]),
+                    cent, dR, ctheta);
       }
     }
 
     if (cDoStarMethod) {
       float ctheta = cosThetaStarStar(l1, l2, pr1, pr2);
       if constexpr (!IsSigSB && !IsSBSB) {
-        histos.fill(HIST("SE/Reco/Star/h2f_n2_mass_") + HIST(SubDir[Idx]),
-                    cent, p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi, dR, ctheta);
-        histos.fill(HIST("SE/RecoCorr/Star/h2f_n2_ctheta_") + HIST(SubDir[Idx]), cent, drap, dphi, ctheta);
-        histos.fill(HIST("SE/RecoCorr/Star/h2f_n2_dltaR_") + HIST(SubDir[Idx]), cent, dR, ctheta);
+        histos.fill(HIST("SE/Reco/Star/h2f_n2_mass_") + HIST(SubDir[Idx]), cent,
+                    p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi, dR,
+                    ctheta);
+        histos.fill(HIST("SE/RecoCorr/Star/h2f_n2_ctheta_") + HIST(SubDir[Idx]),
+                    cent, drap, dphi, ctheta);
+        histos.fill(HIST("SE/RecoCorr/Star/h2f_n2_dltaR_") + HIST(SubDir[Idx]),
+                    cent, dR, ctheta);
       } else if constexpr (IsSigSB) {
-        histos.fill(HIST("SE/RecoBkgSigSB/Star/h2f_n2_mass_") + HIST(SubDir[Idx]),
-                    cent, p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi, dR, ctheta);
-        histos.fill(HIST("SE/RecoCorrBkgSigSB/Star/h2f_n2_ctheta_") + HIST(SubDir[Idx]), cent, drap, dphi, ctheta);
-        histos.fill(HIST("SE/RecoCorrBkgSigSB/Star/h2f_n2_dltaR_") + HIST(SubDir[Idx]), cent, dR, ctheta);
+        histos.fill(
+          HIST("SE/RecoBkgSigSB/Star/h2f_n2_mass_") + HIST(SubDir[Idx]), cent,
+          p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi, dR, ctheta);
+        histos.fill(HIST("SE/RecoCorrBkgSigSB/Star/h2f_n2_ctheta_") +
+                      HIST(SubDir[Idx]),
+                    cent, drap, dphi, ctheta);
+        histos.fill(HIST("SE/RecoCorrBkgSigSB/Star/h2f_n2_dltaR_") +
+                      HIST(SubDir[Idx]),
+                    cent, dR, ctheta);
       } else {
-        histos.fill(HIST("SE/RecoBkgSBSB/Star/h2f_n2_mass_") + HIST(SubDir[Idx]),
-                    cent, p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi, dR, ctheta);
-        histos.fill(HIST("SE/RecoCorrBkgSBSB/Star/h2f_n2_ctheta_") + HIST(SubDir[Idx]), cent, drap, dphi, ctheta);
-        histos.fill(HIST("SE/RecoCorrBkgSBSB/Star/h2f_n2_dltaR_") + HIST(SubDir[Idx]), cent, dR, ctheta);
+        histos.fill(
+          HIST("SE/RecoBkgSBSB/Star/h2f_n2_mass_") + HIST(SubDir[Idx]), cent,
+          p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi, dR, ctheta);
+        histos.fill(HIST("SE/RecoCorrBkgSBSB/Star/h2f_n2_ctheta_") +
+                      HIST(SubDir[Idx]),
+                    cent, drap, dphi, ctheta);
+        histos.fill(HIST("SE/RecoCorrBkgSBSB/Star/h2f_n2_dltaR_") +
+                      HIST(SubDir[Idx]),
+                    cent, dR, ctheta);
       }
     }
   }
 
   template <ParticlePairType part_pair>
-  void fillPairHistosWeighted(PoolTrack const& p1, PoolTrack const& p2, float w)
+  void fillPairHistosWeighted(PoolTrack const& p1, PoolTrack const& p2,
+                              float w)
   {
-    static constexpr std::array<std::string_view, 4> SubDir = {"LaPLaM", "LaMLaP", "LaPLaP", "LaMLaM"};
+    static constexpr std::array<std::string_view, 4> SubDir = {
+      "LaPLaM", "LaMLaP", "LaPLaP", "LaMLaM"};
 
-    constexpr bool IsSigSB = (part_pair == kLambdaSBAntiLambda ||
-                              part_pair == kAntiLambdaSBLambda ||
-                              part_pair == kLambdaSBLambda ||
-                              part_pair == kAntiLambdaSBAntiLambda);
-    constexpr bool IsSBSB = (part_pair == kLambdaSBSBAntiLambda ||
-                             part_pair == kAntiLambdaSBSBLambda ||
-                             part_pair == kLambdaSBSBLambda ||
-                             part_pair == kAntiLambdaSBSBAntiLambda);
+    constexpr bool IsSigSB =
+      (part_pair == kLambdaSBAntiLambda || part_pair == kAntiLambdaSBLambda ||
+       part_pair == kLambdaSBLambda || part_pair == kAntiLambdaSBAntiLambda);
+    constexpr bool IsSBSB =
+      (part_pair == kLambdaSBSBAntiLambda ||
+       part_pair == kAntiLambdaSBSBLambda || part_pair == kLambdaSBSBLambda ||
+       part_pair == kAntiLambdaSBSBAntiLambda);
 
     constexpr int Idx = IsSigSB  ? static_cast<int>(part_pair) - 4
                         : IsSBSB ? static_cast<int>(part_pair) - 8
@@ -1698,24 +2069,33 @@ struct LambdaSpinPolarization {
 
       if constexpr (!IsSigSB && !IsSBSB) {
         histos.fill(HIST("ME/Reco/Atlas/h2f_n2_mass_") + HIST(SubDir[Idx]),
-                    cent, p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi, dR, ctheta, w);
-        histos.fill(HIST("ME/RecoCorr/Atlas/h2f_n2_ctheta_") + HIST(SubDir[Idx]),
+                    cent, p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi,
+                    dR, ctheta, w);
+        histos.fill(HIST("ME/RecoCorr/Atlas/h2f_n2_ctheta_") +
+                      HIST(SubDir[Idx]),
                     cent, drap, dphi, ctheta, w);
         histos.fill(HIST("ME/RecoCorr/Atlas/h2f_n2_dltaR_") + HIST(SubDir[Idx]),
                     cent, dR, ctheta, w);
       } else if constexpr (IsSigSB) {
-        histos.fill(HIST("ME/RecoBkgSigSB/Atlas/h2f_n2_mass_") + HIST(SubDir[Idx]),
-                    cent, p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi, dR, ctheta, w);
-        histos.fill(HIST("ME/RecoCorrBkgSigSB/Atlas/h2f_n2_ctheta_") + HIST(SubDir[Idx]),
+        histos.fill(HIST("ME/RecoBkgSigSB/Atlas/h2f_n2_mass_") +
+                      HIST(SubDir[Idx]),
+                    cent, p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi,
+                    dR, ctheta, w);
+        histos.fill(HIST("ME/RecoCorrBkgSigSB/Atlas/h2f_n2_ctheta_") +
+                      HIST(SubDir[Idx]),
                     cent, drap, dphi, ctheta, w);
-        histos.fill(HIST("ME/RecoCorrBkgSigSB/Atlas/h2f_n2_dltaR_") + HIST(SubDir[Idx]),
+        histos.fill(HIST("ME/RecoCorrBkgSigSB/Atlas/h2f_n2_dltaR_") +
+                      HIST(SubDir[Idx]),
                     cent, dR, ctheta, w);
       } else {
-        histos.fill(HIST("ME/RecoBkgSBSB/Atlas/h2f_n2_mass_") + HIST(SubDir[Idx]),
-                    cent, p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi, dR, ctheta, w);
-        histos.fill(HIST("ME/RecoCorrBkgSBSB/Atlas/h2f_n2_ctheta_") + HIST(SubDir[Idx]),
+        histos.fill(
+          HIST("ME/RecoBkgSBSB/Atlas/h2f_n2_mass_") + HIST(SubDir[Idx]), cent,
+          p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi, dR, ctheta, w);
+        histos.fill(HIST("ME/RecoCorrBkgSBSB/Atlas/h2f_n2_ctheta_") +
+                      HIST(SubDir[Idx]),
                     cent, drap, dphi, ctheta, w);
-        histos.fill(HIST("ME/RecoCorrBkgSBSB/Atlas/h2f_n2_dltaR_") + HIST(SubDir[Idx]),
+        histos.fill(HIST("ME/RecoCorrBkgSBSB/Atlas/h2f_n2_dltaR_") +
+                      HIST(SubDir[Idx]),
                     cent, dR, ctheta, w);
       }
     }
@@ -1724,25 +2104,32 @@ struct LambdaSpinPolarization {
       float ctheta = cosThetaStarStar(l1, l2, pr1, pr2);
 
       if constexpr (!IsSigSB && !IsSBSB) {
-        histos.fill(HIST("ME/Reco/Star/h2f_n2_mass_") + HIST(SubDir[Idx]),
-                    cent, p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi, dR, ctheta, w);
+        histos.fill(HIST("ME/Reco/Star/h2f_n2_mass_") + HIST(SubDir[Idx]), cent,
+                    p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi, dR,
+                    ctheta, w);
         histos.fill(HIST("ME/RecoCorr/Star/h2f_n2_ctheta_") + HIST(SubDir[Idx]),
                     cent, drap, dphi, ctheta, w);
         histos.fill(HIST("ME/RecoCorr/Star/h2f_n2_dltaR_") + HIST(SubDir[Idx]),
                     cent, dR, ctheta, w);
       } else if constexpr (IsSigSB) {
-        histos.fill(HIST("ME/RecoBkgSigSB/Star/h2f_n2_mass_") + HIST(SubDir[Idx]),
-                    cent, p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi, dR, ctheta, w);
-        histos.fill(HIST("ME/RecoCorrBkgSigSB/Star/h2f_n2_ctheta_") + HIST(SubDir[Idx]),
+        histos.fill(
+          HIST("ME/RecoBkgSigSB/Star/h2f_n2_mass_") + HIST(SubDir[Idx]), cent,
+          p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi, dR, ctheta, w);
+        histos.fill(HIST("ME/RecoCorrBkgSigSB/Star/h2f_n2_ctheta_") +
+                      HIST(SubDir[Idx]),
                     cent, drap, dphi, ctheta, w);
-        histos.fill(HIST("ME/RecoCorrBkgSigSB/Star/h2f_n2_dltaR_") + HIST(SubDir[Idx]),
+        histos.fill(HIST("ME/RecoCorrBkgSigSB/Star/h2f_n2_dltaR_") +
+                      HIST(SubDir[Idx]),
                     cent, dR, ctheta, w);
       } else {
-        histos.fill(HIST("ME/RecoBkgSBSB/Star/h2f_n2_mass_") + HIST(SubDir[Idx]),
-                    cent, p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi, dR, ctheta, w);
-        histos.fill(HIST("ME/RecoCorrBkgSBSB/Star/h2f_n2_ctheta_") + HIST(SubDir[Idx]),
+        histos.fill(
+          HIST("ME/RecoBkgSBSB/Star/h2f_n2_mass_") + HIST(SubDir[Idx]), cent,
+          p1.mass(), p2.mass(), p1.pt(), p2.pt(), drap, dphi, dR, ctheta, w);
+        histos.fill(HIST("ME/RecoCorrBkgSBSB/Star/h2f_n2_ctheta_") +
+                      HIST(SubDir[Idx]),
                     cent, drap, dphi, ctheta, w);
-        histos.fill(HIST("ME/RecoCorrBkgSBSB/Star/h2f_n2_dltaR_") + HIST(SubDir[Idx]),
+        histos.fill(HIST("ME/RecoCorrBkgSBSB/Star/h2f_n2_dltaR_") +
+                      HIST(SubDir[Idx]),
                     cent, dR, ctheta, w);
       }
     }
@@ -1750,8 +2137,7 @@ struct LambdaSpinPolarization {
 
   template <ParticlePairType part_pair_sig,
             ParticlePairType part_pair_bkg_sigsb,
-            ParticlePairType part_pair_bkg_sbsb,
-            bool samelambda, typename T>
+            ParticlePairType part_pair_bkg_sbsb, bool samelambda, typename T>
   void analyzePairsWithMassWindow(T const& trks_1, T const& trks_2)
   {
     for (auto const& trk_1 : trks_1) {
@@ -1789,8 +2175,7 @@ struct LambdaSpinPolarization {
 
   template <ParticlePairType part_pair_sig,
             ParticlePairType part_pair_bkg_sigsb,
-            ParticlePairType part_pair_bkg_sbsb,
-            bool samelambda, typename T>
+            ParticlePairType part_pair_bkg_sbsb, bool samelambda, typename T>
   void analyzePairsME(T const& trks_1, T const& trks_2)
   {
 
@@ -1830,8 +2215,7 @@ struct LambdaSpinPolarization {
 
   template <ParticlePairType part_pair_sig,
             ParticlePairType part_pair_bkg_sigsb,
-            ParticlePairType part_pair_bkg_sbsb,
-            bool samelambda, typename T>
+            ParticlePairType part_pair_bkg_sbsb, bool samelambda, typename T>
   void analyzePairsMEKinematic(T const& se_trks_1, T const& se_trks_2,
                                T const& me_pool_1, T const& me_pool_2)
   {
@@ -1879,7 +2263,8 @@ struct LambdaSpinPolarization {
           for (auto const& meP : meVec2) {
             if (std::abs(meP.pt() - p2.pt()) < cMaxDeltaPt &&
                 std::abs(meP.rap() - p2.rap()) < cMaxDeltaRap &&
-                std::abs(RecoDecay::constrainAngle(meP.phi() - p2.phi(), -PI)) < cMaxDeltaPhi) {
+                std::abs(RecoDecay::constrainAngle(meP.phi() - p2.phi(), -PI)) <
+                  cMaxDeltaPhi) {
               matchA.push_back(meP);
             }
           }
@@ -1907,7 +2292,8 @@ struct LambdaSpinPolarization {
           for (auto const& meP : meVec1) {
             if (std::abs(meP.pt() - p1.pt()) < cMaxDeltaPt &&
                 std::abs(meP.rap() - p1.rap()) < cMaxDeltaRap &&
-                std::abs(RecoDecay::constrainAngle(meP.phi() - p1.phi(), -PI)) < cMaxDeltaPhi) {
+                std::abs(RecoDecay::constrainAngle(meP.phi() - p1.phi(), -PI)) <
+                  cMaxDeltaPhi) {
               matchB.push_back(meP);
             }
           }
@@ -1938,9 +2324,11 @@ struct LambdaSpinPolarization {
   // O2 framework declarations
   // =========================================================================
   using LambdaCollisions = aod::LambdaCollisions;
+  using LambdaMcGenCollisions = aod::LambdaMcGenCollisions;
   using LambdaTracks = soa::Join<aod::LambdaTracks, aod::LambdaTracksExt>;
 
-  Preslice<LambdaTracks> perCollisionLambda = aod::lambdatrack::lambdaCollisionId;
+  Preslice<LambdaTracks> perCollisionLambda =
+    aod::lambdatrack::lambdaCollisionId;
   SliceCache cache;
 
   Partition<LambdaTracks> partLambdaTracks =
@@ -1953,10 +2341,21 @@ struct LambdaSpinPolarization {
     (aod::lambdatrackext::trueLambdaFlag == true) &&
     (aod::lambdatrack::v0PrmScd == (int8_t)kPrimary);
 
+  SliceCache cachemc;
+
+  Partition<aod::LambdaMcGenTracks> partMcLambdaTracks =
+    (aod::lambdatrack::v0Type == (int8_t)kLambda) &&
+    (aod::lambdatrack::v0PrmScd == (int8_t)kPrimary);
+
+  Partition<aod::LambdaMcGenTracks> partMcAntiLambdaTracks =
+    (aod::lambdatrack::v0Type == (int8_t)kAntiLambda) &&
+    (aod::lambdatrack::v0PrmScd == (int8_t)kPrimary);
+
   void processDummy(LambdaCollisions::iterator const&) {}
   PROCESS_SWITCH(LambdaSpinPolarization, processDummy, "Dummy", false);
 
-  void processDataReco(LambdaCollisions::iterator const& collision, LambdaTracks const&)
+  void processDataReco(LambdaCollisions::iterator const& collision,
+                       LambdaTracks const&)
   {
     cent = collision.cent();
     auto lTrks = partLambdaTracks->sliceByCached(
@@ -1964,25 +2363,33 @@ struct LambdaSpinPolarization {
     auto alTrks = partAntiLambdaTracks->sliceByCached(
       aod::lambdatrack::lambdaCollisionId, collision.globalIndex(), cache);
 
-    analyzePairsWithMassWindow<kLambdaAntiLambda, kLambdaSBAntiLambda, kLambdaSBSBAntiLambda, false>(lTrks, alTrks);
-    analyzePairsWithMassWindow<kAntiLambdaLambda, kAntiLambdaSBLambda, kAntiLambdaSBSBLambda, false>(alTrks, lTrks);
-    analyzePairsWithMassWindow<kLambdaLambda, kLambdaSBLambda, kLambdaSBSBLambda, true>(lTrks, lTrks);
-    analyzePairsWithMassWindow<kAntiLambdaAntiLambda, kAntiLambdaSBAntiLambda, kAntiLambdaSBSBAntiLambda, true>(alTrks, alTrks);
+    analyzePairsWithMassWindow<kLambdaAntiLambda, kLambdaSBAntiLambda,
+                               kLambdaSBSBAntiLambda, false>(lTrks, alTrks);
+    analyzePairsWithMassWindow<kAntiLambdaLambda, kAntiLambdaSBLambda,
+                               kAntiLambdaSBSBLambda, false>(alTrks, lTrks);
+    analyzePairsWithMassWindow<kLambdaLambda, kLambdaSBLambda,
+                               kLambdaSBSBLambda, true>(lTrks, lTrks);
+    analyzePairsWithMassWindow<kAntiLambdaAntiLambda, kAntiLambdaSBAntiLambda,
+                               kAntiLambdaSBSBAntiLambda, true>(alTrks, alTrks);
   }
-  PROCESS_SWITCH(LambdaSpinPolarization, processDataReco, "SE only (data/MCReco)", false);
+  PROCESS_SWITCH(LambdaSpinPolarization, processDataReco,
+                 "SE only (data/MCReco)", false);
 
   struct GetMultiplicity {
     float operator()(auto const& col) const { return col.cent(); }
   };
-  using MixedBinning = FlexibleBinningPolicy<std::tuple<GetMultiplicity>,
-                                             o2::aod::collision::PosZ,
-                                             GetMultiplicity>;
-  MixedBinning binningOnVtxAndMult{{GetMultiplicity{}}, {axisVtxZME, axisCentME}, true};
+  using MixedBinning =
+    FlexibleBinningPolicy<std::tuple<GetMultiplicity>,
+                          o2::aod::collision::PosZ, GetMultiplicity>;
+  MixedBinning binningOnVtxAndMult{
+    {GetMultiplicity{}},
+    {axisVtxZME, axisCentME},
+    true};
 
   void processDataRecoMixed(LambdaCollisions const& col, LambdaTracks const&)
   {
-    for (auto const& [col1, col2] :
-         soa::selfCombinations(binningOnVtxAndMult, mixingParameter, -1, col, col)) {
+    for (auto const& [col1, col2] : soa::selfCombinations(
+           binningOnVtxAndMult, mixingParameter, -1, col, col)) {
       if (col1.globalIndex() == col2.globalIndex()) {
         continue;
       }
@@ -1999,28 +2406,29 @@ struct LambdaSpinPolarization {
         aod::lambdatrack::lambdaCollisionId, col2.globalIndex(), cache);
 
       histos.fill(HIST("QA/ME/hLambdaMultVsCent"), col1.cent(), lTrks1.size());
-      histos.fill(HIST("QA/ME/hAntiLambdaMultVsCent"), col1.cent(), alTrks1.size());
+      histos.fill(HIST("QA/ME/hAntiLambdaMultVsCent"), col1.cent(),
+                  alTrks1.size());
 
       if (cMEMode == MEModeStandard) {
         analyzePairsME<kLambdaAntiLambda, kLambdaSBAntiLambda,
                        kLambdaSBSBAntiLambda, false>(lTrks1, alTrks2);
         analyzePairsME<kAntiLambdaLambda, kAntiLambdaSBLambda,
                        kAntiLambdaSBSBLambda, false>(alTrks1, lTrks2);
-        analyzePairsME<kLambdaLambda, kLambdaSBLambda,
-                       kLambdaSBSBLambda, false>(lTrks1, lTrks2);
+        analyzePairsME<kLambdaLambda, kLambdaSBLambda, kLambdaSBSBLambda,
+                       false>(lTrks1, lTrks2);
         analyzePairsME<kAntiLambdaAntiLambda, kAntiLambdaSBAntiLambda,
                        kAntiLambdaSBSBAntiLambda, false>(alTrks1, alTrks2);
 
       } else if (cMEMode == MEModeKinematic) {
         analyzePairsMEKinematic<kLambdaAntiLambda, kLambdaSBAntiLambda,
-                                kLambdaSBSBAntiLambda, false>(
-          lTrks1, alTrks1, lTrks2, alTrks2);
+                                kLambdaSBSBAntiLambda, false>(lTrks1, alTrks1,
+                                                              lTrks2, alTrks2);
         analyzePairsMEKinematic<kAntiLambdaLambda, kAntiLambdaSBLambda,
-                                kAntiLambdaSBSBLambda, false>(
-          alTrks1, lTrks1, alTrks2, lTrks2);
+                                kAntiLambdaSBSBLambda, false>(alTrks1, lTrks1,
+                                                              alTrks2, lTrks2);
         analyzePairsMEKinematic<kLambdaLambda, kLambdaSBLambda,
-                                kLambdaSBSBLambda, true>(
-          lTrks1, lTrks1, lTrks2, lTrks2);
+                                kLambdaSBSBLambda, true>(lTrks1, lTrks1, lTrks2,
+                                                         lTrks2);
         analyzePairsMEKinematic<kAntiLambdaAntiLambda, kAntiLambdaSBAntiLambda,
                                 kAntiLambdaSBSBAntiLambda, true>(
           alTrks1, alTrks1, alTrks2, alTrks2);
@@ -2042,29 +2450,61 @@ struct LambdaSpinPolarization {
       return;
     }
 
-    lambdaMixEvtCol(collision.index(), collision.cent(),
-                    collision.posZ(), collision.timeStamp());
+    lambdaMixEvtCol(collision.index(), collision.cent(), collision.posZ(),
+                    collision.timeStamp());
 
     for (auto const& track : lTrks) {
-      lambdaMixEvtTrk(collision.index(), track.globalIndex(),
-                      track.px(), track.py(), track.pz(), track.mass(),
-                      track.prPx(), track.prPy(), track.prPz(),
-                      track.v0Type(), collision.timeStamp());
+      lambdaMixEvtTrk(collision.index(), track.globalIndex(), track.px(),
+                      track.py(), track.pz(), track.mass(), track.prPx(),
+                      track.prPy(), track.prPz(), track.v0Type(),
+                      collision.timeStamp());
     }
     for (auto const& track : alTrks) {
-      lambdaMixEvtTrk(collision.index(), track.globalIndex(),
-                      track.px(), track.py(), track.pz(), track.mass(),
-                      track.prPx(), track.prPy(), track.prPz(),
-                      track.v0Type(), collision.timeStamp());
+      lambdaMixEvtTrk(collision.index(), track.globalIndex(), track.px(),
+                      track.py(), track.pz(), track.mass(), track.prPx(),
+                      track.prPy(), track.prPz(), track.v0Type(),
+                      collision.timeStamp());
     }
   }
   PROCESS_SWITCH(LambdaSpinPolarization, processDataRecoMixEvent,
                  "Mix-event table filling", false);
+
+  void processMcGenMixEvent(LambdaMcGenCollisions::iterator const& collision,
+                            aod::LambdaMcGenTracks const&)
+  {
+    auto lTrks = partMcLambdaTracks->sliceByCached(
+      aod::lambdamcgentrack::lambdaMcGenCollisionId, collision.globalIndex(),
+      cachemc);
+    auto alTrks = partMcAntiLambdaTracks->sliceByCached(
+      aod::lambdamcgentrack::lambdaMcGenCollisionId, collision.globalIndex(),
+      cachemc);
+
+    if (lTrks.size() == 0 && alTrks.size() == 0) {
+      return;
+    }
+
+    lambdaMixEvtMGCol(collision.globalIndex(), collision.cent(),
+                      collision.posZ(), collision.timeStamp());
+
+    for (auto const& track : lTrks) {
+      lambdaMixEvtMGTrk(collision.globalIndex(), track.globalIndex(),
+                        track.px(), track.py(), track.pz(), track.mass(),
+                        track.prPx(), track.prPy(), track.prPz(),
+                        track.v0Type(), collision.timeStamp());
+    }
+    for (auto const& track : alTrks) {
+      lambdaMixEvtMGTrk(collision.globalIndex(), track.globalIndex(),
+                        track.px(), track.py(), track.pz(), track.mass(),
+                        track.prPx(), track.prPy(), track.prPz(),
+                        track.v0Type(), collision.timeStamp());
+    }
+  }
+  PROCESS_SWITCH(LambdaSpinPolarization, processMcGenMixEvent,
+                 "Mix-event McGen table filling", false);
 };
 WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
 {
-  return WorkflowSpec{
-    adaptAnalysisTask<LambdaTableProducer>(cfgc),
-    adaptAnalysisTask<LambdaTracksExtProducer>(cfgc),
-    adaptAnalysisTask<LambdaSpinPolarization>(cfgc)};
+  return WorkflowSpec{adaptAnalysisTask<LambdaTableProducer>(cfgc),
+                      adaptAnalysisTask<LambdaTracksExtProducer>(cfgc),
+                      adaptAnalysisTask<LambdaSpinPolarization>(cfgc)};
 }