diff --git a/CEP_Jpsi2ll/DVJpsiCEP_AP.py b/CEP_Jpsi2ll/DVJpsiCEP_AP.py
new file mode 100644
index 0000000000000000000000000000000000000000..5da5587e85b3865ce138fbb6834698a6261064e4
--- /dev/null
+++ b/CEP_Jpsi2ll/DVJpsiCEP_AP.py
@@ -0,0 +1,250 @@
+from Configurables import DaVinci
+# Define some global variables, change accordingly
+year = DaVinci().DataType
+
+# Fill the chi_c_0,1,2 branches
+fillChic = True
+
+# Print extended information about the trigger TISTOS decissions
+allInfoTISTOS =False
+
+########################################################################################
+# Start making the ntuple
+from Gaudi.Configuration import *
+
+from Configurables import CondDB
+db = CondDB ( LatestGlobalTagByDataType = year )
+
+MessageSvc().Format = "% F%60W%S%7W%R%T %0W%M"
+from Configurables import PrintHeader, PrintDecayTree, StoreExplorerAlg, FilterDesktop, CheckSelResult, CombineParticles, EventNodeKiller, createODIN, EventTuple, TupleToolStripping
+
+from PhysSelPython.Wrappers import Selection, DataOnDemand, SelectionSequence
+from CommonParticles.Utils import *
+
+from Configurables import DiElectronMaker, ProtoParticleCALOFilter, DaVinciInit, TrackSelector, ParticleTransporter, LoKi__VertexFitter
+from Configurables import LoKi__HDRFilter       
+from GaudiKernel.SystemOfUnits import *
+from PhysConf.Selections import ( StrippingSelection ) 
+
+# Dielectron candidates
+dieLL = DiElectronMaker('StdDiElectronFromTracks')
+dieLL.Particle = "J/psi(1S)"
+# selector = trackSelector ( dieLL , trackTypes = ["Long","Upstream"] ) 
+dieLL.addTool( TrackSelector, name='TrackSelector' )
+dieLL.TrackSelector.TrackTypes = ["Long"]
+dieLL.addTool( ProtoParticleCALOFilter, name='Electron' )
+dieLL.Electron.Selection = ["RequiresDet='CALO' CombDLL(e-pi)>'-2.0'"]
+dieLL.DiElectronMassMax = 8000.*MeV
+dieLL.DiElectronMassMin = 100.*MeV
+dieLL.DiElectronPtMin = 0.*MeV
+
+# Converted-photon candidates using downstream electrons
+dieDD_homemade = DiElectronMaker('StdAllLooseGammaDD_homemade')
+dieDD_homemade.DecayDescriptor = "gamma -> e+ e-"
+selector_DD = trackSelector( dieDD_homemade ,trackTypes = ["Downstream"])
+dieDD_homemade.addTool( ProtoParticleCALOFilter, name = 'Electron' )
+dieDD_homemade.Electron.Selection = ["RequiresDet='CALO' CombDLL(e-pi)>'-2000.0'"]
+dieDD_homemade.DeltaY = 3.0
+dieDD_homemade.DeltaYmax = 200 * mm
+dieDD_homemade.DiElectronMassMax = 200.0 * MeV
+dieDD_homemade.DiElectronPtMin = 0.0 * MeV
+dieDD_homemade.ElectronPtMin = 0.0 * MeV
+#-- improved vertex fitter settings
+dieDD_homemade.UseCombinePair = True
+dieDD_homemade.addTool( ParticleTransporter,name = 'TransporterDie' )
+dieDD_homemade.TransporterDie.TrackExtrapolator = "TrackRungeKuttaExtrapolator"
+dieDD_homemade.ParticleCombiners.update( {"" : "LoKi::VertexFitter"} )
+dieDD_homemade.addTool( LoKi__VertexFitter )
+dieDD_homemade.LoKi__VertexFitter.addTool( ParticleTransporter,name = 'Transporter' )
+dieDD_homemade.LoKi__VertexFitter.Transporter.TrackExtrapolator = "TrackRungeKuttaExtrapolator"
+dieDD_homemade.LoKi__VertexFitter.DeltaDistance = 100 * mm
+locations = updateDoD ( dieDD_homemade )
+StdAllLooseGammaDD_homemade=dieDD_homemade
+
+# Dimuon candidates
+_StdLooseDiMuon = DataOnDemand( Location = 'Phys/StdLooseDiMuon/Particles' )
+_MuMu = FilterDesktop( "DiMuons", Code = "(M>0*MeV) & (M<8000*MeV)" )
+
+# Selections
+SelEE = Selection("SelEE", Algorithm = dieLL ) 
+SelMM = Selection("SelMM",  Algorithm = _MuMu, RequiredSelections = [ _StdLooseDiMuon ]) 
+SelGammaEE = Selection("SelGammaEE", Algorithm = dieDD_homemade )
+
+# Build a filter to choose candidates passing stripping/Hlt2
+if (year == "2016"):
+    filterEE = LoKi__HDRFilter( "filterEE",
+                                Code = "HLT_PASS('StrippingLowMultDiElectronLineDecision')",  # StrippingLowMultDiElectronLine 
+                                Location="/Event/Strip/Phys/DecReports")
+    SeqEE = SelectionSequence("SeqEE", TopSelection = SelEE, EventPreSelector=[filterEE] )
+    filterMM = LoKi__HDRFilter( "filterMM",
+                                Code = "HLT_PASS('StrippingLowMultDiMuonLineDecision') | HLT_PASS('StrippingLowMultMuonLineDecision')",  # StrippingLowMultDiMuonLine 
+                                Location="/Event/Strip/Phys/DecReports")
+    SeqMM = SelectionSequence("SeqMM", TopSelection = SelMM, EventPreSelector=[filterMM] )
+elif (year == "2017" or year == "2018"):
+
+    Hlt2FilterEE = LoKi__HDRFilter( "Hlt2FilterEE",
+                                Code = "HLT_PASS('Hlt2LowMultDiElectronDecision')",  # Hlt2LowMultDiElectronDecision 
+                                Location="Hlt2/DecReports")
+    SeqEE = SelectionSequence("SeqEE", TopSelection = SelEE, EventPreSelector=[Hlt2FilterEE] )
+    Hlt2FilterMM = LoKi__HDRFilter( "Hlt2FilterMM",
+                                Code = "HLT_PASS('Hlt2LowMultDiMuonDecision') | HLT_PASS('StrippingLowMultMuonLineDecision')",  # Hlt2LowMultDiMuonDecision 
+                                Location="Hlt2/DecReports")
+    SeqMM = SelectionSequence("SeqMM", TopSelection = SelMM, EventPreSelector=[Hlt2FilterMM] )
+    
+
+########################################################################################
+# Fill the chi_c_0,1,2 branches
+if (fillChic):
+    _Gamma = DataOnDemand( Location = 'Phys/StdVeryLooseAllPhotons/Particles' )
+    _Chic2JpsiMM = CombineParticles("chicMM",
+                             DecayDescriptor = "chi_c0(1P) -> J/psi(1S) gamma",
+                             DaughtersCuts = { "J/psi(1S)" :  "(M>2000) & (M<3800)", "gamma" : "ALL" },
+                             CombinationCut = "(AM<5500)",
+                             MotherCut = "(M<6000)")
+
+    _Chic2JpsiEE = CombineParticles("chicEE",
+                             DecayDescriptor = "chi_c0(1P) -> J/psi(1S) gamma",
+                             DaughtersCuts = { "J/psi(1S)" :  "(M>2000) & (M<3800)", "gamma" : "ALL" },
+                             CombinationCut = "(AM<5500)",
+                             MotherCut = "(M<6000)")
+
+    _ChicMMGammaEE = CombineParticles("chicMMGammaEE",
+                             DecayDescriptor = "chi_c0(1P) -> J/psi(1S) gamma",
+#                             DaughtersCuts = { "J/psi(1S)" :  "(M>2800) & (M<3800)", "gamma" : "(PT > 0 * MeV)" },
+                             DaughtersCuts = { "J/psi(1S)" :  "(M > 2800 * MeV) & (M < 3800 * MeV)", "gamma" : "(PT > 0 * MeV)" },
+                             CombinationCut = "(AM<4700)",
+                             MotherCut = "(M<4500) & (M - M1 > 0)")
+
+    _ChicEEGammaEE = CombineParticles("chicEEGammaEE",
+                             DecayDescriptor = "chi_c0(1P) -> J/psi(1S) gamma",
+#                             DaughtersCuts = { "J/psi(1S)" :  "(M>2800) & (M<3800)", "gamma" : "(PT > 0 * MeV)" },
+                             DaughtersCuts = { "J/psi(1S)" :  "(M > 2800 * MeV) & (M < 3800 * MeV)", "gamma" : "(PT > 0 * MeV)" },
+                             CombinationCut = "(AM<4700)",
+                             MotherCut = "(M<4500) & (M - M1 > 0)")
+
+
+    SelChicMM = Selection("SelChicMM",  Algorithm = _Chic2JpsiMM,  RequiredSelections = [ SelMM, _Gamma ])
+    SelChicEE = Selection("SelChicEE",  Algorithm = _Chic2JpsiEE,  RequiredSelections = [ SelEE, _Gamma ])
+    SelChicMMGammaEE = Selection("SelChicMMGammaEE", Algorithm = _ChicMMGammaEE, RequiredSelections = [SelMM, SelGammaEE ]) 
+    SelChicEEGammaEE = Selection("SelChicEEGammaEE", Algorithm = _ChicEEGammaEE, RequiredSelections = [SelEE, SelGammaEE ]) 
+
+    if (year == "2016"):
+        SeqChicMM = SelectionSequence("SeqChicMM", TopSelection = SelChicMM, EventPreSelector=[filterMM] )
+        SeqChicEE = SelectionSequence("SeqChicEE", TopSelection = SelChicEE, EventPreSelector=[filterEE] )
+        SeqChicMMGammaEE = SelectionSequence("SeqChicMMGammaEE", TopSelection = SelChicMMGammaEE, EventPreSelector=[filterMM] )
+        SeqChicEEGammaEE = SelectionSequence("SeqChicEEGammaEE", TopSelection = SelChicEEGammaEE, EventPreSelector=[filterEE] )
+    elif (year == "2017" or year == "2018"):
+        SeqChicMM = SelectionSequence("SeqChicMM", TopSelection = SelChicMM, EventPreSelector=[Hlt2FilterMM] )
+        SeqChicEE = SelectionSequence("SeqChicEE", TopSelection = SelChicEE, EventPreSelector=[Hlt2FilterEE] )
+        SeqChicMMGammaEE = SelectionSequence("SeqChicMMGammaEE", TopSelection = SelChicMMGammaEE, EventPreSelector=[Hlt2FilterMM] )
+        SeqChicEEGammaEE = SelectionSequence("SeqChicEEGammaEE", TopSelection = SelChicEEGammaEE, EventPreSelector=[Hlt2FilterEE] )
+
+########################################################################################
+
+# Needed for Herschel
+from Configurables import HCRawBankDecoder
+decoder = HCRawBankDecoder()
+CondDB().LocalTags["DQFLAGS"] = ["herschel-20161018"] # DQ masking runs where Herschel was absent
+
+# Fill ntuple
+DaVinci().appendToMainSequence( [ decoder ] )
+DaVinci().appendToMainSequence( [SeqEE.sequence() ])  
+DaVinci().appendToMainSequence( [SeqMM.sequence() ])   
+if (fillChic):
+    DaVinci().appendToMainSequence( [SeqChicMM.sequence() ])  
+    DaVinci().appendToMainSequence( [SeqChicEE.sequence() ])  
+    DaVinci().appendToMainSequence( [dieDD_homemade] )
+    DaVinci().appendToMainSequence( [SeqChicMMGammaEE.sequence() ])  
+    DaVinci().appendToMainSequence( [SeqChicEEGammaEE.sequence() ])  
+
+#import CEP_Jpsi2ll
+from CEP_Jpsi2ll.DiLeptonTuple import DiLeptonTuple as DLT
+DaVinci().appendToMainSequence( DLT.addTuple(name="SelEE", decay=DLT.Jpsi2ee, datatype="DST", Inputs = ['Phys/SelEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","NoCheckPV"] )  )  
+DaVinci().appendToMainSequence( DLT.addTuple(name="SelMM", decay=DLT.Jpsi2MuMu, datatype="DST", Inputs = ['Phys/SelMM/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","NoCheckPV"])  ) 
+
+if (fillChic):  
+    DaVinci().appendToMainSequence( DLT.addTuple(name="SelChicMM", decay=DLT.Chic02JpsiMuMuGamma, datatype="DST", Inputs = ['Phys/SelChicMM/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF","NoCheckPV"])  ) 
+    DaVinci().appendToMainSequence( DLT.addTuple(name="SelChicEE", decay=DLT.Chic02JpsiEEGamma, datatype="DST", Inputs = ['Phys/SelChicEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF","NoCheckPV"])  ) 
+    DaVinci().appendToMainSequence( DLT.addTuple(name="SelChicMMGammaEE", decay=DLT.Chic02JpsiMuMuGammaEE, datatype="DST", Inputs = ['Phys/SelChicMMGammaEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF","NoCheckPV"])  ) 
+    DaVinci().appendToMainSequence( DLT.addTuple(name="SelChicEEGammaEE", decay=DLT.Chic02JpsiEEGammaEE, datatype="DST", Inputs = ['Phys/SelChicEEGammaEE/Particles'], verbose = ["TrackInfo","ElectronVars"], options = ["CEP","DTF","NoCheckPV"])  ) 
+
+
+nev = -1
+DaVinci().EvtMax = nev
+DaVinci().PrintFreq =  10000
+DaVinci().Lumi = True
+DaVinci().TupleFile = "CEP.root"
+if ( nev>0 and nev<100): DaVinciInit("DaVinciInitAlg").PrintEvent = True
+
+from GaudiConf import IOHelper
+
+
+if (allInfoTISTOS):
+    # Extra options from Roel to try and figure out what TisTos is doing
+    from Configurables import ToolSvc, TriggerTisTos
+    ToolSvc().addTool(TriggerTisTos, "Hlt1TriggerTisTos")
+    ToolSvc().Hlt1TriggerTisTos.HltDecReportsLocation = 'Hlt1/DecReports'
+    ToolSvc().Hlt1TriggerTisTos.HltSelReportsLocation = 'Hlt1/SelReports'
+    
+    ToolSvc().addTool(TriggerTisTos, "Hlt2TriggerTisTos")
+    ToolSvc().Hlt2TriggerTisTos.HltDecReportsLocation = 'Hlt2/DecReports'
+    ToolSvc().Hlt2TriggerTisTos.HltSelReportsLocation = 'Hlt2/SelReports'
+    
+    from GaudiKernel.Configurable import applyConfigurableUsers
+    applyConfigurableUsers()
+    # assert(False)
+    
+    import GaudiPython as GP
+    import ROOT
+    appMgr = GP.AppMgr()
+    
+    location = 'Phys/SelEE'
+    
+    # Initialize the ApplicationMgr
+    appMgr.initialize()
+    
+    # Get some services
+    TES = appMgr.evtSvc()
+    toolSvc = appMgr.toolSvc()
+    
+    #LHCb = gbl.LHCb
+    
+    tttHlt1 = toolSvc.create('Hlt1TriggerTisTos', interface='ITriggerTisTos')
+    tttHlt2 = toolSvc.create('Hlt2TriggerTisTos', interface='ITriggerTisTos')
+    
+    Hlt1decisions = ['Hlt1LowMultMuonDecision' , 'Hlt1LowMultMaxVeloAndHerschelDecision' , 'Hlt1LowMultMaxVeloCutDecision' , 'Hlt1LowMultVeloCut_LeptonsDecision' , 'Hlt1LowMultPassThroughDecision' , 'Hlt1LowMultVeloAndHerschel_LeptonsDecision']
+    Hlt2decisions = ['Hlt2LowMultDiMuonDecision' , 'Hlt2LowMultDiElectronDecision']
+    
+    def run(evtNum):
+        appMgr.run(evtNum)
+        if not bool(TES['/Event']):
+            return (-1, None)
+    
+        particles = TES[location + '/Particles']
+        if not particles:
+            return (0, None)
+    
+        particles = [p for p in particles]
+        if not particles:
+            return (0, None)
+    
+        return (1, particles)
+    # Look for the first event with candidates and print its information 
+    while True:
+        s, particles = run(1)
+        if s == -1:
+            break
+        if s == 1:
+            break
+    
+    # Print the information
+    if s:
+        particle = particles[0]
+        tttHlt1.setOfflineInput(particle)
+        tttHlt2.setOfflineInput(particle)
+        for dec in Hlt1decisions:
+            tttHlt1.triggerTisTos(dec)
+            print(tttHlt1.analysisReportTrigger())
+        for dec in Hlt2decisions:
+            tttHlt2.triggerTisTos(dec)
+            print(tttHlt2.analysisReportTrigger())
diff --git a/CEP_Jpsi2ll/DataTypes/2016.py b/CEP_Jpsi2ll/DataTypes/2016.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ac76be65c4a91dda4ebc679d334716c3ebaf91f
--- /dev/null
+++ b/CEP_Jpsi2ll/DataTypes/2016.py
@@ -0,0 +1,2 @@
+from Configurables import DaVinci
+DaVinci().DataType = "2016"
diff --git a/CEP_Jpsi2ll/DataTypes/2017.py b/CEP_Jpsi2ll/DataTypes/2017.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb4fdc4f1d1a01e350ebb161543b96601e427cd4
--- /dev/null
+++ b/CEP_Jpsi2ll/DataTypes/2017.py
@@ -0,0 +1,2 @@
+from Configurables import DaVinci
+DaVinci().DataType = "2017"
diff --git a/CEP_Jpsi2ll/DataTypes/2018.py b/CEP_Jpsi2ll/DataTypes/2018.py
new file mode 100644
index 0000000000000000000000000000000000000000..d13c09afac6394a636c588ef80e5061a1bd83cb9
--- /dev/null
+++ b/CEP_Jpsi2ll/DataTypes/2018.py
@@ -0,0 +1,2 @@
+from Configurables import DaVinci
+DaVinci().DataType = "2018"
diff --git a/CEP_Jpsi2ll/DataTypes/mc_MagDown_2016.py b/CEP_Jpsi2ll/DataTypes/mc_MagDown_2016.py
new file mode 100644
index 0000000000000000000000000000000000000000..459b0190a598110061591fe317d9077125da89b7
--- /dev/null
+++ b/CEP_Jpsi2ll/DataTypes/mc_MagDown_2016.py
@@ -0,0 +1,4 @@
+from Configurables import DaVinci
+DaVinci().Simulation = True
+DaVinci().DDDBtag = 'dddb-20170721-3'
+DaVinci().CondDBtag = 'sim-20170721-2-vc-md100'
diff --git a/CEP_Jpsi2ll/DataTypes/mc_MagDown_2017.py b/CEP_Jpsi2ll/DataTypes/mc_MagDown_2017.py
new file mode 100644
index 0000000000000000000000000000000000000000..a945b470d6363ab6f89509fc345ffc74ecc7cea5
--- /dev/null
+++ b/CEP_Jpsi2ll/DataTypes/mc_MagDown_2017.py
@@ -0,0 +1,4 @@
+from Configurables import DaVinci
+DaVinci().Simulation = True
+DaVinci().DDDBtag = 'dddb-20170721-3'
+DaVinci().CondDBtag = 'sim-20190430-1-vc-md100'
diff --git a/CEP_Jpsi2ll/DataTypes/mc_MagDown_2018.py b/CEP_Jpsi2ll/DataTypes/mc_MagDown_2018.py
new file mode 100644
index 0000000000000000000000000000000000000000..5838d8ab96b636a1d41805a38452a0de24770353
--- /dev/null
+++ b/CEP_Jpsi2ll/DataTypes/mc_MagDown_2018.py
@@ -0,0 +1,4 @@
+from Configurables import DaVinci
+DaVinci().Simulation = True
+DaVinci().DDDBtag = 'dddb-20170721-3'
+DaVinci().CondDBtag = 'sim-20190430-vc-md100'
diff --git a/CEP_Jpsi2ll/DataTypes/mc_MagUp_2016.py b/CEP_Jpsi2ll/DataTypes/mc_MagUp_2016.py
new file mode 100644
index 0000000000000000000000000000000000000000..e34708fca507f0b1147b7bb5755d1c3b60e15709
--- /dev/null
+++ b/CEP_Jpsi2ll/DataTypes/mc_MagUp_2016.py
@@ -0,0 +1,4 @@
+from Configurables import DaVinci
+DaVinci().Simulation = True
+DaVinci().DDDBtag = 'dddb-20170721-3'
+DaVinci().CondDBtag = 'sim-20170721-2-vc-mu100'
diff --git a/CEP_Jpsi2ll/DataTypes/mc_MagUp_2017.py b/CEP_Jpsi2ll/DataTypes/mc_MagUp_2017.py
new file mode 100644
index 0000000000000000000000000000000000000000..51aaedd36a6563fd1d13e8bbe39980ed08ed9029
--- /dev/null
+++ b/CEP_Jpsi2ll/DataTypes/mc_MagUp_2017.py
@@ -0,0 +1,4 @@
+from Configurables import DaVinci
+DaVinci().Simulation = True
+DaVinci().DDDBtag = 'dddb-20170721-3'
+DaVinci().CondDBtag = 'sim-20190430-1-vc-mu100'
diff --git a/CEP_Jpsi2ll/DataTypes/mc_MagUp_2018.py b/CEP_Jpsi2ll/DataTypes/mc_MagUp_2018.py
new file mode 100644
index 0000000000000000000000000000000000000000..cd5a44f5708c015add46c0dd4c90c909a60a0706
--- /dev/null
+++ b/CEP_Jpsi2ll/DataTypes/mc_MagUp_2018.py
@@ -0,0 +1,4 @@
+from Configurables import DaVinci
+DaVinci().Simulation = True
+DaVinci().DDDBtag = 'dddb-20170721-3'
+DaVinci().CondDBtag = 'sim-20190430-vc-mu100'
diff --git a/CEP_Jpsi2ll/DataTypes/real_data.py b/CEP_Jpsi2ll/DataTypes/real_data.py
new file mode 100644
index 0000000000000000000000000000000000000000..53064162faecbf2f6200a2f380a5bf80d2f7f07e
--- /dev/null
+++ b/CEP_Jpsi2ll/DataTypes/real_data.py
@@ -0,0 +1,2 @@
+from Configurables import DaVinci
+DaVinci().Simulation = False
diff --git a/CEP_Jpsi2ll/DiLeptonTuple/AllTriggerLines.py b/CEP_Jpsi2ll/DiLeptonTuple/AllTriggerLines.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb35de3bf655b32cd7351297c08c000a12eebe88
--- /dev/null
+++ b/CEP_Jpsi2ll/DiLeptonTuple/AllTriggerLines.py
@@ -0,0 +1,1266 @@
+"""
+The big TCKs are for 2011:
+     0x790038 33%
+     0x760037 28%
+     0x730035 18%
+for 2012:
+     0x94003D 29%
+     0x97003D 29%
+     0x990042 34%
+
+for 2015:
+     0x010800A2
+for 2017 (Hlt1)
+     290461443
+for 2017 (Hlt2)
+     558962435
+for 2018
+     292820993 Hl1t
+     561190913 Hlt2
+
+s = set()
+for tck in [ 0x790038, 0x760037, 0x730035, 0x94003D, 0x97003D, 0x990042 ]:
+   s.update(set(getHlt1Lines(tck)))
+   s.update(set(getHlt2Lines(tck)))
+   print tck, len(s)
+
+l = list(s)
+l.sort()
+
+for i in l:
+    print '              "'+i.replace("Hlt::Line/",'              "')+'Decision", '
+
+ 
+s = set()
+for tck in [  0x010800A2, 290461443, 558962435,292820993, 561190913  ]:
+   s.update(set(getHlt1Lines(tck)))
+   s.update(set(getHlt2Lines(tck)))
+   print tck, len(s)
+
+l = list(s)
+l.sort()
+
+for i in l:
+    print '              "'+i.replace("Hlt::Line/",'              "')+'Decision", '
+
+
+
+"""
+def allRun2Lines():
+    return [  "Hlt1B2GammaGammaDecision", 
+              "Hlt1B2GammaGammaHighMassDecision", 
+              "Hlt1B2HH_LTUNB_KKDecision", 
+              "Hlt1B2HH_LTUNB_KPiDecision", 
+              "Hlt1B2HH_LTUNB_PiPiDecision", 
+              "Hlt1B2PhiGamma_LTUNBDecision", 
+              "Hlt1B2PhiPhi_LTUNBDecision", 
+              "Hlt1BeamGasBeam1Decision", 
+              "Hlt1BeamGasBeam1VeloOpenDecision", 
+              "Hlt1BeamGasBeam2Decision", 
+              "Hlt1BeamGasBeam2VeloOpenDecision", 
+              "Hlt1BeamGasCrossingEnhancedBeam1Decision", 
+              "Hlt1BeamGasCrossingEnhancedBeam2Decision", 
+              "Hlt1BeamGasCrossingForcedRecoDecision", 
+              "Hlt1BeamGasCrossingForcedRecoFullZDecision", 
+              "Hlt1BeamGasCrossingParasiticDecision", 
+              "Hlt1BeamGasHighRhoVerticesDecision", 
+              "Hlt1BeamGasNoBeamBeam1Decision", 
+              "Hlt1BeamGasNoBeamBeam2Decision", 
+              "Hlt1Bottomonium2KstarKstarDecision", 
+              "Hlt1Bottomonium2PhiPhiDecision", 
+              "Hlt1CEPDecision", 
+              "Hlt1CEPVeloCutDecision", 
+              "Hlt1CalibHighPTLowMultTrksDecision", 
+              "Hlt1CalibMuonAlignJpsiDecision", 
+              "Hlt1CalibRICHMirrorRICH1Decision", 
+              "Hlt1CalibRICHMirrorRICH2Decision", 
+              "Hlt1CalibTrackingKKDecision", 
+              "Hlt1CalibTrackingKPiDecision", 
+              "Hlt1CalibTrackingKPiDetachedDecision", 
+              "Hlt1CalibTrackingPiPiDecision", 
+              "Hlt1Ccbar2PhiPhiDecision", 
+              "Hlt1CharmXSecDecision", 
+              "Hlt1DiElectronHighMassDecision", 
+              "Hlt1DiElectronLowMassDecision", 
+              "Hlt1DiElectronLowMassNoIPDecision", 
+              "Hlt1DiMuonHighMassDecision", 
+              "Hlt1DiMuonLowMassDecision", 
+              "Hlt1DiMuonNoIPDecision", 
+              "Hlt1DiMuonNoIPSSDecision", 
+              "Hlt1DiMuonNoL0Decision", 
+              "Hlt1DiProtonDecision", 
+              "Hlt1DiProtonHighDecision", 
+              "Hlt1DiProtonLowMultDecision", 
+              "Hlt1ErrorEventDecision", 
+              "Hlt1GlobalDecision", 
+              "Hlt1IncPhiDecision", 
+              "Hlt1L0AnyDecision", 
+              "Hlt1L0AnyNoSPDDecision", 
+              "Hlt1LowMultMaxVeloAndHerschelDecision", 
+              "Hlt1LowMultMaxVeloCutDecision", 
+              "Hlt1LowMultMuonDecision", 
+              "Hlt1LowMultPassThroughDecision", 
+              "Hlt1LowMultVeloAndHerschel_HadronsDecision", 
+              "Hlt1LowMultVeloAndHerschel_LeptonsDecision", 
+              "Hlt1LowMultVeloCut_HadronsDecision", 
+              "Hlt1LowMultVeloCut_LeptonsDecision", 
+              "Hlt1LumiDecision", 
+              "Hlt1MBNoBiasDecision", 
+              "Hlt1MBNoBiasRateLimitedDecision", 
+              "Hlt1MultiDiMuonNoIPDecision", 
+              "Hlt1MultiMuonNoL0Decision", 
+              "Hlt1NoBiasEmptyEmptyDecision", 
+              "Hlt1NoBiasNonBeamBeamDecision", 
+              "Hlt1NoPVPassThroughDecision", 
+              "Hlt1ODINTechnicalDecision", 
+              "Hlt1SingleElectronNoIPDecision", 
+              "Hlt1SingleMuonHighPTDecision", 
+              "Hlt1SingleMuonHighPTNoMUIDDecision", 
+              "Hlt1SingleMuonNoIPDecision", 
+              "Hlt1Tell1ErrorDecision", 
+              "Hlt1TrackMVADecision", 
+              "Hlt1TrackMVATightDecision", 
+              "Hlt1TrackMuonDecision", 
+              "Hlt1TrackMuonMVADecision", 
+              "Hlt1TrackMuonNoSPDDecision", 
+              "Hlt1TwoTrackMVADecision", 
+              "Hlt1TwoTrackMVATightDecision", 
+              "Hlt1VeloClosingMicroBiasDecision", 
+              "Hlt2B2HHDecision", 
+              "Hlt2B2HH_B2HHDecision", 
+              "Hlt2B2HH_B2KKDecision", 
+              "Hlt2B2HH_B2KPiDecision", 
+              "Hlt2B2HH_B2PiPiDecision", 
+              "Hlt2B2HH_Lb2PKDecision", 
+              "Hlt2B2HH_Lb2PPiDecision", 
+              "Hlt2B2K0pi0Decision", 
+              "Hlt2B2KKDecision", 
+              "Hlt2B2KPiDecision", 
+              "Hlt2B2Kpi0Decision", 
+              "Hlt2B2Kpi0_B2K0pi0Decision", 
+              "Hlt2B2Kpi0_B2Kpi0Decision", 
+              "Hlt2B2OC_B2DK_D2HHTurboDecision", 
+              "Hlt2B2OC_B2DPi_D2HHTurboDecision", 
+              "Hlt2B2PiPiDecision", 
+              "Hlt2BHadB02PpPpPmPmDecision", 
+              "Hlt2Bc2JpsiXTFBc2JpsiMuXDecision", 
+              "Hlt2BeamGasDecision", 
+              "Hlt2BottomoniumDiKstarTurboDecision", 
+              "Hlt2BottomoniumDiPhiDecision", 
+              "Hlt2Bs2PhiPhiDecision", 
+              "Hlt2CaloPIDBd2KstGammaTurboCalibDecision", 
+              "Hlt2CaloPIDBs2PhiGammaTurboCalibDecision", 
+              "Hlt2CaloPIDD2EtapPiTurboCalibDecision", 
+              "Hlt2CaloPIDDsst2DsGammaTurboCalibDecision", 
+              "Hlt2CaloPIDDstD02KPiPi0_MergedPi0TurboCalibDecision", 
+              "Hlt2CaloPIDDstD02KPiPi0_ResolvedPi0TurboCalibDecision", 
+              "Hlt2CaloPIDEta2MuMuGammaTurboCalibDecision", 
+              "Hlt2CcDiHadronDiPhiDecision", 
+              "Hlt2CcDiHadronDiProtonDecision", 
+              "Hlt2CcDiHadronDiProtonHighTurboDecision", 
+              "Hlt2CcDiHadronDiProtonLowMultDecision", 
+              "Hlt2CcDiHadronDiProtonTurboDecision", 
+              "Hlt2CharmHadD02KPi_XSecTurboDecision", 
+              "Hlt2CharmHadD02KmPipTurboDecision", 
+              "Hlt2CharmHadDp2EtaKp_Eta2EmEpGDecision", 
+              "Hlt2CharmHadDp2EtaKp_Eta2PimPipGDecision", 
+              "Hlt2CharmHadDp2EtaKp_Eta2PimPipPi0_Pi0MDecision", 
+              "Hlt2CharmHadDp2EtaKp_Eta2PimPipPi0_Pi0RDecision", 
+              "Hlt2CharmHadDp2EtaPip_Eta2EmEpGDecision", 
+              "Hlt2CharmHadDp2EtaPip_Eta2PimPipGDecision", 
+              "Hlt2CharmHadDp2EtaPip_Eta2PimPipPi0_Pi0MDecision", 
+              "Hlt2CharmHadDp2EtaPip_Eta2PimPipPi0_Pi0RDecision", 
+              "Hlt2CharmHadDp2EtapKp_Etap2EtaPimPip_EtaRDecision", 
+              "Hlt2CharmHadDp2EtapKp_Etap2PimPipGDecision", 
+              "Hlt2CharmHadDp2EtapPip_Etap2EtaPimPip_EtaRDecision", 
+              "Hlt2CharmHadDp2EtapPip_Etap2PimPipGDecision", 
+              "Hlt2CharmHadDp2KS0KS0KpTurboDecision", 
+              "Hlt2CharmHadDp2KS0KS0PipTurboDecision", 
+              "Hlt2CharmHadDp2KS0KmKpPip_KS0DDTurboDecision", 
+              "Hlt2CharmHadDp2KS0KmKpPip_KS0LLTurboDecision", 
+              "Hlt2CharmHadDp2KS0KmPipPip_KS0DDTurboDecision", 
+              "Hlt2CharmHadDp2KS0KmPipPip_KS0LLTurboDecision", 
+              "Hlt2CharmHadDp2KS0KpKpPim_KS0DDTurboDecision", 
+              "Hlt2CharmHadDp2KS0KpKpPim_KS0LLTurboDecision", 
+              "Hlt2CharmHadDp2KS0KpPimPip_KS0DDTurboDecision", 
+              "Hlt2CharmHadDp2KS0KpPimPip_KS0LLTurboDecision", 
+              "Hlt2CharmHadDp2KS0Kp_KS0DDTurboDecision", 
+              "Hlt2CharmHadDp2KS0Kp_KS0LLTurboDecision", 
+              "Hlt2CharmHadDp2KS0PimPipPip_KS0DDTurboDecision", 
+              "Hlt2CharmHadDp2KS0PimPipPip_KS0LLTurboDecision", 
+              "Hlt2CharmHadDp2KS0Pip_KS0DDTurboDecision", 
+              "Hlt2CharmHadDp2KS0Pip_KS0LLTurboDecision", 
+              "Hlt2CharmHadDp2KmKmKpPipPipTurboDecision", 
+              "Hlt2CharmHadDp2KmKpPimPipPipTurboDecision", 
+              "Hlt2CharmHadDp2KmPimPipPipPipTurboDecision", 
+              "Hlt2CharmHadDp2KpPi0_Pi02EmEpGDecision", 
+              "Hlt2CharmHadDp2PipPi0_Pi02EmEpGDecision", 
+              "Hlt2CharmHadDpDsp2KmKpKpPi0Decision", 
+              "Hlt2CharmHadDpDsp2KmKpPipPi0Decision", 
+              "Hlt2CharmHadDpDsp2KmPipPipPi0Decision", 
+              "Hlt2CharmHadDpDsp2KpKpPimPi0Decision", 
+              "Hlt2CharmHadDpDsp2KpPimPipPi0Decision", 
+              "Hlt2CharmHadDpDsp2PimPipPipPi0Decision", 
+              "Hlt2CharmHadDpToKmKpKpTurboDecision", 
+              "Hlt2CharmHadDpToKmKpPipTurboDecision", 
+              "Hlt2CharmHadDpToKmPipPipTurboDecision", 
+              "Hlt2CharmHadDpToKmPipPip_ForKPiAsymDecision", 
+              "Hlt2CharmHadDpToKmPipPip_ForKPiAsymTurboDecision", 
+              "Hlt2CharmHadDpToKmPipPip_LTUNBTurboDecision", 
+              "Hlt2CharmHadDpToKpKpPimTurboDecision", 
+              "Hlt2CharmHadDpToKpPimPipTurboDecision", 
+              "Hlt2CharmHadDpToPimPipPipTurboDecision", 
+              "Hlt2CharmHadDpm2KKPi_XSecTurboDecision", 
+              "Hlt2CharmHadDpm2KPiPi_XSecTurboDecision", 
+              "Hlt2CharmHadDs2KKPi_XSecTurboDecision", 
+              "Hlt2CharmHadDs2PiPiPi_XSecTurboDecision", 
+              "Hlt2CharmHadDsp2KS0KS0KpTurboDecision", 
+              "Hlt2CharmHadDsp2KS0KS0PipTurboDecision", 
+              "Hlt2CharmHadDsp2KS0KmKpPip_KS0DDTurboDecision", 
+              "Hlt2CharmHadDsp2KS0KmKpPip_KS0LLTurboDecision", 
+              "Hlt2CharmHadDsp2KS0KmPipPip_KS0DDTurboDecision", 
+              "Hlt2CharmHadDsp2KS0KmPipPip_KS0LLTurboDecision", 
+              "Hlt2CharmHadDsp2KS0KpKpPim_KS0DDTurboDecision", 
+              "Hlt2CharmHadDsp2KS0KpKpPim_KS0LLTurboDecision", 
+              "Hlt2CharmHadDsp2KS0KpPimPip_KS0DDTurboDecision", 
+              "Hlt2CharmHadDsp2KS0KpPimPip_KS0LLTurboDecision", 
+              "Hlt2CharmHadDsp2KS0PimPipPip_KS0DDTurboDecision", 
+              "Hlt2CharmHadDsp2KS0PimPipPip_KS0LLTurboDecision", 
+              "Hlt2CharmHadDsp2KmKmKpPipPipTurboDecision", 
+              "Hlt2CharmHadDsp2KmKpPimPipPipTurboDecision", 
+              "Hlt2CharmHadDsp2KmPimPipPipPipTurboDecision", 
+              "Hlt2CharmHadDspToKmKpKpTurboDecision", 
+              "Hlt2CharmHadDspToKmKpPipDecision", 
+              "Hlt2CharmHadDspToKmKpPipTurboDecision", 
+              "Hlt2CharmHadDspToKmKpPip_LTUNBTurboDecision", 
+              "Hlt2CharmHadDspToKmPipPipTurboDecision", 
+              "Hlt2CharmHadDspToKpKpPimTurboDecision", 
+              "Hlt2CharmHadDspToKpPimPipTurboDecision", 
+              "Hlt2CharmHadDspToPimPipPipTurboDecision", 
+              "Hlt2CharmHadDst2PiD02KKGammaDecision", 
+              "Hlt2CharmHadDst2PiD02KPiGammaDecision", 
+              "Hlt2CharmHadDst2PiD02PiPiGammaDecision", 
+              "Hlt2CharmHadDst_2D0Gamma_D02KPi_XSecTurboDecision", 
+              "Hlt2CharmHadDst_2D0Pi0_D02KPi_XSecTurboDecision", 
+              "Hlt2CharmHadDst_2D0Pi_D02K3Pi_XSecTurboDecision", 
+              "Hlt2CharmHadDst_2D0Pi_D02KPi_XSecTurboDecision", 
+              "Hlt2CharmHadDst_2DsGamma_Ds2KKPi_XSecTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02EmEpDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02GG_G2EmEpDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0KS0_KS0DDTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0KS0_KS0LLTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0KS0_KS0LL_KS0DDTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0KmKp_KS0DDDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0KmKp_KS0DDTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0KmKp_KS0DD_LTUNBDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0KmKp_KS0DD_LTUNBTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0KmKp_KS0LLDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0KmKp_KS0LLTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0KmKp_KS0LL_LTUNBDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0KmKp_KS0LL_LTUNBTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0KmPip_KS0DDDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0KmPip_KS0DDTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0KmPip_KS0DD_LTUNBDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0KmPip_KS0LLDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0KmPip_KS0LLTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0KmPip_KS0LL_LTUNBDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0KpPim_KS0DDDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0KpPim_KS0DDTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0KpPim_KS0DD_LTUNBDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0KpPim_KS0LLDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0KpPim_KS0LLTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0KpPim_KS0LL_LTUNBDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0PimPip_KS0DDDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0PimPip_KS0DDTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0PimPip_KS0DD_LTUNBDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0PimPip_KS0DD_LTUNBTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0PimPip_KS0LLDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0PimPip_KS0LLTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0PimPip_KS0LL_LTUNBDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KS0PimPip_KS0LL_LTUNBTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KmKmKpPipTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KmKpKpPimTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KmKpPi0_Pi0MDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KmKpPi0_Pi0RDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KmKpPimPipTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KmKpTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KmKp_LTUNBTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KmPimPipPipTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KmPipPi0_Pi0MDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KmPipPi0_Pi0RDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KmPipTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KmPip_LTUNBTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KpPimPi0_Pi0MDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KpPimPi0_Pi0RDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KpPimPimPipTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KpPimTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02KpPim_LTUNBTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02PimPimPipPipTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02PimPipPi0_Pi0MDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02PimPipPi0_Pi0RDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02PimPipTurboDecision", 
+              "Hlt2CharmHadDstp2D0Pip_D02PimPip_LTUNBTurboDecision", 
+              "Hlt2CharmHadInclDst2PiD02HHXBDTDecision", 
+              "Hlt2CharmHadInclLcpToKmPpPipBDTDecision", 
+              "Hlt2CharmHadInclLcpToKmPpPipBDTTurboDecision", 
+              "Hlt2CharmHadInclOmegacToPpKmKmPipBDTTurboDecision", 
+              "Hlt2CharmHadInclSigc2PiLc2HHXBDTDecision", 
+              "Hlt2CharmHadInclXic0ToPpKmKmPipBDTTurboDecision", 
+              "Hlt2CharmHadInclXicpToKmPpPipBDTTurboDecision", 
+              "Hlt2CharmHadLc2KPK_XSecTurboDecision", 
+              "Hlt2CharmHadLc2KPPi_XSecTurboDecision", 
+              "Hlt2CharmHadLc2LambdaPipPimPip_LamDDDecision", 
+              "Hlt2CharmHadLc2LambdaPipPimPip_LamLLDecision", 
+              "Hlt2CharmHadLc2PiPPi_XSecTurboDecision", 
+              "Hlt2CharmHadLc2XimKpPip_XimDDDDecision", 
+              "Hlt2CharmHadLc2XimKpPip_XimDDLDecision", 
+              "Hlt2CharmHadLc2XimKpPip_XimLLLDecision", 
+              "Hlt2CharmHadLcp2KS0KS0PpTurboDecision", 
+              "Hlt2CharmHadLcp2LamKmKpPip_Lam2PpPimTurboDecision", 
+              "Hlt2CharmHadLcp2LamKmPipPip_Lam2PpPimTurboDecision", 
+              "Hlt2CharmHadLcp2LamKp_LamDDTurboDecision", 
+              "Hlt2CharmHadLcp2LamKp_LamLLTurboDecision", 
+              "Hlt2CharmHadLcp2LamPip_LamDDTurboDecision", 
+              "Hlt2CharmHadLcp2LamPip_LamLLTurboDecision", 
+              "Hlt2CharmHadLcpToKmPpKpPi0TurboDecision", 
+              "Hlt2CharmHadLcpToPpKmKmPipPipTurboDecision", 
+              "Hlt2CharmHadLcpToPpKmKpPimPipTurboDecision", 
+              "Hlt2CharmHadLcpToPpKmKpTurboDecision", 
+              "Hlt2CharmHadLcpToPpKmPimPipPipTurboDecision", 
+              "Hlt2CharmHadLcpToPpKmPipTurboDecision", 
+              "Hlt2CharmHadLcpToPpKmPip_LTUNBTurboDecision", 
+              "Hlt2CharmHadLcpToPpKpKpPimPimTurboDecision", 
+              "Hlt2CharmHadLcpToPpKpPimPimPipTurboDecision", 
+              "Hlt2CharmHadLcpToPpKpPimTurboDecision", 
+              "Hlt2CharmHadLcpToPpPimPimPipPipTurboDecision", 
+              "Hlt2CharmHadLcpToPpPimPipTurboDecision", 
+              "Hlt2CharmHadMuTag_DstpMu_Dstp2D0Pip_D02KmKpTurboDecision", 
+              "Hlt2CharmHadMuTag_DstpMu_Dstp2D0Pip_D02KmPipTurboDecision", 
+              "Hlt2CharmHadMuTag_DstpMu_Dstp2D0Pip_D02KpPimTurboDecision", 
+              "Hlt2CharmHadMuTag_DstpMu_Dstp2D0Pip_D02PimPipTurboDecision", 
+              "Hlt2CharmHadMuTag_Dstp_D02KmKmKpPipTurboDecision", 
+              "Hlt2CharmHadMuTag_Dstp_D02KmKpKpPimTurboDecision", 
+              "Hlt2CharmHadMuTag_Dstp_D02KmKpPimPipTurboDecision", 
+              "Hlt2CharmHadMuTag_Dstp_D02KmPimPipPipTurboDecision", 
+              "Hlt2CharmHadMuTag_Dstp_D02KpPimPimPipTurboDecision", 
+              "Hlt2CharmHadMuTag_Dstp_D02PimPimPipPipTurboDecision", 
+              "Hlt2CharmHadOmccp2DpPpKmKmPip_Dp2KmPipPipTurboDecision", 
+              "Hlt2CharmHadOmccp2LcpKmKmPipPip_Lcp2PpKmPipTurboDecision", 
+              "Hlt2CharmHadOmccp2Xic0KmPipPip_Xic0ToPpKmKmPipTurboDecision", 
+              "Hlt2CharmHadOmccp2XicpKmPim_Xicp2PpKmPipTurboDecision", 
+              "Hlt2CharmHadOmccp2XicpKmPip_Xicp2PpKmPipTurboDecision", 
+              "Hlt2CharmHadOmm2LamKm_DDDDecision", 
+              "Hlt2CharmHadOmm2LamKm_DDDTurboDecision", 
+              "Hlt2CharmHadOmm2LamKm_DDLDecision", 
+              "Hlt2CharmHadOmm2LamKm_DDLTurboDecision", 
+              "Hlt2CharmHadOmm2LamKm_LLLDecision", 
+              "Hlt2CharmHadOmm2LamKm_LLLTurboDecision", 
+              "Hlt2CharmHadPentaToPhiPpPimTurboDecision", 
+              "Hlt2CharmHadPentaToPhiPpTurboDecision", 
+              "Hlt2CharmHadPromptH2LamLamBar_LamDDTurboDecision", 
+              "Hlt2CharmHadPromptH2LamLamBar_LamLLTurboDecision", 
+              "Hlt2CharmHadPromptH2LamLamBar_LamLL_LamDDTurboDecision", 
+              "Hlt2CharmHadPromptH2LamLam_LamDDTurboDecision", 
+              "Hlt2CharmHadPromptH2LamLam_LamLLTurboDecision", 
+              "Hlt2CharmHadPromptH2LamLam_LamLL_LamDDTurboDecision", 
+              "Hlt2CharmHadSecondaryH2LamPipPmDDDDTurboDecision", 
+              "Hlt2CharmHadSecondaryH2LamPipPmDDLLTurboDecision", 
+              "Hlt2CharmHadSecondaryH2LamPipPmLLLLTurboDecision", 
+              "Hlt2CharmHadSecondaryH2LamPpPimDDDDTurboDecision", 
+              "Hlt2CharmHadSecondaryH2LamPpPimDDLLTurboDecision", 
+              "Hlt2CharmHadSecondaryH2LamPpPimLLLLTurboDecision", 
+              "Hlt2CharmHadSigmac_2LcPi_XSecTurboDecision", 
+              "Hlt2CharmHadSpec_D0ToK3Pi_EtaTurboDecision", 
+              "Hlt2CharmHadSpec_D0ToK3Pi_GammaTurboDecision", 
+              "Hlt2CharmHadSpec_D0ToK3Pi_KpmTurboDecision", 
+              "Hlt2CharmHadSpec_D0ToK3Pi_KsTurboDecision", 
+              "Hlt2CharmHadSpec_D0ToK3Pi_LambdaTurboDecision", 
+              "Hlt2CharmHadSpec_D0ToK3Pi_Pi0TurboDecision", 
+              "Hlt2CharmHadSpec_D0ToK3Pi_PiTurboDecision", 
+              "Hlt2CharmHadSpec_D0ToK3Pi_PrTurboDecision", 
+              "Hlt2CharmHadSpec_D0ToKPi_EtaTurboDecision", 
+              "Hlt2CharmHadSpec_D0ToKPi_GammaTurboDecision", 
+              "Hlt2CharmHadSpec_D0ToKPi_KpmTurboDecision", 
+              "Hlt2CharmHadSpec_D0ToKPi_KsTurboDecision", 
+              "Hlt2CharmHadSpec_D0ToKPi_LambdaTurboDecision", 
+              "Hlt2CharmHadSpec_D0ToKPi_Pi0TurboDecision", 
+              "Hlt2CharmHadSpec_D0ToKPi_PiTurboDecision", 
+              "Hlt2CharmHadSpec_D0ToKPi_PrTurboDecision", 
+              "Hlt2CharmHadSpec_DpEtaTurboDecision", 
+              "Hlt2CharmHadSpec_DpGammaTurboDecision", 
+              "Hlt2CharmHadSpec_DpKpmTurboDecision", 
+              "Hlt2CharmHadSpec_DpKsTurboDecision", 
+              "Hlt2CharmHadSpec_DpLambdaTurboDecision", 
+              "Hlt2CharmHadSpec_DpPi0TurboDecision", 
+              "Hlt2CharmHadSpec_DpPiTurboDecision", 
+              "Hlt2CharmHadSpec_DpPrTurboDecision", 
+              "Hlt2CharmHadSpec_DsEtaTurboDecision", 
+              "Hlt2CharmHadSpec_DsGammaTurboDecision", 
+              "Hlt2CharmHadSpec_DsKpmTurboDecision", 
+              "Hlt2CharmHadSpec_DsKsTurboDecision", 
+              "Hlt2CharmHadSpec_DsLambdaTurboDecision", 
+              "Hlt2CharmHadSpec_DsPi0TurboDecision", 
+              "Hlt2CharmHadSpec_DsPiTurboDecision", 
+              "Hlt2CharmHadSpec_DsPrTurboDecision", 
+              "Hlt2CharmHadSpec_Dst_K3Pi_EtaTurboDecision", 
+              "Hlt2CharmHadSpec_Dst_K3Pi_GammaTurboDecision", 
+              "Hlt2CharmHadSpec_Dst_K3Pi_KpmTurboDecision", 
+              "Hlt2CharmHadSpec_Dst_K3Pi_KsTurboDecision", 
+              "Hlt2CharmHadSpec_Dst_K3Pi_LambdaTurboDecision", 
+              "Hlt2CharmHadSpec_Dst_K3Pi_Pi0TurboDecision", 
+              "Hlt2CharmHadSpec_Dst_K3Pi_PiTurboDecision", 
+              "Hlt2CharmHadSpec_Dst_K3Pi_PrTurboDecision", 
+              "Hlt2CharmHadSpec_Dst_KPi_EtaTurboDecision", 
+              "Hlt2CharmHadSpec_Dst_KPi_GammaTurboDecision", 
+              "Hlt2CharmHadSpec_Dst_KPi_KpmTurboDecision", 
+              "Hlt2CharmHadSpec_Dst_KPi_KsTurboDecision", 
+              "Hlt2CharmHadSpec_Dst_KPi_LambdaTurboDecision", 
+              "Hlt2CharmHadSpec_Dst_KPi_Pi0TurboDecision", 
+              "Hlt2CharmHadSpec_Dst_KPi_PiTurboDecision", 
+              "Hlt2CharmHadSpec_Dst_KPi_PrTurboDecision", 
+              "Hlt2CharmHadSpec_LcEtaTurboDecision", 
+              "Hlt2CharmHadSpec_LcGammaTurboDecision", 
+              "Hlt2CharmHadSpec_LcKpmTurboDecision", 
+              "Hlt2CharmHadSpec_LcKsTurboDecision", 
+              "Hlt2CharmHadSpec_LcLambdaTurboDecision", 
+              "Hlt2CharmHadSpec_LcPi0TurboDecision", 
+              "Hlt2CharmHadSpec_LcPiTurboDecision", 
+              "Hlt2CharmHadSpec_LcPrTurboDecision", 
+              "Hlt2CharmHadXcsud2KmKmPimPipTurboDecision", 
+              "Hlt2CharmHadXcsud2KmKmPipPipTurboDecision", 
+              "Hlt2CharmHadXcsud2KmKpPipPipTurboDecision", 
+              "Hlt2CharmHadXic02PKKPi_XSecTurboDecision", 
+              "Hlt2CharmHadXic0ToPpKmKmPipTurboDecision", 
+              "Hlt2CharmHadXic0ToPpKmKmPip_LTUNBTurboDecision", 
+              "Hlt2CharmHadXic2LambdaKmPipPip_LamDDDecision", 
+              "Hlt2CharmHadXic2LambdaKmPipPip_LamLLDecision", 
+              "Hlt2CharmHadXic2LambdaKmPip_LamDDDecision", 
+              "Hlt2CharmHadXic2LambdaKmPip_LamLLDecision", 
+              "Hlt2CharmHadXic2LambdaKpKm_LamDDDecision", 
+              "Hlt2CharmHadXic2LambdaKpKm_LamLLDecision", 
+              "Hlt2CharmHadXic2XimKp_XimDDDDecision", 
+              "Hlt2CharmHadXic2XimKp_XimDDLDecision", 
+              "Hlt2CharmHadXic2XimKp_XimLLLDecision", 
+              "Hlt2CharmHadXic2XimPipPimPip_XimDDDDecision", 
+              "Hlt2CharmHadXic2XimPipPimPip_XimDDLDecision", 
+              "Hlt2CharmHadXic2XimPipPimPip_XimLLLDecision", 
+              "Hlt2CharmHadXic2XimPipPip_XimDDDDecision", 
+              "Hlt2CharmHadXic2XimPipPip_XimDDLDecision", 
+              "Hlt2CharmHadXic2XimPipPip_XimLLLDecision", 
+              "Hlt2CharmHadXic2XimPip_XimDDDDecision", 
+              "Hlt2CharmHadXic2XimPip_XimDDLDecision", 
+              "Hlt2CharmHadXic2XimPip_XimLLLDecision", 
+              "Hlt2CharmHadXiccp2D0PpKmPim_D02KmPipTurboDecision", 
+              "Hlt2CharmHadXiccp2D0PpKmPip_D02KmPipTurboDecision", 
+              "Hlt2CharmHadXiccp2D0PpKpPim_D02KmPipTurboDecision", 
+              "Hlt2CharmHadXiccp2D0Pp_D02KmPipTurboDecision", 
+              "Hlt2CharmHadXiccp2DpPpKm_Dp2KmPipPipTurboDecision", 
+              "Hlt2CharmHadXiccp2DpPpKp_Dp2KmPipPipTurboDecision", 
+              "Hlt2CharmHadXiccp2DpPpPim_Dp2KmPipPipTurboDecision", 
+              "Hlt2CharmHadXiccp2DspPpKm_Dsp2KmKpPipTurboDecision", 
+              "Hlt2CharmHadXiccp2LcpKmPim_Lcp2PpKmPipTurboDecision", 
+              "Hlt2CharmHadXiccp2LcpKmPip_Lcp2PpKmPipTurboDecision", 
+              "Hlt2CharmHadXiccp2LcpKpPim_Lcp2PpKmPipTurboDecision", 
+              "Hlt2CharmHadXiccp2LcpPimPip_Lcp2PpKmPipTurboDecision", 
+              "Hlt2CharmHadXiccp2Xic0Kp_Xic0ToPpKmKmPipTurboDecision", 
+              "Hlt2CharmHadXiccp2Xic0Pim_Xic0ToPpKmKmPipTurboDecision", 
+              "Hlt2CharmHadXiccp2Xic0Pip_Xic0ToPpKmKmPipTurboDecision", 
+              "Hlt2CharmHadXiccp2XicpKpPim_Xicp2PpKmPipTurboDecision", 
+              "Hlt2CharmHadXiccp2XicpPimPim_Xicp2PpKmPipTurboDecision", 
+              "Hlt2CharmHadXiccp2XicpPimPip_Xicp2PpKmPipTurboDecision", 
+              "Hlt2CharmHadXiccpp2D0PpKmPimPip_D02KmPipTurboDecision", 
+              "Hlt2CharmHadXiccpp2D0PpKmPipPip_D02KmPipTurboDecision", 
+              "Hlt2CharmHadXiccpp2D0PpKpPimPip_D02KmPipTurboDecision", 
+              "Hlt2CharmHadXiccpp2D0PpPip_D02KmPipTurboDecision", 
+              "Hlt2CharmHadXiccpp2DpPpKmPim_Dp2KmPipPipTurboDecision", 
+              "Hlt2CharmHadXiccpp2DpPpKmPip_Dp2KmPipPipTurboDecision", 
+              "Hlt2CharmHadXiccpp2DpPpKpPip_Dp2KmPipPipTurboDecision", 
+              "Hlt2CharmHadXiccpp2DpPp_Dp2KmPipPipTurboDecision", 
+              "Hlt2CharmHadXiccpp2DspPpKmPip_Dsp2KmKpPipTurboDecision", 
+              "Hlt2CharmHadXiccpp2LcpKmPimPip_Lcp2PpKmPipTurboDecision", 
+              "Hlt2CharmHadXiccpp2LcpKmPipPip_Lcp2PpKmPipTurboDecision", 
+              "Hlt2CharmHadXiccpp2LcpKpPimPip_Lcp2PpKmPipTurboDecision", 
+              "Hlt2CharmHadXiccpp2LcpPim_Lcp2PpKmPipTurboDecision", 
+              "Hlt2CharmHadXiccpp2LcpPip_Lcp2PpKmPipTurboDecision", 
+              "Hlt2CharmHadXiccpp2Omc0KpKp_Omc0ToPpKmKmPipTurboDecision", 
+              "Hlt2CharmHadXiccpp2Xic0KpPip_Xic0ToPpKmKmPipTurboDecision", 
+              "Hlt2CharmHadXiccpp2Xic0PimPip_Xic0ToPpKmKmPipTurboDecision", 
+              "Hlt2CharmHadXiccpp2Xic0PipPip_Xic0ToPpKmKmPipTurboDecision", 
+              "Hlt2CharmHadXiccpp2XicpKp_Xicp2PpKmPipTurboDecision", 
+              "Hlt2CharmHadXiccpp2XicpPim_Xicp2PpKmPipTurboDecision", 
+              "Hlt2CharmHadXiccpp2XicpPip_Xicp2PpKmPipTurboDecision", 
+              "Hlt2CharmHadXicpToPpKmPipDecision", 
+              "Hlt2CharmHadXicpToPpKmPipTurboDecision", 
+              "Hlt2CharmHadXim2LamPim_DDDDecision", 
+              "Hlt2CharmHadXim2LamPim_DDDTurboDecision", 
+              "Hlt2CharmHadXim2LamPim_DDLDecision", 
+              "Hlt2CharmHadXim2LamPim_DDLTurboDecision", 
+              "Hlt2CharmHadXim2LamPim_LLLDecision", 
+              "Hlt2CharmHadXim2LamPim_LLLTurboDecision", 
+              "Hlt2DPS2mu2HcDecision", 
+              "Hlt2DPS2muHcDecision", 
+              "Hlt2DPS2x2muDecision", 
+              "Hlt2DPS2x2muHcDecision", 
+              "Hlt2DPS2xHcDecision", 
+              "Hlt2DPS3x2muDecision", 
+              "Hlt2DPS3xHcDecision", 
+              "Hlt2DPS:2mu&HcDecision", 
+              "Hlt2DPS:2x2muDecision", 
+              "Hlt2DPS:2xHcDecision", 
+              "Hlt2DebugEventDecision", 
+              "Hlt2DiElectronElSoftDecision", 
+              "Hlt2DiElectronJPsiEETurboDecision", 
+              "Hlt2DiMuonBDecision", 
+              "Hlt2DiMuonBPromptDecision", 
+              "Hlt2DiMuonBTurboDecision", 
+              "Hlt2DiMuonBUBDecision", 
+              "Hlt2DiMuonChicXTurboDecision", 
+              "Hlt2DiMuonDetachedDecision", 
+              "Hlt2DiMuonDetachedHeavyDecision", 
+              "Hlt2DiMuonDetachedJPsiDecision", 
+              "Hlt2DiMuonDetachedPsi2SDecision", 
+              "Hlt2DiMuonJPsiDecision", 
+              "Hlt2DiMuonJPsiHighPTDecision", 
+              "Hlt2DiMuonJPsiTurboDecision", 
+              "Hlt2DiMuonPsi2SDecision", 
+              "Hlt2DiMuonPsi2SHighPTDecision", 
+              "Hlt2DiMuonPsi2STurboDecision", 
+              "Hlt2DiMuonSoftDecision", 
+              "Hlt2DiMuonUpsilonTurboDecision", 
+              "Hlt2DiMuonZDecision", 
+              "Hlt2DiPhiDecision", 
+              "Hlt2DiProtonDecision", 
+              "Hlt2DiProtonLowMultDecision", 
+              "Hlt2DisplVerticesDoubleDecision", 
+              "Hlt2DisplVerticesDoublePSDecision", 
+              "Hlt2DisplVerticesSingleDecision", 
+              "Hlt2DisplVerticesSingleHighFDDecision", 
+              "Hlt2DisplVerticesSingleHighMassDecision", 
+              "Hlt2DisplVerticesSingleLoosePSDecision", 
+              "Hlt2DisplVerticesSinglePSDecision", 
+              "Hlt2DisplVerticesSingleVeryHighFDDecision", 
+              "Hlt2EWConvPhotonDDHighPtDecision", 
+              "Hlt2EWConvPhotonDDVHighPtDecision", 
+              "Hlt2EWConvPhotonLLHighPtDecision", 
+              "Hlt2EWConvPhotonLLVHighPtDecision", 
+              "Hlt2EWDiElectronDYDecision", 
+              "Hlt2EWDiElectronHighMassDecision", 
+              "Hlt2EWDiMuonDY1Decision", 
+              "Hlt2EWDiMuonDY2Decision", 
+              "Hlt2EWDiMuonDY3Decision", 
+              "Hlt2EWDiMuonDY4Decision", 
+              "Hlt2EWDiMuonZDecision", 
+              "Hlt2EWSingleElectronHighPtDecision", 
+              "Hlt2EWSingleElectronLowPtDecision", 
+              "Hlt2EWSingleElectronVHighPtDecision", 
+              "Hlt2EWSingleMuonHighPtDecision", 
+              "Hlt2EWSingleMuonHighPtNoMUIDDecision", 
+              "Hlt2EWSingleMuonLowPtDecision", 
+              "Hlt2EWSingleMuonVHighPtDecision", 
+              "Hlt2EWSingleTauHighPt2ProngDecision", 
+              "Hlt2EWSingleTauHighPt3ProngDecision", 
+              "Hlt2ErrorEventDecision", 
+              "Hlt2ExoticaDiMuonNoIPSSTurboDecision", 
+              "Hlt2ExoticaDiMuonNoIPTurboDecision", 
+              "Hlt2ExoticaDisplDiEDecision", 
+              "Hlt2ExoticaDisplDiELowMassDecision", 
+              "Hlt2ExoticaDisplDiMuonDecision", 
+              "Hlt2ExoticaDisplDiMuonNoPointDecision", 
+              "Hlt2ExoticaDisplPhiPhiDecision", 
+              "Hlt2ExoticaEtaToDiEGammaDecision", 
+              "Hlt2ExoticaLFVPrmptDecision", 
+              "Hlt2ExoticaLFVPrmptSSTurboDecision", 
+              "Hlt2ExoticaLFVPrmptTurboDecision", 
+              "Hlt2ExoticaPi0ToDiEGammaDecision", 
+              "Hlt2ExoticaPrmptDiMuonSSTurboDecision", 
+              "Hlt2ExoticaPrmptDiMuonTurboDecision", 
+              "Hlt2ExoticaQuadMuonNoIPDecision", 
+              "Hlt2ExoticaRHNuDecision", 
+              "Hlt2Exoticaf1gammaConvTurboDecision", 
+              "Hlt2Exoticaf1mumuTurboDecision", 
+              "Hlt2Exoticasigma0lbgammaTurboDecision", 
+              "Hlt2ForwardDecision", 
+              "Hlt2GlobalDecision", 
+              "Hlt2Hb2V0V0Hb2KSKSDDDecision", 
+              "Hlt2Hb2V0V0Hb2KSKSLDDecision", 
+              "Hlt2Hb2V0V0Hb2KSKSLLDecision", 
+              "Hlt2HcetacPPmumuTurboDecision", 
+              "Hlt2HcetacPhiPhimumuTurboDecision", 
+              "Hlt2IncPhiDecision", 
+              "Hlt2JetsDiJetDisplacedSVSVLowPtDecision", 
+              "Hlt2JetsDiJetMuMuDecision", 
+              "Hlt2JetsDiJetMuMuLowPtDecision", 
+              "Hlt2JetsDiJetSVDecision", 
+              "Hlt2JetsDiJetSVHighPtDecision", 
+              "Hlt2JetsDiJetSVLowPtDecision", 
+              "Hlt2JetsDiJetSVMuDecision", 
+              "Hlt2JetsDiJetSVMuLowPtDecision", 
+              "Hlt2JetsDiJetSVSVDecision", 
+              "Hlt2JetsDiJetSVSVLowPtDecision", 
+              "Hlt2JetsJetDisplacedSVDecision", 
+              "Hlt2JetsJetLowPtDecision", 
+              "Hlt2JetsJetSVDecision", 
+              "Hlt2LFVJpsiMuETurboDecision", 
+              "Hlt2LFVPhiMuETurboDecision", 
+              "Hlt2LFVPromptPhiMuETurboDecision", 
+              "Hlt2LFVUpsilonMuETurboDecision", 
+              "Hlt2Lb2PKDecision", 
+              "Hlt2Lb2PPiDecision", 
+              "Hlt2LowMultChiC2HHDecision", 
+              "Hlt2LowMultChiC2HHHHDecision", 
+              "Hlt2LowMultChiC2HHHHWSDecision", 
+              "Hlt2LowMultChiC2HHWSDecision", 
+              "Hlt2LowMultChiC2PPDecision", 
+              "Hlt2LowMultChiC2PPWSDecision", 
+              "Hlt2LowMultD2K3PiDecision", 
+              "Hlt2LowMultD2K3PiWSDecision", 
+              "Hlt2LowMultD2KKPiDecision", 
+              "Hlt2LowMultD2KKPiWSDecision", 
+              "Hlt2LowMultD2KPiDecision", 
+              "Hlt2LowMultD2KPiPiDecision", 
+              "Hlt2LowMultD2KPiPiWSDecision", 
+              "Hlt2LowMultD2KPiWSDecision", 
+              "Hlt2LowMultDiElectronDecision", 
+              "Hlt2LowMultDiElectron_noTrFiltDecision", 
+              "Hlt2LowMultDiMuonDecision", 
+              "Hlt2LowMultDiMuon_PSDecision", 
+              "Hlt2LowMultDiPhotonDecision", 
+              "Hlt2LowMultDiPhoton_HighMassDecision", 
+              "Hlt2LowMultHadron_noTrFiltDecision", 
+              "Hlt2LowMultL2pPiDecision", 
+              "Hlt2LowMultL2pPiWSDecision", 
+              "Hlt2LowMultLMR2HHDecision", 
+              "Hlt2LowMultLMR2HHHHDecision", 
+              "Hlt2LowMultLMR2HHHHWSDecision", 
+              "Hlt2LowMultLMR2HHHHWS_heavyPSDecision", 
+              "Hlt2LowMultLMR2HHHHWS_mediumPSDecision", 
+              "Hlt2LowMultLMR2HHHH_heavyPSDecision", 
+              "Hlt2LowMultLMR2HHHH_mediumPSDecision", 
+              "Hlt2LowMultLMR2HHWSDecision", 
+              "Hlt2LowMultLMR2HHWS_heavyPSDecision", 
+              "Hlt2LowMultLMR2HHWS_mediumPSDecision", 
+              "Hlt2LowMultLMR2HH_heavyPSDecision", 
+              "Hlt2LowMultLMR2HH_mediumPSDecision", 
+              "Hlt2LowMultMuonDecision", 
+              "Hlt2LowMultPi0Decision", 
+              "Hlt2LowMultTechnical_MinBiasDecision", 
+              "Hlt2LumiDecision", 
+              "Hlt2MBNoBiasDecision", 
+              "Hlt2MajoranaBLambdaMuDDDecision", 
+              "Hlt2MajoranaBLambdaMuLLDecision", 
+              "Hlt2NoBiasNonBeamBeamDecision", 
+              "Hlt2PIDB2KJPsiEENegTaggedTurboCalibDecision", 
+              "Hlt2PIDB2KJPsiEEPosTaggedTurboCalibDecision", 
+              "Hlt2PIDB2KJPsiMuMuNegTaggedTurboCalibDecision", 
+              "Hlt2PIDB2KJPsiMuMuPosTaggedTurboCalibDecision", 
+              "Hlt2PIDB2KJPsiPPNegTaggedTurboCalibDecision", 
+              "Hlt2PIDB2KJPsiPPPosTaggedTurboCalibDecision", 
+              "Hlt2PIDD02KPiPiPiTagTurboCalibDecision", 
+              "Hlt2PIDD02KPiPiPiTurboCalibDecision", 
+              "Hlt2PIDD02KPiTagTurboCalibDecision", 
+              "Hlt2PIDDetJPsiEENegTaggedTurboCalibDecision", 
+              "Hlt2PIDDetJPsiEEPosNegTaggedTurboCalibDecision", 
+              "Hlt2PIDDetJPsiEEPosTaggedTurboCalibDecision", 
+              "Hlt2PIDDetJPsiMuMuNegTaggedTurboCalibDecision", 
+              "Hlt2PIDDetJPsiMuMuPosTaggedTurboCalibDecision", 
+              "Hlt2PIDDetJPsiPPNegTaggedTurboCalibDecision", 
+              "Hlt2PIDDetJPsiPPPosTaggedTurboCalibDecision", 
+              "Hlt2PIDDetPhiKKNegTaggedTurboCalibDecision", 
+              "Hlt2PIDDetPhiKKPosTaggedTurboCalibDecision", 
+              "Hlt2PIDDetPhiKKUnbiasedTurboCalibDecision", 
+              "Hlt2PIDDetPhiMuMuNegTaggedTurboCalibDecision", 
+              "Hlt2PIDDetPhiMuMuPosTaggedTurboCalibDecision", 
+              "Hlt2PIDDs2PiPhiKKNegTaggedTurboCalibDecision", 
+              "Hlt2PIDDs2PiPhiKKPosTaggedTurboCalibDecision", 
+              "Hlt2PIDDs2PiPhiKKUnbiasedTurboCalibDecision", 
+              "Hlt2PIDDs2PiPhiMuMuNegTaggedTurboCalibDecision", 
+              "Hlt2PIDDs2PiPhiMuMuPosTaggedTurboCalibDecision", 
+              "Hlt2PIDKs2PiPiDDTurboCalibDecision", 
+              "Hlt2PIDKs2PiPiLLTurboCalibDecision", 
+              "Hlt2PIDLambda2PPiDDTurboCalibDecision", 
+              "Hlt2PIDLambda2PPiDDhighPTTurboCalibDecision", 
+              "Hlt2PIDLambda2PPiDDveryhighPTTurboCalibDecision", 
+              "Hlt2PIDLambda2PPiLLTurboCalibDecision", 
+              "Hlt2PIDLambda2PPiLLhighPTTurboCalibDecision", 
+              "Hlt2PIDLambda2PPiLLisMuonTurboCalibDecision", 
+              "Hlt2PIDLambda2PPiLLveryhighPTTurboCalibDecision", 
+              "Hlt2PIDLb2LcMuNuTurboCalibDecision", 
+              "Hlt2PIDLb2LcPiTurboCalibDecision", 
+              "Hlt2PIDLc2KPPiTurboCalibDecision", 
+              "Hlt2PIDOmega2LambdaKDDDTurboCalibDecision", 
+              "Hlt2PIDOmega2LambdaKLLLTurboCalibDecision", 
+              "Hlt2PIDSc02LcPiTurboCalibDecision", 
+              "Hlt2PIDScpp2LcPiTurboCalibDecision", 
+              "Hlt2PassThroughDecision", 
+              "Hlt2Phi2KsKsDecision", 
+              "Hlt2Phi2KsKsD0CtrlDecision", 
+              "Hlt2PhiBs2PhiPhiDecision", 
+              "Hlt2PhiIncPhiDecision", 
+              "Hlt2PhiPhi2EETurboDecision", 
+              "Hlt2PhiPhi2KsKsDecision", 
+              "Hlt2PhiPhi2KsKsD0CtrlDecision", 
+              "Hlt2PhiPhi2MuMuTurboDecision", 
+              "Hlt2PhiPromptPhi2EETurboDecision", 
+              "Hlt2RadiativeB2GammaGammaDecision", 
+              "Hlt2RadiativeB2GammaGammaDDDecision", 
+              "Hlt2RadiativeB2GammaGammaDoubleDecision", 
+              "Hlt2RadiativeB2GammaGammaLLDecision", 
+              "Hlt2RadiativeBd2KstGammaDecision", 
+              "Hlt2RadiativeBd2KstGammaULUnbiasedDecision", 
+              "Hlt2RadiativeBs2PhiGammaDecision", 
+              "Hlt2RadiativeBs2PhiGammaUnbiasedDecision", 
+              "Hlt2RadiativeHypb2L0HGammaOmDecision", 
+              "Hlt2RadiativeHypb2L0HGammaOmEEDecision", 
+              "Hlt2RadiativeHypb2L0HGammaXiDecision", 
+              "Hlt2RadiativeHypb2L0HGammaXiEEDecision", 
+              "Hlt2RadiativeIncHHGammaDecision", 
+              "Hlt2RadiativeIncHHGammaEEDecision", 
+              "Hlt2RadiativeIncHHHGammaDecision", 
+              "Hlt2RadiativeIncHHHGammaEEDecision", 
+              "Hlt2RadiativeLb2L0GammaEELLDecision", 
+              "Hlt2RadiativeLb2L0GammaLLDecision", 
+              "Hlt2RareCharmD02EMuDecision", 
+              "Hlt2RareCharmD02KKMuMuDecision", 
+              "Hlt2RareCharmD02KKMuMuFilterDecision", 
+              "Hlt2RareCharmD02KKMueDecision", 
+              "Hlt2RareCharmD02KKMueFilterDecision", 
+              "Hlt2RareCharmD02KKeeDecision", 
+              "Hlt2RareCharmD02KKeeFilterDecision", 
+              "Hlt2RareCharmD02KMuDecision", 
+              "Hlt2RareCharmD02KPiDecision", 
+              "Hlt2RareCharmD02KPiMuMuDecision", 
+              "Hlt2RareCharmD02KPiMuMuFilterDecision", 
+              "Hlt2RareCharmD02KPiMuMuSSDecision", 
+              "Hlt2RareCharmD02KPiMuMuSSFilterDecision", 
+              "Hlt2RareCharmD02KPiMuMuUntagDecision", 
+              "Hlt2RareCharmD02KPiMueDecision", 
+              "Hlt2RareCharmD02KPiMueFilterDecision", 
+              "Hlt2RareCharmD02KPieeDecision", 
+              "Hlt2RareCharmD02KPieeFilterDecision", 
+              "Hlt2RareCharmD02MuMuDecision", 
+              "Hlt2RareCharmD02PiPiDecision", 
+              "Hlt2RareCharmD02PiPiMuMuDecision", 
+              "Hlt2RareCharmD02PiPiMuMuFilterDecision", 
+              "Hlt2RareCharmD02PiPiMueDecision", 
+              "Hlt2RareCharmD02PiPiMueFilterDecision", 
+              "Hlt2RareCharmD02PiPieeDecision", 
+              "Hlt2RareCharmD02PiPieeFilterDecision", 
+              "Hlt2RareCharmD2KEEOSDecision", 
+              "Hlt2RareCharmD2KEESSDecision", 
+              "Hlt2RareCharmD2KEEWSDecision", 
+              "Hlt2RareCharmD2KEMuOSDecision", 
+              "Hlt2RareCharmD2KMuEOSDecision", 
+              "Hlt2RareCharmD2KMuESSDecision", 
+              "Hlt2RareCharmD2KMuEWSDecision", 
+              "Hlt2RareCharmD2KMuMuFilterDecision", 
+              "Hlt2RareCharmD2KMuMuOSDecision", 
+              "Hlt2RareCharmD2KMuMuSSDecision", 
+              "Hlt2RareCharmD2KMuMuSSFilterDecision", 
+              "Hlt2RareCharmD2KMuMuWSDecision", 
+              "Hlt2RareCharmD2KMueFilterDecision", 
+              "Hlt2RareCharmD2KMueSSFilterDecision", 
+              "Hlt2RareCharmD2KeeFilterDecision", 
+              "Hlt2RareCharmD2KeeSSFilterDecision", 
+              "Hlt2RareCharmD2PiEEOSDecision", 
+              "Hlt2RareCharmD2PiEESSDecision", 
+              "Hlt2RareCharmD2PiEEWSDecision", 
+              "Hlt2RareCharmD2PiEMuOSDecision", 
+              "Hlt2RareCharmD2PiMuEOSDecision", 
+              "Hlt2RareCharmD2PiMuESSDecision", 
+              "Hlt2RareCharmD2PiMuEWSDecision", 
+              "Hlt2RareCharmD2PiMuMuFilterDecision", 
+              "Hlt2RareCharmD2PiMuMuOSDecision", 
+              "Hlt2RareCharmD2PiMuMuSSDecision", 
+              "Hlt2RareCharmD2PiMuMuSSFilterDecision", 
+              "Hlt2RareCharmD2PiMuMuWSDecision", 
+              "Hlt2RareCharmD2PiMueFilterDecision", 
+              "Hlt2RareCharmD2PiMueSSFilterDecision", 
+              "Hlt2RareCharmD2PieeFilterDecision", 
+              "Hlt2RareCharmD2PieeSSFilterDecision", 
+              "Hlt2RareCharmLc2PMuMuDecision", 
+              "Hlt2RareCharmLc2PMuMuFilterDecision", 
+              "Hlt2RareCharmLc2PMuMuSSDecision", 
+              "Hlt2RareCharmLc2PMuMuSSFilterDecision", 
+              "Hlt2RareCharmLc2PMueDecision", 
+              "Hlt2RareCharmLc2PMueFilterDecision", 
+              "Hlt2RareCharmLc2PeeDecision", 
+              "Hlt2RareCharmLc2PeeFilterDecision", 
+              "Hlt2RareStrangeKPiMuMuDecision", 
+              "Hlt2RareStrangeKPiMuMuSSDecision", 
+              "Hlt2RareStrangeKsPiPiEETOSDecision", 
+              "Hlt2RareStrangeSigmaPMuMuDecision", 
+              "Hlt2RareWZD0GammaTurboDecision", 
+              "Hlt2RareWZDiMuonGammaTurboDecision", 
+              "Hlt2RareWZDpGammaTurboDecision", 
+              "Hlt2RareWZDsGammaTurboDecision", 
+              "Hlt2RareWZGammaGammaTurboDecision", 
+              "Hlt2RareWZJPsiDiJetsTurboDecision", 
+              "Hlt2RareWZKaonGammaTurboDecision", 
+              "Hlt2RareWZKs0GammaTurboDecision", 
+              "Hlt2RareWZKstGammaTurboDecision", 
+              "Hlt2RareWZPhiGammaTurboDecision", 
+              "Hlt2RareWZPi0GammaTurboDecision", 
+              "Hlt2RareWZPi0Pi0TurboDecision", 
+              "Hlt2RareWZPionGammaTurboDecision", 
+              "Hlt2RareWZRho0GammaTurboDecision", 
+              "Hlt2SLB_B2D0Mu_D02KmKpTurboDecision", 
+              "Hlt2SLB_B2D0Mu_D02KmPipTurboDecision", 
+              "Hlt2SLB_B2D0Mu_D02PimPipTurboDecision", 
+              "Hlt2SLB_B2DstMu_D02KmKpTurboDecision", 
+              "Hlt2SLB_B2DstMu_D02KmPipTurboDecision", 
+              "Hlt2SLB_B2DstMu_D02PimPipTurboDecision", 
+              "Hlt2SingleMuonDecision", 
+              "Hlt2SingleMuonHighPTDecision", 
+              "Hlt2SingleMuonLowPTDecision", 
+              "Hlt2SingleMuonNoSPDDecision", 
+              "Hlt2SingleMuonRareDecision", 
+              "Hlt2SingleMuonVHighPTDecision", 
+              "Hlt2StrangeKPiPiPiTurboDecision", 
+              "Hlt2StrangeLFVMuonElectronSoftDecision", 
+              "Hlt2TFBc2JpsiMuXDecision", 
+              "Hlt2Topo2BodyDecision", 
+              "Hlt2Topo3BodyDecision", 
+              "Hlt2Topo4BodyDecision", 
+              "Hlt2TopoE2BodyDecision", 
+              "Hlt2TopoE3BodyDecision", 
+              "Hlt2TopoE4BodyDecision", 
+              "Hlt2TopoEE2BodyDecision", 
+              "Hlt2TopoEE3BodyDecision", 
+              "Hlt2TopoEE4BodyDecision", 
+              "Hlt2TopoMu2BodyDecision", 
+              "Hlt2TopoMu3BodyDecision", 
+              "Hlt2TopoMu4BodyDecision", 
+              "Hlt2TopoMuE2BodyDecision", 
+              "Hlt2TopoMuE3BodyDecision", 
+              "Hlt2TopoMuE4BodyDecision", 
+              "Hlt2TopoMuMu2BodyDecision", 
+              "Hlt2TopoMuMu3BodyDecision", 
+              "Hlt2TopoMuMu4BodyDecision", 
+              "Hlt2TopoMuMuDDDecision", 
+              "Hlt2TrackEffDiMuonDownstreamMinusHighStatMatchedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonDownstreamMinusHighStatTaggedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonDownstreamMinusLowStatMatchedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonDownstreamMinusLowStatTaggedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonDownstreamMinusMatchedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonDownstreamMinusTaggedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonDownstreamPlusHighStatMatchedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonDownstreamPlusHighStatTaggedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonDownstreamPlusLowStatMatchedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonDownstreamPlusLowStatTaggedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonDownstreamPlusMatchedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonDownstreamPlusTaggedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonMuonTTMinusHighStatMatchedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonMuonTTMinusHighStatTaggedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonMuonTTMinusLowStatMatchedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonMuonTTMinusLowStatTaggedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonMuonTTMinusMatchedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonMuonTTMinusTaggedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonMuonTTPlusHighStatMatchedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonMuonTTPlusHighStatTaggedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonMuonTTPlusLowStatMatchedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonMuonTTPlusLowStatTaggedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonMuonTTPlusMatchedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonMuonTTPlusTaggedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonVeloMuonMinusHighStatMatchedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonVeloMuonMinusHighStatTaggedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonVeloMuonMinusLowStatMatchedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonVeloMuonMinusLowStatTaggedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonVeloMuonMinusMatchedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonVeloMuonMinusTaggedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonVeloMuonPlusHighStatMatchedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonVeloMuonPlusHighStatTaggedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonVeloMuonPlusLowStatMatchedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonVeloMuonPlusLowStatTaggedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonVeloMuonPlusMatchedTurboCalibDecision", 
+              "Hlt2TrackEffDiMuonVeloMuonPlusTaggedTurboCalibDecision", 
+              "Hlt2TrackEffElectronDetachedEEKTurboCalibDecision", 
+              "Hlt2TrackEffElectronDetachedEEKstarTurboCalibDecision", 
+              "Hlt2TrackEffElectronDetachedEEPhiTurboCalibDecision", 
+              "Hlt2TrackEffElectronDetachedEKTurboCalibDecision", 
+              "Hlt2TrackEffElectronDetachedEPiTurboCalibDecision", 
+              "Hlt2TrackEffElectronDetachedMuKTurboCalibDecision", 
+              "Hlt2TrackEffElectronDetachedMuMuKTurboCalibDecision", 
+              "Hlt2TrackEffElectronDetachedMuMuKstarTurboCalibDecision", 
+              "Hlt2TrackEffElectronDetachedMuMuPhiTurboCalibDecision", 
+              "Hlt2TrackEffElectronDetachedMuPiTurboCalibDecision", 
+              "Hlt2TrackEffElectronDetachedProtonProtonPhiTurboCalibDecision", 
+              "Hlt2TrackEff_D0ToK3piPionProbeTurboDecision", 
+              "Hlt2TrackEff_D0ToKpiKaonProbeDecision", 
+              "Hlt2TrackEff_D0ToKpiKaonProbeTurboDecision", 
+              "Hlt2TrackEff_D0ToKpiPionProbeDecision", 
+              "Hlt2TrackEff_D0ToKpiPionProbeTurboDecision", 
+              "Hlt2TrackEff_DsToPhiPiKaonProbeTurboDecision", 
+              "Hlt2TransparentDecision", 
+              "Hlt2TriMuonDetachedDecision", 
+              "Hlt2TriMuonTau23MuDecision", 
+              "Hlt2Xc3PiXForTauD02KpiDecision", 
+              "Hlt2Xc3PiXForTauD02KpiNonPhysDecision", 
+              "Hlt2Xc3PiXForTauD02KpiWSDecision", 
+              "Hlt2Xc3PiXForTauDp2KpipiDecision", 
+              "Hlt2Xc3PiXForTauDp2KpipiNonPhysDecision", 
+              "Hlt2Xc3PiXForTauDp2KpipiWSDecision", 
+              "Hlt2Xc3PiXForTauDs2kkpiDecision", 
+              "Hlt2Xc3PiXForTauDs2kkpiNonPhysDecision", 
+              "Hlt2Xc3PiXForTauDs2kkpiWSDecision", 
+              "Hlt2Xc3PiXForTauJpsi2mumuDecision", 
+              "Hlt2Xc3PiXForTauJpsi2mumuNonPhysDecision", 
+              "Hlt2Xc3PiXForTauLc2pkpiDecision", 
+              "Hlt2Xc3PiXForTauLc2pkpiNonPhysDecision", 
+              "Hlt2Xc3PiXForTauLc2pkpiWSDecision", 
+              "Hlt2XcMuXForTauB2XcFakeMuDecision", 
+              "Hlt2XcMuXForTauB2XcFakePDecision", 
+              "Hlt2XcMuXForTauB2XcMuDecision", 
+              "Hlt2XcMuXForTauB2XcSSPDecision", 
+              "Hlt2XcMuXForTauB2XcSSPFakePDecision", 
+    ]
+
+def allRun1Lines():
+    return [  "Hlt1BeamGasBeam1Decision", 
+              "Hlt1BeamGasBeam2Decision", 
+              "Hlt1BeamGasCrossingEnhancedBeam1Decision", 
+              "Hlt1BeamGasCrossingEnhancedBeam2Decision", 
+              "Hlt1BeamGasCrossingForcedRecoDecision", 
+              "Hlt1BeamGasCrossingForcedRecoFullZDecision", 
+              "Hlt1BeamGasCrossingParasiticDecision", 
+              "Hlt1BeamGasHighRhoVerticesDecision", 
+              "Hlt1BeamGasNoBeamBeam1Decision", 
+              "Hlt1BeamGasNoBeamBeam2Decision", 
+              "Hlt1CharmCalibrationNoBiasDecision", 
+              "Hlt1DiMuonHighMassDecision", 
+              "Hlt1DiMuonLowMassDecision", 
+              "Hlt1DiProtonDecision", 
+              "Hlt1DiProtonLowMultDecision", 
+              "Hlt1ErrorEventDecision", 
+              "Hlt1GlobalDecision", 
+              "Hlt1L0AnyDecision", 
+              "Hlt1L0AnyNoSPDDecision", 
+              "Hlt1L0AnyNoSPDRateLimitedDecision", 
+              "Hlt1L0AnyRateLimitedDecision", 
+              "Hlt1L0HighSumETJetDecision", 
+              "Hlt1LumiDecision", 
+              "Hlt1LumiMidBeamCrossingDecision", 
+              "Hlt1MBMicroBiasTStationDecision", 
+              "Hlt1MBMicroBiasTStationRateLimitedDecision", 
+              "Hlt1MBMicroBiasVeloDecision", 
+              "Hlt1MBMicroBiasVeloRateLimitedDecision", 
+              "Hlt1MBNoBiasDecision", 
+              "Hlt1NoPVPassThroughDecision", 
+              "Hlt1ODINTechnicalDecision", 
+              "Hlt1SingleElectronNoIPDecision", 
+              "Hlt1SingleMuonHighPTDecision", 
+              "Hlt1SingleMuonNoIPDecision", 
+              "Hlt1Tell1ErrorDecision", 
+              "Hlt1TrackAllL0Decision", 
+              "Hlt1TrackAllL0TightDecision", 
+              "Hlt1TrackForwardPassThroughDecision", 
+              "Hlt1TrackForwardPassThroughLooseDecision", 
+              "Hlt1TrackMuonDecision", 
+              "Hlt1TrackPhotonDecision", 
+              "Hlt1VeloClosingMicroBiasDecision", 
+              "Hlt1VertexDisplVertexDecision", 
+              "Hlt2B2HHDecision", 
+              "Hlt2B2HHLTUnbiasedDecision", 
+              "Hlt2B2HHLTUnbiasedDetachedDecision", 
+              "Hlt2B2HHPi0_MergedDecision", 
+              "Hlt2Bd2KstGammaDecision", 
+              "Hlt2Bd2KstGammaWideBMassDecision", 
+              "Hlt2Bd2KstGammaWideKMassDecision", 
+              "Hlt2Bs2PhiGammaDecision", 
+              "Hlt2Bs2PhiGammaWideBMassDecision", 
+              "Hlt2CharmHadD02HHHHDecision", 
+              "Hlt2CharmHadD02HHHHDst_2K2piDecision", 
+              "Hlt2CharmHadD02HHHHDst_2K2piWideMassDecision", 
+              "Hlt2CharmHadD02HHHHDst_3KpiDecision", 
+              "Hlt2CharmHadD02HHHHDst_3KpiWideMassDecision", 
+              "Hlt2CharmHadD02HHHHDst_4piDecision", 
+              "Hlt2CharmHadD02HHHHDst_4piWideMassDecision", 
+              "Hlt2CharmHadD02HHHHDst_K3piDecision", 
+              "Hlt2CharmHadD02HHHHDst_K3piWideMassDecision", 
+              "Hlt2CharmHadD02HHHHDst_KKpipiDecision", 
+              "Hlt2CharmHadD02HHHHDst_KKpipiWideMassDecision", 
+              "Hlt2CharmHadD02HHHHWideMassDecision", 
+              "Hlt2CharmHadD02HHHH_2K2piDecision", 
+              "Hlt2CharmHadD02HHHH_2K2piWideMassDecision", 
+              "Hlt2CharmHadD02HHHH_3KpiDecision", 
+              "Hlt2CharmHadD02HHHH_3KpiWideMassDecision", 
+              "Hlt2CharmHadD02HHHH_4piDecision", 
+              "Hlt2CharmHadD02HHHH_4piWideMassDecision", 
+              "Hlt2CharmHadD02HHHH_K3piDecision", 
+              "Hlt2CharmHadD02HHHH_K3piWideMassDecision", 
+              "Hlt2CharmHadD02HHHH_KKpipiDecision", 
+              "Hlt2CharmHadD02HHHH_KKpipiWideMassDecision", 
+              "Hlt2CharmHadD02HHKsDDDecision", 
+              "Hlt2CharmHadD02HHKsLLDecision", 
+              "Hlt2CharmHadD02HHXDst_hhXDecision", 
+              "Hlt2CharmHadD02HHXDst_hhXWideMassDecision", 
+              "Hlt2CharmHadD02HH_D02KKDecision", 
+              "Hlt2CharmHadD02HH_D02KKWideMassDecision", 
+              "Hlt2CharmHadD02HH_D02KPiDecision", 
+              "Hlt2CharmHadD02HH_D02KPiWideMassDecision", 
+              "Hlt2CharmHadD02HH_D02PiPiDecision", 
+              "Hlt2CharmHadD02HH_D02PiPiWideMassDecision", 
+              "Hlt2CharmHadD2HHHDecision", 
+              "Hlt2CharmHadD2HHHWideMassDecision", 
+              "Hlt2CharmHadD2KS0H_D2KS0DDKDecision", 
+              "Hlt2CharmHadD2KS0H_D2KS0DDPiDecision", 
+              "Hlt2CharmHadD2KS0H_D2KS0KDecision", 
+              "Hlt2CharmHadD2KS0H_D2KS0PiDecision", 
+              "Hlt2CharmHadD2KS0KS0Decision", 
+              "Hlt2CharmHadD2KS0KS0WideMassDecision", 
+              "Hlt2CharmHadLambdaC2KPKDecision", 
+              "Hlt2CharmHadLambdaC2KPKWideMassDecision", 
+              "Hlt2CharmHadLambdaC2KPPiDecision", 
+              "Hlt2CharmHadLambdaC2KPPiWideMassDecision", 
+              "Hlt2CharmHadLambdaC2PiPKDecision", 
+              "Hlt2CharmHadLambdaC2PiPKWideMassDecision", 
+              "Hlt2CharmHadLambdaC2PiPPiDecision", 
+              "Hlt2CharmHadLambdaC2PiPPiWideMassDecision", 
+              "Hlt2CharmHadMinBiasD02KKDecision", 
+              "Hlt2CharmHadMinBiasD02KPiDecision", 
+              "Hlt2CharmHadMinBiasDplus2hhhDecision", 
+              "Hlt2CharmHadMinBiasLambdaC2KPPiDecision", 
+              "Hlt2CharmHadMinBiasLambdaC2LambdaPiDecision", 
+              "Hlt2CharmRareDecayD02MuMuDecision", 
+              "Hlt2CharmSemilep3bodyD2KMuMuDecision", 
+              "Hlt2CharmSemilep3bodyD2KMuMuSSDecision", 
+              "Hlt2CharmSemilep3bodyD2PiMuMuDecision", 
+              "Hlt2CharmSemilep3bodyD2PiMuMuSSDecision", 
+              "Hlt2CharmSemilep3bodyLambdac2PMuMuDecision", 
+              "Hlt2CharmSemilep3bodyLambdac2PMuMuSSDecision", 
+              "Hlt2CharmSemilepD02HHMuMuDecision", 
+              "Hlt2CharmSemilepD02HHMuMuHardHadronsAndMuonsDecision", 
+              "Hlt2CharmSemilepD02HHMuMuHardHadronsAndMuonsWideMassDecision", 
+              "Hlt2CharmSemilepD02HHMuMuHardHadronsSoftMuonsDecision", 
+              "Hlt2CharmSemilepD02HHMuMuHardHadronsSoftMuonsWideMassDecision", 
+              "Hlt2CharmSemilepD02HHMuMuWideMassDecision", 
+              "Hlt2CharmSemilepD02HMuNu_D02KMuNuDecision", 
+              "Hlt2CharmSemilepD02HMuNu_D02KMuNuTightDecision", 
+              "Hlt2CharmSemilepD02HMuNu_D02KMuNuWSDecision", 
+              "Hlt2CharmSemilepD02HMuNu_D02PiMuNuDecision", 
+              "Hlt2CharmSemilepD02HMuNu_D02PiMuNuWSDecision", 
+              "Hlt2CharmSemilepD02KKMuMuDecision", 
+              "Hlt2CharmSemilepD02KPiMuMuDecision", 
+              "Hlt2CharmSemilepD02PiPiMuMuDecision", 
+              "Hlt2CharmSemilepD2HMuMuDecision", 
+              "Hlt2CharmSemilepD2HMuMuWideMassDecision", 
+              "Hlt2DebugEventDecision", 
+              "Hlt2DiElectronBDecision", 
+              "Hlt2DiElectronHighMassDecision", 
+              "Hlt2DiMuonDecision", 
+              "Hlt2DiMuonAndD0Decision", 
+              "Hlt2DiMuonAndDpDecision", 
+              "Hlt2DiMuonAndDsDecision", 
+              "Hlt2DiMuonAndGammaDecision", 
+              "Hlt2DiMuonAndLcDecision", 
+              "Hlt2DiMuonAndMuonDecision", 
+              "Hlt2DiMuonBDecision", 
+              "Hlt2DiMuonDY1Decision", 
+              "Hlt2DiMuonDY2Decision", 
+              "Hlt2DiMuonDY3Decision", 
+              "Hlt2DiMuonDY4Decision", 
+              "Hlt2DiMuonDetachedDecision", 
+              "Hlt2DiMuonDetachedHeavyDecision", 
+              "Hlt2DiMuonDetachedJPsiDecision", 
+              "Hlt2DiMuonDetachedPsi2SDecision", 
+              "Hlt2DiMuonJPsiDecision", 
+              "Hlt2DiMuonJPsiHighPTDecision", 
+              "Hlt2DiMuonLowMassDecision", 
+              "Hlt2DiMuonPsi2SDecision", 
+              "Hlt2DiMuonPsi2SHighPTDecision", 
+              "Hlt2DiMuonZDecision", 
+              "Hlt2DiPhiDecision", 
+              "Hlt2DiProtonDecision", 
+              "Hlt2DiProtonLowMultDecision", 
+              "Hlt2DiProtonLowMultTFDecision", 
+              "Hlt2DiProtonTFDecision", 
+              "Hlt2DisplVerticesDoubleDecision", 
+              "Hlt2DisplVerticesDoublePSDecision", 
+              "Hlt2DisplVerticesDoublePostScaledDecision", 
+              "Hlt2DisplVerticesHighFDSingleDecision", 
+              "Hlt2DisplVerticesHighMassSingleDecision", 
+              "Hlt2DisplVerticesLowMassSingleDecision", 
+              "Hlt2DisplVerticesSingleDecision", 
+              "Hlt2DisplVerticesSingleDownDecision", 
+              "Hlt2DisplVerticesSingleHighFDDecision", 
+              "Hlt2DisplVerticesSingleHighFDPostScaledDecision", 
+              "Hlt2DisplVerticesSingleHighMassDecision", 
+              "Hlt2DisplVerticesSingleHighMassPostScaledDecision", 
+              "Hlt2DisplVerticesSingleLoosePSDecision", 
+              "Hlt2DisplVerticesSingleMVPostScaledDecision", 
+              "Hlt2DisplVerticesSinglePSDecision", 
+              "Hlt2DisplVerticesSinglePostScaledDecision", 
+              "Hlt2DisplVerticesSingleVeryHighFDDecision", 
+              "Hlt2DoubleDiMuonDecision", 
+              "Hlt2Dst2PiD02KMuDecision", 
+              "Hlt2Dst2PiD02KPiDecision", 
+              "Hlt2Dst2PiD02MuMuDecision", 
+              "Hlt2Dst2PiD02PiPiDecision", 
+              "Hlt2ErrorEventDecision", 
+              "Hlt2ExpressBeamHaloDecision", 
+              "Hlt2ExpressD02KPiDecision", 
+              "Hlt2ExpressDStar2D0PiDecision", 
+              "Hlt2ExpressDs2PhiPiDecision", 
+              "Hlt2ExpressHLT1PhysicsDecision", 
+              "Hlt2ExpressJPsiDecision", 
+              "Hlt2ExpressJPsiTagProbeDecision", 
+              "Hlt2ExpressKSDecision", 
+              "Hlt2ExpressLambdaDecision", 
+              "Hlt2ForwardDecision", 
+              "Hlt2GlobalDecision", 
+              "Hlt2IncPhiDecision", 
+              "Hlt2IncPhiSidebandsDecision", 
+              "Hlt2LambdaC_LambdaC2Lambda0DDKDecision", 
+              "Hlt2LambdaC_LambdaC2Lambda0DDPiDecision", 
+              "Hlt2LambdaC_LambdaC2Lambda0LLKDecision", 
+              "Hlt2LambdaC_LambdaC2Lambda0LLPiDecision", 
+              "Hlt2LowMultChiC2HHDecision", 
+              "Hlt2LowMultChiC2HHHHDecision", 
+              "Hlt2LowMultChiC2HHHHWSDecision", 
+              "Hlt2LowMultChiC2HHWSDecision", 
+              "Hlt2LowMultD2K3PiDecision", 
+              "Hlt2LowMultD2K3PiWSDecision", 
+              "Hlt2LowMultD2KPiDecision", 
+              "Hlt2LowMultD2KPiPiDecision", 
+              "Hlt2LowMultD2KPiPiWSDecision", 
+              "Hlt2LowMultD2KPiWSDecision", 
+              "Hlt2LowMultDDIncDecision", 
+              "Hlt2LowMultElectronDecision", 
+              "Hlt2LowMultElectron_nofilterDecision", 
+              "Hlt2LowMultHadronDecision", 
+              "Hlt2LowMultHadron_nofilterDecision", 
+              "Hlt2LowMultMuonDecision", 
+              "Hlt2LowMultPhotonDecision", 
+              "Hlt2LumiDecision", 
+              "Hlt2MuonFromHLT1Decision", 
+              "Hlt2PassThroughDecision", 
+              "Hlt2RadiativeTopoPhotonDecision", 
+              "Hlt2RadiativeTopoPhotonL0Decision", 
+              "Hlt2RadiativeTopoTrackDecision", 
+              "Hlt2RadiativeTopoTrackTOSDecision", 
+              "Hlt2SingleElectronTFHighPtDecision", 
+              "Hlt2SingleElectronTFLowPtDecision", 
+              "Hlt2SingleMuonDecision", 
+              "Hlt2SingleMuonHighPTDecision", 
+              "Hlt2SingleMuonLowPTDecision", 
+              "Hlt2SingleMuonVHighPTDecision", 
+              "Hlt2SingleTFElectronDecision", 
+              "Hlt2SingleTFVHighPtElectronDecision", 
+              "Hlt2TFBc2JpsiMuXDecision", 
+              "Hlt2TFBc2JpsiMuXSignalDecision", 
+              "Hlt2Topo2BodyBBDTDecision", 
+              "Hlt2Topo2BodySimpleDecision", 
+              "Hlt2Topo3BodyBBDTDecision", 
+              "Hlt2Topo3BodySimpleDecision", 
+              "Hlt2Topo4BodyBBDTDecision", 
+              "Hlt2Topo4BodySimpleDecision", 
+              "Hlt2TopoE2BodyBBDTDecision", 
+              "Hlt2TopoE3BodyBBDTDecision", 
+              "Hlt2TopoE4BodyBBDTDecision", 
+              "Hlt2TopoMu2BodyBBDTDecision", 
+              "Hlt2TopoMu3BodyBBDTDecision", 
+              "Hlt2TopoMu4BodyBBDTDecision", 
+              "Hlt2TopoRad2BodyBBDTDecision", 
+              "Hlt2TopoRad2plus1BodyBBDTDecision", 
+              "Hlt2TransparentDecision", 
+              "Hlt2TriMuonDetachedDecision", 
+              "Hlt2TriMuonTauDecision", 
+              "Hlt2diPhotonDiMuonDecision", 
+ ]
+
+def allLines(run):
+    if (1==run): return allRun1Lines()
+    else:        return allRun2Lines()
+
+def L0Lines():
+    return ["L0HadronDecision",
+            "L0MuonDecision",
+            "L0MuonLooseDecision",
+            "L0DiMuonDecision",
+            "L0ElectronDecision",
+            "L0ElectronLooseDecision",
+            "L0PhotonDecision"]
+
+def L0LowMultLines():
+    return ["L0DiEM,lowMultDecision",
+            "L0DiHadron,lowMultDecision",
+            "L0DiMuon,lowMultDecision",
+            "L0Electron,lowMultDecision",
+            "L0Muon,lowMultDecision",
+            "L0Photon,lowMultDecision",
+            ]
+
+def commonLines(run):
+    a = allLines(run)
+    l = L0Lines()
+    for i in a:
+        if 'TrackAll' in i:
+            if (1==run): l.append(i)   # run1
+        if 'TrackMVA' in i: 
+            if (2==run): l.append(i)   # run2
+        if (2==run):    # run2 -> short
+            if (i=="Hlt2Topo2BodyDecision" or i=="Hlt2Topo3BodyDecision" or i=="Hlt2Topo4BodyDecision"): l.append(i)
+        if (1==run):    # run1 -> long
+            if (i=="Hlt2Topo2BodyBBDTDecision" or i=="Hlt2Topo3BodyBBDTDecision" or i=="Hlt2Topo4BodyBBDTDecision"): l.append(i)
+    return l
+
+def muonLines(run):
+    a = allLines(run)
+    l = topoMuLines(run)
+    for i in a:
+         if 'Muon' in i and not ('DY' in i or 'Charm' in i or 'DiMuonAnd' in i or 'DiMuonZ' in i or 'Double' in i or 'TriMuon' in i or "PhotonDiMuon" in i or "TrackEff" in i or "PID" in i or "Calib" in i) : l.append(i)
+    return l
+         
+def topoMuLines(run):
+    a = allLines(run)
+    l = commonLines(run)
+    for i in a:
+        if (2==run):    # run2 -> short
+            if (i=="Hlt2TopoMu2BodyDecision" or i=="Hlt2TopoMu3BodyDecision" or i=="Hlt2TopoMu4BodyDecision"): l.append(i)
+        if (1==run):    # run1 -> long
+            if (i=="Hlt2Topo2MuBodyBBDTDecision" or i=="Hlt2TopoMu3BodyBBDTDecision" or i=="Hlt2TopoMu4BodyBBDTDecision"): l.append(i)
+    return l
+         
+def electronLines(run):
+    a = allLines(run)
+    l = commonLines(run)
+    for i in a:
+         if 'Electron' in i: l.append(i)
+         if 'TopoE' in i: l.append(i)
+    return l
+         
+def cepLines(run):
+    a = allLines(run)
+    l = L0LowMultLines()
+    l.append('Hlt1LowMultDecision')
+    l.append('Hlt2LowMultChiC2HHDecision')
+    l.append('Hlt2LowMultLMRDecision')
+    l.append('Hlt2LowMultLMR2HHDecision')
+    for i in a:
+        # Cristina: add all LowMult lines
+        if 'Hlt1CEP' in i: l.append(i)
+        if 'Hlt1LowMult' in i: l.append(i)
+        if 'Hlt1MBNoBias' in i: l.append(i)
+        if 'Hlt1NoPV' in i: l.append(i)
+        if 'Hlt1TrackAllL0' in i: l.append(i)
+        if 'Hlt1TrackMuon' in i: l.append(i)
+        if 'Hlt2LowMultDi' in i: l.append(i)
+        if 'Hlt2LowMultHadron' in i: l.append(i)
+        if 'Hlt2LowMultMuon' in i: l.append(i)
+        # Code from Patrick commented out: 
+        #if 'LowMultMuon' not in i: continue
+        #if 'Muon' in i: l.append(i)
+        #if 'Electron' in i: l.append(i)
+        #if 'Leptons' in i: l.append(i)
+        #if 'PassThrough' in i: l.append(i)
+    return l
+   
+def jpsi2eeAllL0HLT1Lines(run):
+    a = allLines(run)
+    l = L0Lines()
+    for i in a:
+        if 'Hlt1' in i: l.append(i)
+        if 'Hlt2' and 'Electron' in i: l.append(i)
+    for i in a:
+        if (2==run):    # run2 -> short
+            if (i=="Hlt2TopoMu2BodyDecision" or i=="Hlt2TopoMu3BodyDecision" or i=="Hlt2TopoMu4BodyDecision"): l.append(i) 
+    return l
diff --git a/CEP_Jpsi2ll/DiLeptonTuple/DiLeptonTuple.py b/CEP_Jpsi2ll/DiLeptonTuple/DiLeptonTuple.py
new file mode 100644
index 0000000000000000000000000000000000000000..3687a427b2cddd2e42de0dc0e37f8ec442e43918
--- /dev/null
+++ b/CEP_Jpsi2ll/DiLeptonTuple/DiLeptonTuple.py
@@ -0,0 +1,575 @@
+from Gaudi.Configuration import *
+from DecayTreeTuple.Configuration import *
+from AllTriggerLines import *
+
+# Decays
+Bd2JpsiKS0 = "B0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(KS0 -> ^pi+ ^pi-)"
+Psi2S2Jpsipipi   = "psi(2S) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^pi+ ^pi-"
+Psi2S2JpsiMuMupipi   = "psi(2S) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^pi+ ^pi-"
+Psi2S2JpsiEEpipi     = "psi(2S) -> ^(J/psi(1S) -> ^e+ ^e-) ^pi+ ^pi-"
+Psi2S2JpsiMuMupi0pi0 = "psi(2S) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^pi0 ^pi0"
+Psi2S2JpsiEEpi0pi0   = "psi(2S) -> ^(J/psi(1S) -> ^e+ ^e-) ^pi0 ^pi0"
+Psi2S2Chic0MuMuGamma = "psi(2S) -> ^(chi_c0(1P) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^gamma) ^gamma"
+Psi2S2Chic0EEGamma   = "psi(2S) -> ^(chi_c0(1P) -> ^(J/psi(1S) -> ^e+ ^e-) ^gamma) ^gamma"
+Psi2S2Chic1MuMuGamma = "psi(2S) -> ^(chi_c1(1P) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^gamma) ^gamma"
+Psi2S2Chic1EEGamma   = "psi(2S) -> ^(chi_c1(1P) -> ^(J/psi(1S) -> ^e+ ^e-) ^gamma) ^gamma"
+Psi2S2Chic2MuMuGamma = "psi(2S) -> ^(chi_c2(1P) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^gamma) ^gamma"
+Psi2S2Chic2EEGamma   = "psi(2S) -> ^(chi_c2(1P) -> ^(J/psi(1S) -> ^e+ ^e-) ^gamma) ^gamma"
+Psi2S2JpsiMuMuEta    = "psi(2S) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^eta"
+Psi2S2JpsiEEEta      = "psi(2S) -> ^(J/psi(1S) -> ^e+ ^e-) ^eta"
+Psi2S2JpsiMuMupi0    = "psi(2S) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^pi0"
+Psi2S2JpsiEEpi0      = "psi(2S) -> ^(J/psi(1S) -> ^e+ ^e-) ^pi0"
+X2Jpsipipi = "X_1(3872) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^pi+ ^pi-"
+X2JpsiKK = "X_1(3872) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^K+ ^K-"
+Jpsi2MuMu = "J/psi(1S) -> ^mu+ ^mu-"
+Chic02JpsiMuMuGamma = "chi_c0(1P) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^gamma"
+Chic02JpsiEEGamma = "chi_c0(1P) -> ^(J/psi(1S) -> ^e+ ^e-) ^gamma"
+Chic12JpsiMuMuGamma = "chi_c1(1P) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^gamma"
+Chic12JpsiEEGamma = "chi_c1(1P) -> ^(J/psi(1S) -> ^e+ ^e-) ^gamma"
+Chic22JpsiMuMuGamma = "chi_c2(1P) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^gamma"
+Chic22JpsiEEGamma = "chi_c2(1P) -> ^(J/psi(1S) -> ^e+ ^e-) ^gamma"
+Chic02JpsiMuMuGammaEE = "chi_c0(1P) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(gamma -> ^e+ ^e-)"
+Chic02JpsiEEGammaEE = "chi_c0(1P) -> ^(J/psi(1S) -> ^e+ ^e-) ^(gamma -> ^e+ ^e-)"
+Jpsi2ee = "J/psi(1S) -> ^e+ ^e-"
+Jpsi2MuMuSS = "[J/psi(1S) -> ^mu+ ^mu+]CC"
+Bu2MuMuK = "[B+ -> ^(J/psi(1S) -> ^mu- ^mu+) ^K+ ]CC"
+Bu2eeK = "[B+ -> ^(J/psi(1S) -> ^e- ^e+) ^K+ ]CC"
+Bu2MueK = "[B+ -> ^(J/psi(1S) -> ^mu- ^e+) ^K+ ]CC"
+Bu2eMuK = "[B+ -> ^(J/psi(1S) -> ^e- ^mu+) ^K+ ]CC"
+Bu2JpsiPi = "[B+ -> ^(J/psi(1S) -> ^mu+ ^mu-) ^pi+]CC"
+Bu2JpsiK = "[B+ -> ^(J/psi(1S) -> ^mu+ ^mu-) ^K+]CC"
+Bs2JpsiPhi = "B_s0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(phi(1020) -> ^K+ ^K-)"
+Bd2JpsiPi0 = "B0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^pi0"
+Bd2JpsiKstar = "[B0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(K*(892)0 -> ^K+ ^pi-)]CC"
+
+Bd2eeKst = "[B0 -> ^(J/psi(1S) -> ^e+ ^e-) ^(K*(892)0 -> ^K+ ^pi-) ]CC"
+Bd2MuMuKst = "[B0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(K*(892)0 -> ^K+ ^pi-) ]CC"
+Bd2MuMuKstSS = "[B0 -> ^(J/psi(1S) -> ^mu+ ^mu+) ^(K*(892)0 -> ^K+ ^pi-) ]CC"
+Bd2MueKst = "[B0 -> ^(J/psi(1S) -> ^mu+ ^e-) ^(K*(892)0 -> ^K+ ^pi-) ]CC"
+Bd2eMuKst = "[B0 -> ^(J/psi(1S) -> ^e+ ^mu-) ^(K*(892)0 -> ^K+ ^pi-) ]CC"
+Lambdab2MuMupK = "[Lambda_b0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(Lambda(1520)0 -> ^p+ ^K-) ]CC"
+
+Lambdab2Jpsippi = "[Lambda_b0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^p+ ^pi-]CC"
+Lambdab2JpsiLambda = "[Lambda_b0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(Lambda0 -> ^p+ ^pi-)]CC"
+Xib2Lambdabpi = "[Xi_b- -> ^(Lambda_b0 -> ( ^J/psi(1S) -> ^mu+ ^mu-) ^(Lambda0 -> ^p+ ^pi-)) ^pi-  ]CC"
+Xib2LambdabpiWS = "[Xi_b~+ -> ^(Lambda_b0 -> ( ^J/psi(1S) -> ^mu+ ^mu-) ^(Lambda0 -> ^p+ ^pi-)) ^pi+ ]CC"
+Xib2PsiLpi = "[Xi_b- -> ( ^J/psi(1S) -> ^mu+ ^mu-) ^(Lambda0 -> ^p+ ^pi-) ^pi-  ]CC"
+Xib2PsiLpiWS = "[Xi_b~+ -> ( ^J/psi(1S) -> ^mu+ ^mu-) ^(Lambda0 -> ^p+ ^pi-) ^pi+ ]CC"
+
+##############################################################################
+#
+# Tuple maker
+#
+def addTuple(name="", decay="", datatype="", shortname="", verbose=[], options=["DTF","Resonant"], Inputs = [] ):
+    from Configurables import DecayTreeTuple, PrintDecayTree, FilterDesktop, GaudiSequencer, PrintHeader, TESCheck, CheckPV, DaVinci
+    
+    if shortname == "": shortname = name
+    shortname = shortname+"_Tuple" # +datatype
+    shortname = shortname.replace("MCMC","MC")
+    seq = GaudiSequencer("Seq"+shortname)
+    dtf = ("DTF" in options)
+    resonant = ("Resonant" in options)
+    short = ("Short" in options)
+    run = 2
+    if ("Run1" in options): run = 1
+    
+    if not Inputs : Inputs = [ name+"/Particles" ] 
+
+#    if ("MC"==datatype or ""==datatype): location = "/Event/Phys/"+name+"/Particles"
+#    if ("TURBO"!=datatype):
+#        from Configurables import LoKi__HDRFilter       
+#        filter = TESCheck("Check"+shortname, Inputs = Inputs, Stop = False)
+#        else :              # I am not running the selection, hence the stripping decision must be here     
+#            filter = LoKi__HDRFilter( "Check"+shortname,
+#                                  Code = "HLT_PASS('Stripping"+name+"Decision')",
+#                                  Location="/Event/Strip/Phys/DecReports" )
+#        seq.Members += [  filter ] # PrintHeader(),
+
+    tuple = DecayTreeTuple(shortname)
+    if (short): tuple.ToolList = []
+    isMDST = (datatype.upper()=="MDST")        
+    isTURBO = (datatype.upper()=="TURBO")        
+    tuple.Inputs = Inputs
+
+#    tuple.OutputLevel = 1
+    tuple.ToolList =  []
+        
+    tuple.Decay = decay
+
+    multiPV = False
+    if (not short):
+        tg = tuple.addTupleTool("TupleToolGeometry")
+        if not isMDST and not isTURBO and not "CEP" in options and "NoCheckPV" not in options :
+            multiPV = True
+            tg.FillMultiPV = True
+
+    tlist = []
+    if ( "AllLines" in options):
+        tlist = allLines(run)
+    elif ( "L0eLines+AllLines" in options):
+        tlist = jpsi2eeAllL0HLT1Lines(run)
+    elif ( "CEP" in options):
+        tlist = cepLines(run)            
+    elif ("e+" in decay):
+        tlist = electronLines(run)            
+    elif ( decay == Jpsi2MuMu or decay == Jpsi2MuMuSS or decay == Psi2S2Jpsipipi or decay == X2Jpsipipi or decay == X2JpsiKK or decay == Chic12JpsiMuMuGamma or decay == Chic02JpsiMuMuGamma or decay == Chic22JpsiMuMuGamma):
+        tlist = muonLines(run)
+    elif ("mu+" in decay):
+        tlist = muonLines(run)
+        tlist.append(topoMuLines(run))
+    if ( False ):
+        tlist = allLines(run)
+    print(tlist)
+    
+    # psi branch
+    Psi = tuple.addTupleTool("TupleToolDecay/Psi")
+    if ( Jpsi2ee != decay and Jpsi2MuMu != decay): bpsi = (decay.replace("^","")).replace("(J/psi(1S)","^(J/psi(1S)")
+    else : bpsi = "^("+decay.replace("^","")+")"
+    print("J/psi branch is ``{0}''".format(bpsi))
+    if ( Jpsi2ee in decay ):
+        eplus = tuple.addTupleTool("TupleToolDecay", name = "eplus")
+        eminus = tuple.addTupleTool("TupleToolDecay", name = "eminus")
+        tuple.Branches = {
+            "Psi" : bpsi,
+            "eplus": "J/psi(1S) -> ^e+ e-",
+            "eminus" : "J/psi(1S) -> e+ ^e-"}
+    elif ( Jpsi2MuMu in decay):
+        muplus = tuple.addTupleTool("TupleToolDecay", name = "muplus")
+        muminus = tuple.addTupleTool("TupleToolDecay", name = "muminus")
+        tuple.Branches = {
+            "Psi" : bpsi,
+            "muplus": "J/psi(1S) -> ^mu+ mu-",
+            "muminus" : "J/psi(1S) -> mu+ ^mu-"}
+    else:
+        tuple.Branches["Psi"] = bpsi
+        
+    # sort out kstars
+    if "892" in decay:
+        bkstar = (decay.replace("^","")).replace("(K*(892)","^(K*(892)")
+        tuple.Branches["Kstar"] = bkstar
+        Kstar = tuple.addTupleTool("TupleToolDecay/Kstar")
+
+    from Configurables import TupleToolTISTOS
+    tistos = TupleToolTISTOS(TriggerList = tlist, VerboseHlt1 = True, VerboseHlt2 = True, VerboseL0 = True)#, TUS = True, TPS = True)
+    #tistos.OutputLevel = 1
+    
+    if ( not Psi2S2JpsiMuMupipi == decay or Psi2S2JpsiEEpipi == decay and not X2Jpsipipi==decay and not X2JpsiKK==decay or Psi2S2JpsiMuMupi0pi0 == decay or Psi2S2JpsiEEpi0pi0 == decay or Psi2S2JpsiMuMupi0 == decay or Psi2S2JpsiEEpi0 == decay or Psi2S2JpsiMuMuEta == decay or Psi2S2JpsiEEEta == decay or Psi2S2Chic0MuMuGamma == decay or Psi2S2Chic0EEGamma == decay or Psi2S2Chic1MuMuGamma == decay or Psi2S2Chic1EEGamma == decay or Psi2S2Chic2MuMuGamma == decay or Psi2S2Chic2EEGamma == decay or Psi2S2Jpsipipi == decay): 
+        Psi.addTool(tistos)
+        Psi.ToolList += [ "TupleToolTISTOS" ]
+#    if (not isMDST):
+#        vi = tuple.Psi.addTupleTool("TupleToolVtxIsoln")
+#        vi.InputParticles = [ "/Event/Phys/MyGoodPions" ]
+
+    if ( Jpsi2ee == decay or Jpsi2MuMu == decay or Jpsi2MuMuSS == decay ): # Psi
+        if (dtf):
+            pvfit = tuple.Psi.addTupleTool("TupleToolDecayTreeFitter/PVFit")        # fit with all constraints I can think of
+            pvfit.Verbose = True
+            pvfit.constrainToOriginVertex = ( "Constrain" in options )   # Usually not
+
+    elif ( Psi2S2JpsiMuMupipi == decay or Psi2S2JpsiEEpipi == decay or X2Jpsipipi==decay or X2JpsiKK==decay or Psi2S2JpsiMuMupi0pi0 == decay or Psi2S2JpsiEEpi0pi0 == decay or Psi2S2JpsiMuMupi0 == decay or Psi2S2JpsiEEpi0 == decay or Psi2S2JpsiMuMuEta == decay or Psi2S2JpsiEEEta == decay or Psi2S2Chic0MuMuGamma == decay or Psi2S2Chic0EEGamma == decay or Psi2S2Chic1MuMuGamma == decay or Psi2S2Chic1EEGamma == decay or Psi2S2Chic2MuMuGamma == decay or Psi2S2Chic2EEGamma == decay or Psi2S2Jpsipipi == decay): # X(3872) and so
+        if (Psi2S2Jpsipipi == decay or Psi2S2JpsiMuMupipi == decay or Psi2S2JpsiEEpipi == decay or X2Jpsipipi==decay or X2JpsiKK==decay or Psi2S2JpsiMuMupi0pi0 == decay or Psi2S2JpsiEEpi0pi0 == decay or Psi2S2JpsiMuMupi0 == decay or Psi2S2JpsiEEpi0 == decay or Psi2S2JpsiMuMuEta == decay or Psi2S2JpsiEEEta == decay or Psi2S2Chic0MuMuGamma == decay or Psi2S2Chic0EEGamma == decay or Psi2S2Chic1MuMuGamma == decay or Psi2S2Chic1EEGamma == decay or Psi2S2Chic2MuMuGamma == decay or Psi2S2Chic2EEGamma == decay): theX = "psi_2S"
+        elif (X2Jpsipipi==decay or X2JpsiKK==decay): theX = "X"
+        psipipi = tuple.addTupleTool("TupleToolDecay/"+theX)
+        tuple.Branches[theX] = "^("+decay.replace("^","")+")"
+        psipipi.addTool(tistos)
+        psipipi.ToolList += [ "TupleToolTISTOS" ]
+        if (dtf):
+            psifit = psipipi.addTupleTool("TupleToolDecayTreeFitter/JpsiFit")        
+            psifit.Verbose = True
+            psifit.constrainToOriginVertex = False
+            psifit.daughtersToConstrain += [ "J/psi(1S)" ] # constrain J/psi
+        
+    elif ( Chic12JpsiMuMuGamma == decay or Chic02JpsiMuMuGamma == decay or Chic22JpsiMuMuGamma == decay or Chic12JpsiEEGamma == decay or Chic02JpsiEEGamma == decay or Chic22JpsiEEGamma == decay ): # chic
+        chic = tuple.addTupleTool("TupleToolDecay/Chic")
+        gamma = tuple.addTupleTool("TupleToolDecay/gamma")
+        tuple.Branches = {
+            "Chic" : "^("+decay.replace("^","")+")",
+            "gamma" : decay.replace("^","").replace("gamma","^gamma")} 
+        chic.addTool(tistos)
+        chic.ToolList += [ "TupleToolTISTOS" ]
+        if (dtf):
+            psifit = chic.addTupleTool("TupleToolDecayTreeFitter/JpsiFit")        
+            psifit.Verbose = True
+            psifit.constrainToOriginVertex = False
+            psifit.daughtersToConstrain += [ "J/psi(1S)" ] # constrain J/psi
+
+    elif ( Chic02JpsiMuMuGammaEE == decay or Chic02JpsiEEGammaEE == decay ): # chic
+        chic = tuple.addTupleTool("TupleToolDecay/Chic")
+        gamma = tuple.addTupleTool("TupleToolDecay/gamma")
+        tuple.Branches = {
+            "Chic" : "^("+decay.replace("^","")+")",
+            "gamma" : decay.replace("^","").replace("(gamma -> e+ e-)","^(gamma -> e+ e-)")}
+        chic.addTool(tistos)
+        chic.ToolList += [ "TupleToolTISTOS" ]
+        if (dtf):
+            psifit = chic.addTupleTool("TupleToolDecayTreeFitter/JpsiFit")
+            psifit.Verbose = True
+            psifit.constrainToOriginVertex = False
+            psifit.daughtersToConstrain += [ "J/psi(1S)" ] # constrain J/psi
+
+
+    else:   # it's a b-hadron. Dtf will be done
+        B = tuple.addTupleTool("TupleToolDecay/B")
+        bh = "UNDEFINED"
+        if ('Xi_b-' in decay ): bh = 'Xi_b-'
+        elif ('Xi_b~+' in decay ): bh = 'Xi_b~+'
+        elif ('Lambda_b0' in decay ): bh = 'Lambda_b0'
+        elif ('B0' in decay): bh = 'B0'
+        elif ('B+' in decay ): bh = 'B+'
+        elif ('B_s0' in decay ): bh = 'B_s0'
+        if ('CC' in decay): bh = '['+bh+']cc'
+        print("Branch will be ``{0} : {1}''".format(bh,decay.replace("^","")))
+
+        tuple.Branches["B"] = "^("+decay.replace("^","")+")"
+        
+        # This is needed for ConstB
+        bhh = bh.replace('[','').replace(']cc','')
+
+        if ( Psi2S2Jpsipipi == decay or  X2Jpsipipi==decay or  X2JpsiKK==decay): 
+            B.addTool(tistos)
+            B.ToolList += [ "TupleToolTISTOS" ]
+
+        if ( Bs2JpsiPhi==decay ):
+            p2vv = B.addTupleTool("TupleToolP2VV") 
+            p2vv.Calculator = "Bs2JpsiPhiAngleCalculator"
+        elif ( "K*(892)0" in decay and not Bd2MuMuKstSS==decay ):
+            p2vv = B.addTupleTool("TupleToolP2VV") 
+            p2vv.Calculator = "Bd2KstarMuMuAngleCalculator"
+        if (Lambdab2Jpsippi==decay ): B.addTupleTool("TupleToolDalitz") 
+
+        if (('pi0' not in decay) and ('KS0' not in decay) and ('Lambda0' not in decay)):
+#            B.ToolList +=  [ "TupleToolAngles"] 
+            tta = tuple.addTupleTool("TupleToolAngles") 
+            if (not resonant): tta.WRTMother = False 
+#            if (( 'K*(892)0' in decay)  or ('phi' in decay)): tuple.B.ToolList +=  [ "TupleToolP2VV" ]  # really wants a VV
+        if (dtf):
+            FullFit = B.addTupleTool("TupleToolDecayTreeFitter/FullFit")
+            FullFit.Verbose = True                          # fills daughters
+            FullFit.constrainToOriginVertex = True  # else constrain pointing
+            FullFit.daughtersToConstrain += [ "J/psi(1S)" ] # even non resonant
+
+            if ("ConstBFit" in verbose):
+                ConstBFit = B.addTupleTool("TupleToolDecayTreeFitter/ConstBFit")
+                ConstBFit.Verbose = True
+                ConstBFit.constrainToOriginVertex = True
+                ConstBFit.daughtersToConstrain += [ "J/psi(1S)", bhh ] # constrain B as well
+                ConstBFit.UpdateDaughters = True                       # Maurizio's daughters
+
+            for d in [ 'KS0', 'pi0', 'Lambda0' ]:
+                if d in decay:
+                    FullFit.daughtersToConstrain += [ d ]
+                    if ( "ConstBFit" in verbose ): ConstBFit.daughtersToConstrain += [ d ]
+            if (not resonant):
+                NoPsiFit = B.addTupleTool("TupleToolDecayTreeFitter/NoPsiFit")
+                NoPsiFit.Verbose = True
+                NoPsiFit.constrainToOriginVertex = True
+            if (not resonant): #b constraint for calculating qsq
+                ConstBNoPsiFit = B.addTupleTool("TupleToolDecayTreeFitter/ConstBNoPsiFit")
+                ConstBNoPsiFit.Verbose = True
+                ConstBNoPsiFit.constrainToOriginVertex = True
+                ConstBNoPsiFit.daughtersToConstrain += [ bhh ] # constrain B as well
+                ConstBNoPsiFit.UpdateDaughters = True                       # Maurizio's daughters
+
+            #if (resonant and ('KS0' in decay or "pi0" in decay or 'Lambda0' in decay)):
+            #    OnlyPsiFit = B.addTupleTool("TupleToolDecayTreeFitter/OnlyPsiFit")
+            #    OnlyPsiFit.Verbose = True
+            #    OnlyPsiFit.constrainToOriginVertex = True
+            #    OnlyPsiFit.daughtersToConstrain += [ "J/psi(1S)" ]
+            if ('phi' in decay):
+                substitute1 = { 'Beauty -> Meson (Strange -> ^K+ K-)': 'pi+'  }
+                from Configurables import TupleToolDecayTreeFitter
+                subDTF = TupleToolDecayTreeFitter("SubPipKm", Verbose=False,
+                                                  daughtersToConstrain = [ "J/psi(1S)" ],
+                                                  constrainToOriginVertex=True,
+                                                  Substitutions=substitute1)
+                B.addTool(subDTF)
+                B.ToolList += [ "TupleToolDecayTreeFitter/SubPipKm" ]
+                
+                B.addTool(subDTF)
+                substitute2 = { 'Beauty -> Meson (Strange -> K+ ^K-)': 'pi-' }
+                B.addTool(subDTF.clone("SubKpPim",Substitutions=substitute2))
+                B.ToolList += [ "TupleToolDecayTreeFitter/SubKpPim" ]
+
+            if ( Lambdab2Jpsippi==decay ):
+                substitute1 = { 'Beauty -> Meson p+ ^pi-': 'K-', 'Beauty -> Meson p~- ^pi+': 'K+'  }
+                from Configurables import TupleToolDecayTreeFitter
+                B.addTupleTool(TupleToolDecayTreeFitter("SubpK", Verbose=False,
+                                                        daughtersToConstrain = [ "J/psi(1S)" ],
+                                                        constrainToOriginVertex=True,
+                                                        Substitutions=substitute1))
+                        
+                substitute2 = { 'Beauty -> Meson ^p+ pi-': 'K+', 'Beauty -> Meson ^p~- pi+': 'K-'  }
+                B.addTupleTool(TupleToolDecayTreeFitter("SubKpi", Verbose=False,
+                                                        daughtersToConstrain = [ "J/psi(1S)" ],
+                                                        constrainToOriginVertex=True,
+                                                        Substitutions=substitute2))
+                if ("ConstBFit" in verbose):
+                    ConstBSubFit = B.addTupleTool("TupleToolDecayTreeFitter/ConstBSubFit")
+                    ConstBSubFit.Substitutions=substitute1   # substitute and then constrain
+                    ConstBSubFit.Verbose = True
+                    ConstBSubFit.constrainToOriginVertex = True
+                    ConstBSubFit.daughtersToConstrain += [ "J/psi(1S)", bhh ] # constrain B as well
+                    ConstBSubFit.UpdateDaughters = True                       # Maurizio's daughters
+
+            if ( Bd2JpsiKS0==decay ):
+                substitute1 = { 'Beauty -> Meson (Strange -> ^pi+ pi-)' : 'K+' }
+                substitute2 = { 'Beauty -> Meson (Strange -> pi+ ^pi-)' : 'K-' }
+                from Configurables import TupleToolDecayTreeFitter
+                B.addTupleTool(TupleToolDecayTreeFitter("PsiKppim", Verbose=False,
+                                                        daughtersToConstrain = [ "J/psi(1S)" ],
+                                                        constrainToOriginVertex=True,
+                                                        Substitutions=substitute1))
+                        
+                B.addTupleTool(TupleToolDecayTreeFitter("PsiKmpip", Verbose=False,
+                                                        daughtersToConstrain = [ "J/psi(1S)" ],
+                                                        constrainToOriginVertex=True,
+                                                        Substitutions=substitute2))
+
+            if ( Bu2JpsiK == decay):
+            
+                substitute2 = { 'Beauty -> Meson ^K+': 'pi+', 'Beauty -> Meson ^K-': 'pi-' }
+                subDTF2 = B.addTupleTool(TupleToolDecayTreeFitter("Subpi", Verbose=False,
+                                                                  daughtersToConstrain = [ "J/psi(1S)" ],
+                                                                  constrainToOriginVertex=True,
+                                                                  Substitutions=substitute2))
+            
+            if ( Bu2eeK == decay or Bu2MuMuK == decay or Bu2MueK == decay or Bu2eMuK == decay):
+                if Bu2eeK == decay : substitute1 = {  "Beauty -> ( J/psi(1S) -> ^e+ X- ) Strange " : "pi+" ,
+                                                      "Beauty -> ( J/psi(1S) -> ^e- X+ ) Strange " : "pi-" }
+                elif Bu2MuMuK == decay : substitute1 = {  "Beauty -> ( J/psi(1S) -> ^mu+ X- ) Strange " : "pi+" ,
+                                                          "Beauty -> ( J/psi(1S) -> ^mu- X+ ) Strange " : "pi-" }
+                elif Bu2MueK == decay : substitute1 = {  "Beauty -> ( J/psi(1S) -> ^e+ X- ) Strange " : "pi+" ,
+                                                         "Beauty -> ( J/psi(1S) -> ^mu- X+ ) Strange " : "pi-" }
+                elif Bu2eMuK == decay : substitute1 = {  "Beauty -> ( J/psi(1S) -> ^mu+ X- ) Strange " : "pi+" ,
+                                                         "Beauty -> ( J/psi(1S) -> ^e- X+ ) Strange " : "pi-" }
+
+                from Configurables import TupleToolDecayTreeFitter
+                subDTF = B.addTupleTool(TupleToolDecayTreeFitter("Subpipi", Verbose=False,
+                                                                 constrainToOriginVertex=True,
+                                                                 Substitutions=substitute1,
+                                                                 UpdateDaughters = True)) # Maurizio's daughters
+                    
+#        """
+#        if (('KS0' in decay) or ("K*(892)" in decay) or ("Lambda0" in decay)):
+#            mh = tuple.addTupleTool("TupleToolMassHypo")
+#            if ("KS0" in decay):
+#                mh.PIDReplacements = { "pi+" : "p+" }    
+#            #if ("K*(892)" in decay):
+#            #    mh.PIDReplacements = { "pi-" : "K+" }     
+#            if ("Lambda0" in decay):
+#                mh.PIDReplacements = { "p+" : "pi+" }
+#        """
+                
+        B.addTool(tistos)
+        B.ToolList += [ "TupleToolTISTOS"  ]
+
+
+    if (not short):  
+        rs = tuple.addTupleTool("TupleToolRecoStats")
+        rs.Verbose = ("RecoStats" in verbose)
+    ei = tuple.addTupleTool("TupleToolEventInfo")
+    ei.Verbose = ("EventInfo" in verbose)                  # gives GpsYear, month, day, etc
+    ki = tuple.addTupleTool("TupleToolKinematic")          # gives _AtVtx_P
+    ki.Verbose=  ("Kinematic" in verbose)
+
+    bspot = tuple.addTupleTool("TupleToolBeamSpot")
+    bspot.Verbose = ("BeamSpot" in verbose)
+
+    fillsc = tuple.addTupleTool("TupleToolFillingScheme")
+    
+    allphot = tuple.addTupleTool("TupleToolAllPhotons")
+
+    partstat = tuple.addTupleTool("TupleToolParticleStats")
+  
+    if ("CEP" not in options): tuple.addTupleTool("TupleToolPrimaries")
+    ti = tuple.addTupleTool("TupleToolTrackInfo")
+    ti.Verbose = ("TrackInfo" in verbose)                  # gives many more chi2
+    if ('e+' in decay or "TrackInfo" in verbose): ti.StoredMeasurements = [ "FirstMeasurement", "AtTT" ]    # gives all track parameters
+    if ( "TrackPosition" in  verbose):                     # extrapolates to TT, IT
+        tp1 = tuple.addTupleTool("TupleToolTrackPosition/TupleToolTrackPositionTT")
+        tp2 = tuple.addTupleTool("TupleToolTrackPosition/TupleToolTrackPositionIT")
+        tp1.ExtraName = "TT"
+        tp2.ExtraName = "IT"
+        tp2.Z = 7800    
+    if (not short):
+        pid = tuple.addTupleTool("TupleToolPid")
+        pid.Verbose = ("Pid" in verbose)               # many more vars in RICH
+    tuple.addTupleTool("TupleToolANNPID")
+    if ('e+' in decay):
+        brem = tuple.addTupleTool("TupleToolBremInfo")
+    if ('e+' or 'mu+' in decay):
+        calo = tuple.addTupleTool("TupleToolL0Calo")
+        calo.WhichCalo = "ECAL"
+        # Get the trigger ET information
+        calo.TriggerClusterLocation = "/Event/Trig/L0/Calo"
+
+    #isolation
+    if "iso" in verbose :
+        # lines from Greg Ciezarek
+        #from configIso import configIso
+        #configIso()
+        # this is work in progress 
+        #will be comitted to SVN properly at a future date as of 3/4/14
+        from Configurables import TupleToolApplyIsolation
+        tuple.B.addTool(TupleToolApplyIsolation,    name="TupleToolApplyIsolationHard")
+        tuple.B.TupleToolApplyIsolationHard.OutputSuffix="_Hard"
+        tuple.B.TupleToolApplyIsolationHard.WeightsFile="weightsHard.xml"
+        tuple.B.ToolList+=["TupleToolApplyIsolation/TupleToolApplyIsolationHard"]
+        tuple.B.addTool(TupleToolApplyIsolation,    name="TupleToolApplyIsolationSoft")
+        tuple.B.TupleToolApplyIsolationSoft.OutputSuffix="_Soft"
+        tuple.B.TupleToolApplyIsolationSoft.WeightsFile="weightsSoft.xml"
+        tuple.B.ToolList+=["TupleToolApplyIsolation/TupleToolApplyIsolationSoft"]  
+        #vtxiso = tuple.B.addTupleTool("TupleToolVtxIsoln")
+        #tuple.B.TupleToolApplyIsolationHard.OutputLevel = 3 
+        #tuple.B.TupleToolApplyIsolationSoft.OutputLevel = 3 
+#    tuple.addTupleTool("TupleToolPropertime")
+    if ( "Stripping" in verbose ): # not reading stripping output
+        tts = tuple.addTupleTool("TupleToolStripping")
+        tts.StrippingList = [ 
+            "StrippingBetaSBd2JpsiKsDetachedLineDecision", 
+            "StrippingBetaSBd2JpsiKsPrescaledLineDecision", 
+            "StrippingBetaSBd2JpsiKstarDetachedLineDecision", 
+            "StrippingBetaSBd2JpsiKstarPrescaledLineDecision", 
+            "StrippingBetaSBs2ChicPhi_Chic2KKPiPiNominalLineDecision", 
+            "StrippingBetaSBs2ChicPhi_Chic2PiPiPiPiNominalLineDecision", 
+            "StrippingBetaSBs2EtacPhiNominalLineDecision", 
+            "StrippingBetaSBs2JpsiEtaDetachedLineDecision", 
+            "StrippingBetaSBs2JpsiEtaPrescaledLineDecision", 
+            "StrippingBetaSBs2JpsiKstarLineDecision", 
+            "StrippingBetaSBs2JpsiPhiDetachedLineDecision", 
+            "StrippingBetaSBs2JpsiPhiPrescaledLineDecision", 
+            "StrippingBetaSBs2JpsieePhiDetachedLineDecision", 
+            "StrippingBetaSBs2JpsieePhiLineDecision", 
+            "StrippingBetaSBs2Jpsif0LineDecision", 
+            "StrippingBetaSBs2K0stK0stNominalLineDecision", 
+            "StrippingBetaSBs2KstKstNominalLineDecision", 
+            "StrippingBetaSBs2KstKstSameChargeLineDecision", 
+            "StrippingBetaSBs2PhiKstNominalLineDecision", 
+            "StrippingBetaSBs2PhiPhiLineDecision", 
+            "StrippingBetaSBs2PhiPhiWideLineDecision", 
+            "StrippingBetaSBs2Q2Body4piLineDecision", 
+            "StrippingBetaSBu2JpsiKDetachedLineDecision", 
+            "StrippingBetaSBu2JpsiKNoPIDDetachedLineDecision", 
+            "StrippingBetaSBu2JpsiKPrescaledLineDecision", 
+            "StrippingBetaSJpsi2MuMuDetachedLineDecision", 
+            "StrippingBetaSJpsi2MuMuLineDecision", 
+            "StrippingBetaSLambdab2JpsiLambdaUnbiasedLineDecision", 
+            "StrippingBu2LLK_eeLineDecision", 
+            "StrippingBu2LLK_mmLineDecision", 
+            "StrippingBd2KstarMuMu_BdToKstarMuMuLineDecision", 
+            "StrippingBd2KstarMuMu_BdToKstarMuMuLowPLineDecision", 
+            "StrippingBd2KstarMuMu_BdToKstarMuMuSSLineDecision", 
+            "StrippingBd2KstarMuMu_BdToKstarMuMuSSLowPLineDecision", 
+            "StrippingBd2KstarMuMu_BuToKMuMuLineDecision", 
+            "StrippingBd2KstarMuMu_BuToKMuMuSSLineDecision" ]
+    if ( "CEP" in options ):
+        tts = tuple.addTupleTool("TupleToolStripping")
+        tts.Verbose = True
+        tts.StrippingList = [
+            "StrippingLowMultDiMuonLineDecision",
+            "StrippingLowMultDiPhotonLineDecision",
+            "StrippingLowMultLMR2HHHHLineDecision",
+            "StrippingLowMultLMR2HHLineDecision",
+            "StrippingLowMultMuonLineDecision",
+            "StrippingLowMultPi0LineDecision",
+            "StrippingLowMultTMPLineDecision",
+            "StrippingLowMultDiElectronLineDecision" ]
+    if ( "CEP" in options and not datatype=="MC" ):
+        tth = tuple.addTupleTool("TupleToolHerschel")
+        tth.OutputLevel = 6
+        if "2015" in options : tth.DigitsLocation="Raw/HC/CorrectedDigits" 
+        
+    if (not short):
+        tuple.addTupleTool("TupleToolPhotonInfo")
+        tuple.addTupleTool("TupleToolPi0Info")
+#    tuple.OutputLevel = 1
+    if ( datatype == "MC" ):   # it's MC!
+        tmc = tuple.addTupleTool("TupleToolMCTruth")
+#        tmc.addTupleTool("MCTupleToolKinematic")
+        for tool in tmc.ToolList:
+            if ( "MCTupleToolHierarchy" not in tmc.ToolList ):
+                tmc.addTupleTool("MCTupleToolHierarchy")
+        tuple.addTupleTool("TupleToolMCBackgroundInfo")
+    
+    if ("ElectronVars" in verbose):    
+        #tev = tuple.addTupleTool("LoKi::Hybrid::TupleTool/ElectronVars")
+        #tev.Variables = { 
+        dictElectronVars = {
+            "eta"               : "ETA",
+            "phi"               : "PHI",
+            #"TRACK_PT"          : "PPINFO(505,-100,-200)",
+            #"TRACK_P"           : "PPINFO(504,-100,-200)",
+            #"TRACK_GhostProb"   : "TRGHOSTPROB",
+            #"TRACK_Chi2DOF"     : "TRCHI2DOF",
+            "RichPIDe"          : "PPINFO(100,-10000,-20000)",
+            "InAccBrem"         : "PPINFO(304,-1,-2)",
+            "BremPIDe"          : "PPINFO(362,-10000,-20000)",
+            #"VeloCharge"        : "PPINFO(400,-1,-2)",
+            "CaloTrMatch"       : "PPINFO(310,-1,-1000)",
+            "CaloElectronMatch" : "PPINFO(311,-1,-2)",
+            "CaloBremMatch"     : "PPINFO(312,-1,-2)",
+            "CaloBremChi2"      : "PPINFO(335,-1,-1000)",
+            "CaloEoverP"        : "PPINFO(338,-1,-2)",
+            "CaloSpdE"          : "PPINFO(330,-1,-2)",
+            "CaloPrsE"          : "PPINFO(331,-1,-2)",
+            "CaloEcalE"         : "PPINFO(332,-1,-1000)",
+            "CaloHcalE"         : "PPINFO(333,-1,-1000)",
+            "CaloNeutralID"     : "PPINFO(328,-1,-1000)",
+            "ClusterAsX"        : "PPINFO(390,-100000,-200000)",
+            "ClusterAsY"        : "PPINFO(391,-100000,-200000)",
+            "PrsPIDe"           : "PPINFO(361,-1000,-2000)",
+            "EcalPIDe"          : "PPINFO(360,-1000,-2000)",
+            "HcalPIDe"          : "PPINFO(363,-1000,-2000)",
+            "IsPhoton"          : "PPINFO(381,-1,-1000)",
+            "IsNotE"            : "PPINFO(382,-1,-1000)",
+            "IsNotH"            : "PPINFO(383,-1,-1000)",
+            "InAccBrem"         : "PPINFO(304,-1,-1000)",
+            "PhotonID"          : "PPINFO(380,-1,-1000)"}
+      
+        if ( Jpsi2ee in decay ):
+            tuple.eplus.addTupleTool("LoKi::Hybrid::TupleTool/ElectronVars")
+            tuple.eplus.ElectronVars.Variables = dictElectronVars 
+            tuple.eminus.addTupleTool("LoKi::Hybrid::TupleTool/ElectronVars")
+            tuple.eminus.ElectronVars.Variables = dictElectronVars 
+        elif ( Jpsi2MuMu in decay):
+            tuple.muplus.addTupleTool("LoKi::Hybrid::TupleTool/ElectronVars")
+            tuple.muplus.ElectronVars.Variables = dictElectronVars 
+            tuple.muminus.addTupleTool("LoKi::Hybrid::TupleTool/ElectronVars")
+            tuple.muminus.ElectronVars.Variables = dictElectronVars 
+        elif ( "gamma" in decay):
+            tuple.gamma.addTupleTool("LoKi::Hybrid::TupleTool/ElectronVars")
+            tuple.gamma.ElectronVars.Variables = dictElectronVars
+        else:
+            tuple.addTupleTool("LoKi::Hybrid::TupleTool/ElectronVars")
+            tuple.ElectronVars.Variables = dictElectronVars 
+            
+    
+    if (isMDST):
+        seq.Members += [ #PrintDecayTree( Inputs = [ location]),
+            EventNodeKiller(Nodes=["DAQ"] ) ]
+
+    if ( datatype == "MC" ):   # it's not MC!
+        from Configurables import TrackSmearState as SMEAR
+        smear = SMEAR()
+#        seq.Members += [ smear ]+
+    elif (not isMDST and not isTURBO):   # it's not mdst
+        from Configurables import TrackScaleState as SCALER
+        scaler = SCALER('StateScale')   
+        seq.Members += [ scaler ]
+
+    if (("NoCheckPV" not in options) and ("CEP" not in options)):
+        # add checkPV but only if not CEP and not disabled
+        seq.Members += [ CheckPV("CheckPV_"+name) ]
+    elif multiPV:
+        import sys
+        print("You cannot run MultiPV and not CheckPV")
+        sys.exit()
+
+    """
+        if ("CEP" in options):
+            CheckPV().MinPVs = 0
+            CheckPV().MaxPVs = 0
+    """
+    
+    seq.Members += [ tuple ]
+    return [ seq ]
diff --git a/CEP_Jpsi2ll/DiLeptonTuple/__init__.py b/CEP_Jpsi2ll/DiLeptonTuple/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/CEP_Jpsi2ll/README.md b/CEP_Jpsi2ll/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..040152ec80bbb232ab9475e8ad89daacbf9f712a
--- /dev/null
+++ b/CEP_Jpsi2ll/README.md
@@ -0,0 +1,11 @@
+# CEP $`J/\psi \rightarrow ll`$ ntuple options
+
+Includes the option files for creating ntuples for the CEP $`J/\psi \rightarrow ll, \ l=e,\mu`$ analysis.
+
+## Datasets
+The LOWMULT stream is used to make ntuples for 2016, 2017 and 2018 data. Reconstructed are:
+
+- Dimuon mass spectrum from 0 to 8 GeV.
+- Dielectron mass spectrum from 0.1 to 8 GeV.
+- $`\chi_{c_{J}} \rightarrow J/\psi(\rightarrow \mu^{+} \mu^{-}) \gamma`$ (feed-down background)
+- $`\chi_{c_{J}} \rightarrow J/\psi(\rightarrow e^{+} e^{-}) \gamma`$ (feed-down background)
diff --git a/CEP_Jpsi2ll/__init__.py b/CEP_Jpsi2ll/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/CEP_Jpsi2ll/info.yaml b/CEP_Jpsi2ll/info.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..aa2a45d4ee00c608d071e297c5a5b2270cc1e8c8
--- /dev/null
+++ b/CEP_Jpsi2ll/info.yaml
@@ -0,0 +1,75 @@
+defaults:
+    wg: QEE
+    inform:
+        - cristina.sanchez.gras@cern.ch
+
+2016_MagDown_CEP_Jpsi2ll:
+    application: DaVinci/v45r5
+    turbo: no
+    input:
+        bk_query: "/LHCb/Collision16/Beam6500GeV-VeloClosed-MagDown/Real Data/Reco16/Stripping28r2/90000000/LOWMULT.DST"
+    options:
+        - DataTypes/2016.py
+        - DataTypes/real_data.py
+        - DVJpsiCEP_AP.py
+    output: CEP_JPSI2LL_2016.ROOT
+
+
+2016_MagUp_CEP_Jpsi2ll:
+    application: DaVinci/v45r5
+    turbo: no
+    input:
+        bk_query: "/LHCb/Collision16/Beam6500GeV-VeloClosed-MagUp/Real Data/Reco16/Stripping28r2/90000000/LOWMULT.DST"
+    options:
+        - DataTypes/2016.py
+        - DataTypes/real_data.py
+        - DVJpsiCEP_AP.py
+    output: CEP_JPSI2LL_2016.ROOT
+
+
+2017_MagDown_CEP_Jpsi2ll:
+    application: DaVinci/v45r5
+    turbo: no
+    input:
+        bk_query: "/LHCb/Collision17/Beam6500GeV-VeloClosed-MagDown/Real Data/Reco17/90600000/FULL.DST"
+    options:
+        - DataTypes/2017.py
+        - DataTypes/real_data.py
+        - DVJpsiCEP_AP.py
+    output: CEP_JPSI2LL_2017.ROOT
+
+
+2017_MagUp_CEP_Jpsi2ll:
+    application: DaVinci/v45r5
+    turbo: no
+    input:
+        bk_query: "/LHCb/Collision17/Beam6500GeV-VeloClosed-MagUp/Real Data/Reco17/90600000/FULL.DST"
+    options:
+        - DataTypes/2017.py
+        - DataTypes/real_data.py
+        - DVJpsiCEP_AP.py
+    output: CEP_JPSI2LL_2017.ROOT
+
+
+2018_MagDown_CEP_Jpsi2ll:
+    application: DaVinci/v45r5
+    turbo: no
+    input:
+        bk_query: "/LHCb/Collision18/Beam6500GeV-VeloClosed-MagDown/Real Data/Reco18/90600000/FULL.DST"
+    options:
+        - DataTypes/2018.py
+        - DataTypes/real_data.py
+        - DVJpsiCEP_AP.py
+    output: CEP_JPSI2LL_2018.ROOT
+
+
+2018_MagUp_CEP_Jpsi2ll:
+    application: DaVinci/v45r5
+    turbo: no
+    input:
+        bk_query: "/LHCb/Collision18/Beam6500GeV-VeloClosed-MagUp/Real Data/Reco18/90600000/FULL.DST"
+    options:
+        - DataTypes/2018.py
+        - DataTypes/real_data.py
+        - DVJpsiCEP_AP.py
+    output: CEP_JPSI2LL_2018.ROOT