L1RpcTriggerAnalysis/src/rootMAnaDict.cc

//
// File generated by /opt/cms/slc5_amd64_gcc472/lcg/root/5.34.07//bin/rootcint at Wed Jul 10 08:41:52 2013

// Do NOT change. Changes will be lost next time file is generated
//

#define R__DICTIONARY_FILENAME rootMAnaDict
#include "RConfig.h" //rootcint 4834
#if !defined(R__ACCESS_IN_SYMBOL)
//Break the privacy of classes -- Disabled for the moment
#define private public
#define protected public
#endif

// Since CINT ignores the std namespace, we need to do so in this file.
namespace std {} using namespace std;
#include "rootMAnaDict.h"

#include "TCollectionProxyInfo.h"
#include "TClass.h"
#include "TBuffer.h"
#include "TMemberInspector.h"
#include "TError.h"

#ifndef G__ROOT
#define G__ROOT
#endif

#include "RtypesImp.h"
#include "TIsAProxy.h"
#include "TFileMergeInfo.h"

// START OF SHADOWS

namespace ROOT {
   namespace Shadow {
   } // of namespace Shadow
} // of namespace ROOT
// END OF SHADOWS

namespace ROOT {
   void EventObj_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_EventObj(void *p = 0);
   static void *newArray_EventObj(Long_t size, void *p);
   static void delete_EventObj(void *p);
   static void deleteArray_EventObj(void *p);
   static void destruct_EventObj(void *p);
   static void streamer_EventObj(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::EventObj*)
   {
      ::EventObj *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::EventObj >(0);
      static ::ROOT::TGenericClassInfo 
         instance("EventObj", ::EventObj::Class_Version(), "../../../UserCode/L1RpcTriggerAnalysis/interface/EventObj.h", 6,
                  typeid(::EventObj), DefineBehavior(ptr, ptr),
                  &::EventObj::Dictionary, isa_proxy, 0,
                  sizeof(::EventObj) );
      instance.SetNew(&new_EventObj);
      instance.SetNewArray(&newArray_EventObj);
      instance.SetDelete(&delete_EventObj);
      instance.SetDeleteArray(&deleteArray_EventObj);
      instance.SetDestructor(&destruct_EventObj);
      instance.SetStreamerFunc(&streamer_EventObj);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::EventObj*)
   {
      return GenerateInitInstanceLocal((::EventObj*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::EventObj*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void L1Obj_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_L1Obj(void *p = 0);
   static void *newArray_L1Obj(Long_t size, void *p);
   static void delete_L1Obj(void *p);
   static void deleteArray_L1Obj(void *p);
   static void destruct_L1Obj(void *p);
   static void streamer_L1Obj(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::L1Obj*)
   {
      ::L1Obj *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::L1Obj >(0);
      static ::ROOT::TGenericClassInfo 
         instance("L1Obj", ::L1Obj::Class_Version(), "../../../UserCode/L1RpcTriggerAnalysis/interface/L1Obj.h", 6,
                  typeid(::L1Obj), DefineBehavior(ptr, ptr),
                  &::L1Obj::Dictionary, isa_proxy, 0,
                  sizeof(::L1Obj) );
      instance.SetNew(&new_L1Obj);
      instance.SetNewArray(&newArray_L1Obj);
      instance.SetDelete(&delete_L1Obj);
      instance.SetDeleteArray(&deleteArray_L1Obj);
      instance.SetDestructor(&destruct_L1Obj);
      instance.SetStreamerFunc(&streamer_L1Obj);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::L1Obj*)
   {
      return GenerateInitInstanceLocal((::L1Obj*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::L1Obj*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void EventData_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_EventData(void *p = 0);
   static void *newArray_EventData(Long_t size, void *p);
   static void delete_EventData(void *p);
   static void deleteArray_EventData(void *p);
   static void destruct_EventData(void *p);
   static void streamer_EventData(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::EventData*)
   {
      ::EventData *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::EventData >(0);
      static ::ROOT::TGenericClassInfo 
         instance("EventData", ::EventData::Class_Version(), "../../../UserCode/L1RpcTriggerAnalysis/interface/EventData.h", 11,
                  typeid(::EventData), DefineBehavior(ptr, ptr),
                  &::EventData::Dictionary, isa_proxy, 0,
                  sizeof(::EventData) );
      instance.SetNew(&new_EventData);
      instance.SetNewArray(&newArray_EventData);
      instance.SetDelete(&delete_EventData);
      instance.SetDeleteArray(&deleteArray_EventData);
      instance.SetDestructor(&destruct_EventData);
      instance.SetStreamerFunc(&streamer_EventData);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::EventData*)
   {
      return GenerateInitInstanceLocal((::EventData*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::EventData*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TrackObj_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TrackObj(void *p = 0);
   static void *newArray_TrackObj(Long_t size, void *p);
   static void delete_TrackObj(void *p);
   static void deleteArray_TrackObj(void *p);
   static void destruct_TrackObj(void *p);
   static void streamer_TrackObj(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TrackObj*)
   {
      ::TrackObj *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TrackObj >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TrackObj", ::TrackObj::Class_Version(), "../../../UserCode/L1RpcTriggerAnalysis/interface/TrackObj.h", 6,
                  typeid(::TrackObj), DefineBehavior(ptr, ptr),
                  &::TrackObj::Dictionary, isa_proxy, 0,
                  sizeof(::TrackObj) );
      instance.SetNew(&new_TrackObj);
      instance.SetNewArray(&newArray_TrackObj);
      instance.SetDelete(&delete_TrackObj);
      instance.SetDeleteArray(&deleteArray_TrackObj);
      instance.SetDestructor(&destruct_TrackObj);
      instance.SetStreamerFunc(&streamer_TrackObj);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TrackObj*)
   {
      return GenerateInitInstanceLocal((::TrackObj*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TrackObj*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void MuonObj_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_MuonObj(void *p = 0);
   static void *newArray_MuonObj(Long_t size, void *p);
   static void delete_MuonObj(void *p);
   static void deleteArray_MuonObj(void *p);
   static void destruct_MuonObj(void *p);
   static void streamer_MuonObj(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::MuonObj*)
   {
      ::MuonObj *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::MuonObj >(0);
      static ::ROOT::TGenericClassInfo 
         instance("MuonObj", ::MuonObj::Class_Version(), "../../../UserCode/L1RpcTriggerAnalysis/interface/MuonObj.h", 6,
                  typeid(::MuonObj), DefineBehavior(ptr, ptr),
                  &::MuonObj::Dictionary, isa_proxy, 0,
                  sizeof(::MuonObj) );
      instance.SetNew(&new_MuonObj);
      instance.SetNewArray(&newArray_MuonObj);
      instance.SetDelete(&delete_MuonObj);
      instance.SetDeleteArray(&deleteArray_MuonObj);
      instance.SetDestructor(&destruct_MuonObj);
      instance.SetStreamerFunc(&streamer_MuonObj);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::MuonObj*)
   {
      return GenerateInitInstanceLocal((::MuonObj*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::MuonObj*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void L1ObjColl_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_L1ObjColl(void *p = 0);
   static void *newArray_L1ObjColl(Long_t size, void *p);
   static void delete_L1ObjColl(void *p);
   static void deleteArray_L1ObjColl(void *p);
   static void destruct_L1ObjColl(void *p);
   static void streamer_L1ObjColl(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::L1ObjColl*)
   {
      ::L1ObjColl *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::L1ObjColl >(0);
      static ::ROOT::TGenericClassInfo 
         instance("L1ObjColl", ::L1ObjColl::Class_Version(), "../../../UserCode/L1RpcTriggerAnalysis/interface/L1ObjColl.h", 9,
                  typeid(::L1ObjColl), DefineBehavior(ptr, ptr),
                  &::L1ObjColl::Dictionary, isa_proxy, 0,
                  sizeof(::L1ObjColl) );
      instance.SetNew(&new_L1ObjColl);
      instance.SetNewArray(&newArray_L1ObjColl);
      instance.SetDelete(&delete_L1ObjColl);
      instance.SetDeleteArray(&deleteArray_L1ObjColl);
      instance.SetDestructor(&destruct_L1ObjColl);
      instance.SetStreamerFunc(&streamer_L1ObjColl);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::L1ObjColl*)
   {
      return GenerateInitInstanceLocal((::L1ObjColl*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::L1ObjColl*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void SynchroCountsObj_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_SynchroCountsObj(void *p = 0);
   static void *newArray_SynchroCountsObj(Long_t size, void *p);
   static void delete_SynchroCountsObj(void *p);
   static void deleteArray_SynchroCountsObj(void *p);
   static void destruct_SynchroCountsObj(void *p);
   static void streamer_SynchroCountsObj(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::SynchroCountsObj*)
   {
      ::SynchroCountsObj *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::SynchroCountsObj >(0);
      static ::ROOT::TGenericClassInfo 
         instance("SynchroCountsObj", ::SynchroCountsObj::Class_Version(), "../../../UserCode/L1RpcTriggerAnalysis/interface/SynchroCountsObj.h", 6,
                  typeid(::SynchroCountsObj), DefineBehavior(ptr, ptr),
                  &::SynchroCountsObj::Dictionary, isa_proxy, 0,
                  sizeof(::SynchroCountsObj) );
      instance.SetNew(&new_SynchroCountsObj);
      instance.SetNewArray(&newArray_SynchroCountsObj);
      instance.SetDelete(&delete_SynchroCountsObj);
      instance.SetDeleteArray(&deleteArray_SynchroCountsObj);
      instance.SetDestructor(&destruct_SynchroCountsObj);
      instance.SetStreamerFunc(&streamer_SynchroCountsObj);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::SynchroCountsObj*)
   {
      return GenerateInitInstanceLocal((::SynchroCountsObj*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::SynchroCountsObj*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void SynchroCountsObjVect_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_SynchroCountsObjVect(void *p = 0);
   static void *newArray_SynchroCountsObjVect(Long_t size, void *p);
   static void delete_SynchroCountsObjVect(void *p);
   static void deleteArray_SynchroCountsObjVect(void *p);
   static void destruct_SynchroCountsObjVect(void *p);
   static void streamer_SynchroCountsObjVect(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::SynchroCountsObjVect*)
   {
      ::SynchroCountsObjVect *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::SynchroCountsObjVect >(0);
      static ::ROOT::TGenericClassInfo 
         instance("SynchroCountsObjVect", ::SynchroCountsObjVect::Class_Version(), "../../../UserCode/L1RpcTriggerAnalysis/interface/SynchroCountsObjVect.h", 9,
                  typeid(::SynchroCountsObjVect), DefineBehavior(ptr, ptr),
                  &::SynchroCountsObjVect::Dictionary, isa_proxy, 0,
                  sizeof(::SynchroCountsObjVect) );
      instance.SetNew(&new_SynchroCountsObjVect);
      instance.SetNewArray(&newArray_SynchroCountsObjVect);
      instance.SetDelete(&delete_SynchroCountsObjVect);
      instance.SetDeleteArray(&deleteArray_SynchroCountsObjVect);
      instance.SetDestructor(&destruct_SynchroCountsObjVect);
      instance.SetStreamerFunc(&streamer_SynchroCountsObjVect);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::SynchroCountsObjVect*)
   {
      return GenerateInitInstanceLocal((::SynchroCountsObjVect*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::SynchroCountsObjVect*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void DetCluDigiObj_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_DetCluDigiObj(void *p = 0);
   static void *newArray_DetCluDigiObj(Long_t size, void *p);
   static void delete_DetCluDigiObj(void *p);
   static void deleteArray_DetCluDigiObj(void *p);
   static void destruct_DetCluDigiObj(void *p);
   static void streamer_DetCluDigiObj(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::DetCluDigiObj*)
   {
      ::DetCluDigiObj *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::DetCluDigiObj >(0);
      static ::ROOT::TGenericClassInfo 
         instance("DetCluDigiObj", ::DetCluDigiObj::Class_Version(), "../../../UserCode/L1RpcTriggerAnalysis/interface/DetCluDigiObj.h", 6,
                  typeid(::DetCluDigiObj), DefineBehavior(ptr, ptr),
                  &::DetCluDigiObj::Dictionary, isa_proxy, 0,
                  sizeof(::DetCluDigiObj) );
      instance.SetNew(&new_DetCluDigiObj);
      instance.SetNewArray(&newArray_DetCluDigiObj);
      instance.SetDelete(&delete_DetCluDigiObj);
      instance.SetDeleteArray(&deleteArray_DetCluDigiObj);
      instance.SetDestructor(&destruct_DetCluDigiObj);
      instance.SetStreamerFunc(&streamer_DetCluDigiObj);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::DetCluDigiObj*)
   {
      return GenerateInitInstanceLocal((::DetCluDigiObj*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::DetCluDigiObj*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void DetCluDigiObjVect_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_DetCluDigiObjVect(void *p = 0);
   static void *newArray_DetCluDigiObjVect(Long_t size, void *p);
   static void delete_DetCluDigiObjVect(void *p);
   static void deleteArray_DetCluDigiObjVect(void *p);
   static void destruct_DetCluDigiObjVect(void *p);
   static void streamer_DetCluDigiObjVect(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::DetCluDigiObjVect*)
   {
      ::DetCluDigiObjVect *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::DetCluDigiObjVect >(0);
      static ::ROOT::TGenericClassInfo 
         instance("DetCluDigiObjVect", ::DetCluDigiObjVect::Class_Version(), "../../../UserCode/L1RpcTriggerAnalysis/interface/DetCluDigiObjVect.h", 9,
                  typeid(::DetCluDigiObjVect), DefineBehavior(ptr, ptr),
                  &::DetCluDigiObjVect::Dictionary, isa_proxy, 0,
                  sizeof(::DetCluDigiObjVect) );
      instance.SetNew(&new_DetCluDigiObjVect);
      instance.SetNewArray(&newArray_DetCluDigiObjVect);
      instance.SetDelete(&delete_DetCluDigiObjVect);
      instance.SetDeleteArray(&deleteArray_DetCluDigiObjVect);
      instance.SetDestructor(&destruct_DetCluDigiObjVect);
      instance.SetStreamerFunc(&streamer_DetCluDigiObjVect);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::DetCluDigiObjVect*)
   {
      return GenerateInitInstanceLocal((::DetCluDigiObjVect*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::DetCluDigiObjVect*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TriggerMenuResultObj_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TriggerMenuResultObj(void *p = 0);
   static void *newArray_TriggerMenuResultObj(Long_t size, void *p);
   static void delete_TriggerMenuResultObj(void *p);
   static void deleteArray_TriggerMenuResultObj(void *p);
   static void destruct_TriggerMenuResultObj(void *p);
   static void streamer_TriggerMenuResultObj(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TriggerMenuResultObj*)
   {
      ::TriggerMenuResultObj *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TriggerMenuResultObj >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TriggerMenuResultObj", ::TriggerMenuResultObj::Class_Version(), "../../../UserCode/L1RpcTriggerAnalysis/interface/TriggerMenuResultObj.h", 8,
                  typeid(::TriggerMenuResultObj), DefineBehavior(ptr, ptr),
                  &::TriggerMenuResultObj::Dictionary, isa_proxy, 0,
                  sizeof(::TriggerMenuResultObj) );
      instance.SetNew(&new_TriggerMenuResultObj);
      instance.SetNewArray(&newArray_TriggerMenuResultObj);
      instance.SetDelete(&delete_TriggerMenuResultObj);
      instance.SetDeleteArray(&deleteArray_TriggerMenuResultObj);
      instance.SetDestructor(&destruct_TriggerMenuResultObj);
      instance.SetStreamerFunc(&streamer_TriggerMenuResultObj);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TriggerMenuResultObj*)
   {
      return GenerateInitInstanceLocal((::TriggerMenuResultObj*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TriggerMenuResultObj*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void HitSpecObj_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_HitSpecObj(void *p = 0);
   static void *newArray_HitSpecObj(Long_t size, void *p);
   static void delete_HitSpecObj(void *p);
   static void deleteArray_HitSpecObj(void *p);
   static void destruct_HitSpecObj(void *p);
   static void streamer_HitSpecObj(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::HitSpecObj*)
   {
      ::HitSpecObj *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::HitSpecObj >(0);
      static ::ROOT::TGenericClassInfo 
         instance("HitSpecObj", ::HitSpecObj::Class_Version(), "../../../UserCode/L1RpcTriggerAnalysis/interface/HitSpecObj.h", 8,
                  typeid(::HitSpecObj), DefineBehavior(ptr, ptr),
                  &::HitSpecObj::Dictionary, isa_proxy, 0,
                  sizeof(::HitSpecObj) );
      instance.SetNew(&new_HitSpecObj);
      instance.SetNewArray(&newArray_HitSpecObj);
      instance.SetDelete(&delete_HitSpecObj);
      instance.SetDeleteArray(&deleteArray_HitSpecObj);
      instance.SetDestructor(&destruct_HitSpecObj);
      instance.SetStreamerFunc(&streamer_HitSpecObj);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::HitSpecObj*)
   {
      return GenerateInitInstanceLocal((::HitSpecObj*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::HitSpecObj*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

//______________________________________________________________________________
TClass *EventObj::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *EventObj::Class_Name()
{
   return "EventObj";
}

//______________________________________________________________________________
const char *EventObj::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::EventObj*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int EventObj::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::EventObj*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void EventObj::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::EventObj*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *EventObj::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::EventObj*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *L1Obj::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *L1Obj::Class_Name()
{
   return "L1Obj";
}

//______________________________________________________________________________
const char *L1Obj::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::L1Obj*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int L1Obj::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::L1Obj*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void L1Obj::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::L1Obj*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *L1Obj::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::L1Obj*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *EventData::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *EventData::Class_Name()
{
   return "EventData";
}

//______________________________________________________________________________
const char *EventData::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::EventData*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int EventData::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::EventData*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void EventData::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::EventData*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *EventData::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::EventData*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TrackObj::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TrackObj::Class_Name()
{
   return "TrackObj";
}

//______________________________________________________________________________
const char *TrackObj::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TrackObj*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TrackObj::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TrackObj*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TrackObj::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TrackObj*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TrackObj::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TrackObj*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *MuonObj::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *MuonObj::Class_Name()
{
   return "MuonObj";
}

//______________________________________________________________________________
const char *MuonObj::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::MuonObj*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int MuonObj::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::MuonObj*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void MuonObj::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MuonObj*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *MuonObj::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MuonObj*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *L1ObjColl::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *L1ObjColl::Class_Name()
{
   return "L1ObjColl";
}

//______________________________________________________________________________
const char *L1ObjColl::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::L1ObjColl*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int L1ObjColl::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::L1ObjColl*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void L1ObjColl::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::L1ObjColl*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *L1ObjColl::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::L1ObjColl*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *SynchroCountsObj::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *SynchroCountsObj::Class_Name()
{
   return "SynchroCountsObj";
}

//______________________________________________________________________________
const char *SynchroCountsObj::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::SynchroCountsObj*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int SynchroCountsObj::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::SynchroCountsObj*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void SynchroCountsObj::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::SynchroCountsObj*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *SynchroCountsObj::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::SynchroCountsObj*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *SynchroCountsObjVect::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *SynchroCountsObjVect::Class_Name()
{
   return "SynchroCountsObjVect";
}

//______________________________________________________________________________
const char *SynchroCountsObjVect::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::SynchroCountsObjVect*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int SynchroCountsObjVect::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::SynchroCountsObjVect*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void SynchroCountsObjVect::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::SynchroCountsObjVect*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *SynchroCountsObjVect::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::SynchroCountsObjVect*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *DetCluDigiObj::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *DetCluDigiObj::Class_Name()
{
   return "DetCluDigiObj";
}

//______________________________________________________________________________
const char *DetCluDigiObj::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::DetCluDigiObj*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int DetCluDigiObj::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::DetCluDigiObj*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void DetCluDigiObj::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::DetCluDigiObj*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *DetCluDigiObj::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::DetCluDigiObj*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *DetCluDigiObjVect::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *DetCluDigiObjVect::Class_Name()
{
   return "DetCluDigiObjVect";
}

//______________________________________________________________________________
const char *DetCluDigiObjVect::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::DetCluDigiObjVect*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int DetCluDigiObjVect::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::DetCluDigiObjVect*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void DetCluDigiObjVect::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::DetCluDigiObjVect*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *DetCluDigiObjVect::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::DetCluDigiObjVect*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TriggerMenuResultObj::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TriggerMenuResultObj::Class_Name()
{
   return "TriggerMenuResultObj";
}

//______________________________________________________________________________
const char *TriggerMenuResultObj::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TriggerMenuResultObj*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TriggerMenuResultObj::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TriggerMenuResultObj*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TriggerMenuResultObj::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TriggerMenuResultObj*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TriggerMenuResultObj::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TriggerMenuResultObj*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *HitSpecObj::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *HitSpecObj::Class_Name()
{
   return "HitSpecObj";
}

//______________________________________________________________________________
const char *HitSpecObj::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::HitSpecObj*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int HitSpecObj::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::HitSpecObj*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void HitSpecObj::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::HitSpecObj*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *HitSpecObj::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::HitSpecObj*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
void EventObj::Streamer(TBuffer &R__b)
{
   // Stream an object of class EventObj.

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TObject::Streamer(R__b);
      R__b >> bx;
      R__b >> id;
      R__b >> lumi;
      R__b >> run;
      R__b >> time;
      R__b >> orbit;
      R__b.CheckByteCount(R__s, R__c, EventObj::IsA());
   } else {
      R__c = R__b.WriteVersion(EventObj::IsA(), kTRUE);
      TObject::Streamer(R__b);
      R__b << bx;
      R__b << id;
      R__b << lumi;
      R__b << run;
      R__b << time;
      R__b << orbit;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void EventObj::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class EventObj.
      TClass *R__cl = ::EventObj::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "bx", &bx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "id", &id);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "lumi", &lumi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "run", &run);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "time", &time);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "orbit", &orbit);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_EventObj(void *p) {
      return  p ? new(p) ::EventObj : new ::EventObj;
   }
   static void *newArray_EventObj(Long_t nElements, void *p) {
      return p ? new(p) ::EventObj[nElements] : new ::EventObj[nElements];
   }
   // Wrapper around operator delete
   static void delete_EventObj(void *p) {
      delete ((::EventObj*)p);
   }
   static void deleteArray_EventObj(void *p) {
      delete [] ((::EventObj*)p);
   }
   static void destruct_EventObj(void *p) {
      typedef ::EventObj current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_EventObj(TBuffer &buf, void *obj) {
      ((::EventObj*)obj)->::EventObj::Streamer(buf);
   }
} // end of namespace ROOT for class ::EventObj

//______________________________________________________________________________
void EventData::Streamer(TBuffer &R__b)
{
   // Stream an object of class EventData.

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TObject::Streamer(R__b);
      R__b >> weight;
      R__b >> pt;
      R__b >> eta;
      R__b >> phi;
      R__b >> phiHit;
      R__b >> etaHit;
      R__b >> charge;
      {
         vector<L1Obj> &R__stl =  l1ObjectsOtf;
         R__stl.clear();
         int R__i, R__n;
         R__b >> R__n;
         R__stl.reserve(R__n);
         for (R__i = 0; R__i < R__n; R__i++) {
            L1Obj R__t;
            R__t.Streamer(R__b);
            R__stl.push_back(R__t);
         }
      }
      {
         vector<L1Obj> &R__stl =  l1ObjectsGmt;
         R__stl.clear();
         int R__i, R__n;
         R__b >> R__n;
         R__stl.reserve(R__n);
         for (R__i = 0; R__i < R__n; R__i++) {
            L1Obj R__t;
            R__t.Streamer(R__b);
            R__stl.push_back(R__t);
         }
      }
      R__b.CheckByteCount(R__s, R__c, EventData::IsA());
   } else {
      R__c = R__b.WriteVersion(EventData::IsA(), kTRUE);
      TObject::Streamer(R__b);
      R__b << weight;
      R__b << pt;
      R__b << eta;
      R__b << phi;
      R__b << phiHit;
      R__b << etaHit;
      R__b << charge;
      {
         vector<L1Obj> &R__stl =  l1ObjectsOtf;
         int R__n=(&R__stl) ? int(R__stl.size()) : 0;
         R__b << R__n;
         if(R__n) {
            vector<L1Obj>::iterator R__k;
            for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
            ((L1Obj&)(*R__k)).Streamer(R__b);
            }
         }
      }
      {
         vector<L1Obj> &R__stl =  l1ObjectsGmt;
         int R__n=(&R__stl) ? int(R__stl.size()) : 0;
         R__b << R__n;
         if(R__n) {
            vector<L1Obj>::iterator R__k;
            for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
            ((L1Obj&)(*R__k)).Streamer(R__b);
            }
         }
      }
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void EventData::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class EventData.
      TClass *R__cl = ::EventData::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "weight", &weight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "pt", &pt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "eta", &eta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "phi", &phi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "phiHit", &phiHit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "etaHit", &etaHit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "charge", &charge);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "l1ObjectsOtf", (void*)&l1ObjectsOtf);
      R__insp.InspectMember("vector<L1Obj>", (void*)&l1ObjectsOtf, "l1ObjectsOtf.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "l1ObjectsGmt", (void*)&l1ObjectsGmt);
      R__insp.InspectMember("vector<L1Obj>", (void*)&l1ObjectsGmt, "l1ObjectsGmt.", false);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_EventData(void *p) {
      return  p ? new(p) ::EventData : new ::EventData;
   }
   static void *newArray_EventData(Long_t nElements, void *p) {
      return p ? new(p) ::EventData[nElements] : new ::EventData[nElements];
   }
   // Wrapper around operator delete
   static void delete_EventData(void *p) {
      delete ((::EventData*)p);
   }
   static void deleteArray_EventData(void *p) {
      delete [] ((::EventData*)p);
   }
   static void destruct_EventData(void *p) {
      typedef ::EventData current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_EventData(TBuffer &buf, void *obj) {
      ((::EventData*)obj)->::EventData::Streamer(buf);
   }
} // end of namespace ROOT for class ::EventData

//______________________________________________________________________________
void TrackObj::Streamer(TBuffer &R__b)
{
   // Stream an object of class TrackObj.

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TObject::Streamer(R__b);
      R__b >> thePt;
      R__b >> theEta;
      R__b >> thePhi;
      R__b >> theCharge;
      R__b.CheckByteCount(R__s, R__c, TrackObj::IsA());
   } else {
      R__c = R__b.WriteVersion(TrackObj::IsA(), kTRUE);
      TObject::Streamer(R__b);
      R__b << thePt;
      R__b << theEta;
      R__b << thePhi;
      R__b << theCharge;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void TrackObj::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TrackObj.
      TClass *R__cl = ::TrackObj::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "thePt", &thePt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "theEta", &theEta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "thePhi", &thePhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "theCharge", &theCharge);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TrackObj(void *p) {
      return  p ? new(p) ::TrackObj : new ::TrackObj;
   }
   static void *newArray_TrackObj(Long_t nElements, void *p) {
      return p ? new(p) ::TrackObj[nElements] : new ::TrackObj[nElements];
   }
   // Wrapper around operator delete
   static void delete_TrackObj(void *p) {
      delete ((::TrackObj*)p);
   }
   static void deleteArray_TrackObj(void *p) {
      delete [] ((::TrackObj*)p);
   }
   static void destruct_TrackObj(void *p) {
      typedef ::TrackObj current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TrackObj(TBuffer &buf, void *obj) {
      ((::TrackObj*)obj)->::TrackObj::Streamer(buf);
   }
} // end of namespace ROOT for class ::TrackObj

//______________________________________________________________________________
void MuonObj::Streamer(TBuffer &R__b)
{
   // Stream an object of class MuonObj.

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TrackObj::Streamer(R__b);
      R__b >> nRPCHits;
      R__b >> nDTHits;
      R__b >> nCSCHits;
      R__b >> nTrackerHits;
      R__b >> nMatchedStations;
      R__b >> isUnique;
      R__b >> nAllMuons;
      R__b >> theMuonBits;
      R__b.CheckByteCount(R__s, R__c, MuonObj::IsA());
   } else {
      R__c = R__b.WriteVersion(MuonObj::IsA(), kTRUE);
      TrackObj::Streamer(R__b);
      R__b << nRPCHits;
      R__b << nDTHits;
      R__b << nCSCHits;
      R__b << nTrackerHits;
      R__b << nMatchedStations;
      R__b << isUnique;
      R__b << nAllMuons;
      R__b << theMuonBits;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void MuonObj::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class MuonObj.
      TClass *R__cl = ::MuonObj::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "nRPCHits", &nRPCHits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "nDTHits", &nDTHits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "nCSCHits", &nCSCHits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "nTrackerHits", &nTrackerHits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "nMatchedStations", &nMatchedStations);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "isUnique", &isUnique);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "nAllMuons", &nAllMuons);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "theMuonBits", &theMuonBits);
      TrackObj::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_MuonObj(void *p) {
      return  p ? new(p) ::MuonObj : new ::MuonObj;
   }
   static void *newArray_MuonObj(Long_t nElements, void *p) {
      return p ? new(p) ::MuonObj[nElements] : new ::MuonObj[nElements];
   }
   // Wrapper around operator delete
   static void delete_MuonObj(void *p) {
      delete ((::MuonObj*)p);
   }
   static void deleteArray_MuonObj(void *p) {
      delete [] ((::MuonObj*)p);
   }
   static void destruct_MuonObj(void *p) {
      typedef ::MuonObj current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_MuonObj(TBuffer &buf, void *obj) {
      ((::MuonObj*)obj)->::MuonObj::Streamer(buf);
   }
} // end of namespace ROOT for class ::MuonObj

//______________________________________________________________________________
void L1Obj::Streamer(TBuffer &R__b)
{
   // Stream an object of class L1Obj.

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TObject::Streamer(R__b);
      R__b >> pt;
      R__b >> eta;
      R__b >> phi;
      R__b >> bx;
      R__b >> q;
      R__b >> charge;
      void *ptr_type = (void*)&type;
      R__b >> *reinterpret_cast<Int_t*>(ptr_type);
      R__b.CheckByteCount(R__s, R__c, L1Obj::IsA());
   } else {
      R__c = R__b.WriteVersion(L1Obj::IsA(), kTRUE);
      TObject::Streamer(R__b);
      R__b << pt;
      R__b << eta;
      R__b << phi;
      R__b << bx;
      R__b << q;
      R__b << charge;
      R__b << (Int_t)type;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void L1Obj::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class L1Obj.
      TClass *R__cl = ::L1Obj::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "pt", &pt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "eta", &eta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "phi", &phi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "bx", &bx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "q", &q);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "charge", &charge);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "type", &type);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_L1Obj(void *p) {
      return  p ? new(p) ::L1Obj : new ::L1Obj;
   }
   static void *newArray_L1Obj(Long_t nElements, void *p) {
      return p ? new(p) ::L1Obj[nElements] : new ::L1Obj[nElements];
   }
   // Wrapper around operator delete
   static void delete_L1Obj(void *p) {
      delete ((::L1Obj*)p);
   }
   static void deleteArray_L1Obj(void *p) {
      delete [] ((::L1Obj*)p);
   }
   static void destruct_L1Obj(void *p) {
      typedef ::L1Obj current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_L1Obj(TBuffer &buf, void *obj) {
      ((::L1Obj*)obj)->::L1Obj::Streamer(buf);
   }
} // end of namespace ROOT for class ::L1Obj

//______________________________________________________________________________
void L1ObjColl::Streamer(TBuffer &R__b)
{
   // Stream an object of class L1ObjColl.

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TObject::Streamer(R__b);
      {
         vector<L1Obj> &R__stl =  theL1Obj;
         R__stl.clear();
         int R__i, R__n;
         R__b >> R__n;
         R__stl.reserve(R__n);
         for (R__i = 0; R__i < R__n; R__i++) {
            L1Obj R__t;
            R__t.Streamer(R__b);
            R__stl.push_back(R__t);
         }
      }
      {
         vector<bool> &R__stl =  theL1Matching;
         R__stl.clear();
         int R__i, R__n;
         R__b >> R__n;
         R__stl.reserve(R__n);
         for (R__i = 0; R__i < R__n; R__i++) {
            bool R__t;
            R__b >> R__t;
            R__stl.push_back(R__t);
         }
      }
      {
         vector<double> &R__stl =  theDeltaR;
         R__stl.clear();
         int R__i, R__n;
         R__b >> R__n;
         R__stl.reserve(R__n);
         for (R__i = 0; R__i < R__n; R__i++) {
            double R__t;
            R__b >> R__t;
            R__stl.push_back(R__t);
         }
      }
      R__b.CheckByteCount(R__s, R__c, L1ObjColl::IsA());
   } else {
      R__c = R__b.WriteVersion(L1ObjColl::IsA(), kTRUE);
      TObject::Streamer(R__b);
      {
         vector<L1Obj> &R__stl =  theL1Obj;
         int R__n=(&R__stl) ? int(R__stl.size()) : 0;
         R__b << R__n;
         if(R__n) {
            vector<L1Obj>::iterator R__k;
            for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
            ((L1Obj&)(*R__k)).Streamer(R__b);
            }
         }
      }
      {
         vector<bool> &R__stl =  theL1Matching;
         int R__n=(&R__stl) ? int(R__stl.size()) : 0;
         R__b << R__n;
         if(R__n) {
            vector<bool>::iterator R__k;
            for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
            R__b << (*R__k);
            }
         }
      }
      {
         vector<double> &R__stl =  theDeltaR;
         int R__n=(&R__stl) ? int(R__stl.size()) : 0;
         R__b << R__n;
         if(R__n) {
            vector<double>::iterator R__k;
            for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
            R__b << (*R__k);
            }
         }
      }
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void L1ObjColl::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class L1ObjColl.
      TClass *R__cl = ::L1ObjColl::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "theL1Obj", (void*)&theL1Obj);
      R__insp.InspectMember("vector<L1Obj>", (void*)&theL1Obj, "theL1Obj.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "theL1Matching", (void*)&theL1Matching);
      R__insp.InspectMember("vector<bool>", (void*)&theL1Matching, "theL1Matching.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "theDeltaR", (void*)&theDeltaR);
      R__insp.InspectMember("vector<double>", (void*)&theDeltaR, "theDeltaR.", false);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_L1ObjColl(void *p) {
      return  p ? new(p) ::L1ObjColl : new ::L1ObjColl;
   }
   static void *newArray_L1ObjColl(Long_t nElements, void *p) {
      return p ? new(p) ::L1ObjColl[nElements] : new ::L1ObjColl[nElements];
   }
   // Wrapper around operator delete
   static void delete_L1ObjColl(void *p) {
      delete ((::L1ObjColl*)p);
   }
   static void deleteArray_L1ObjColl(void *p) {
      delete [] ((::L1ObjColl*)p);
   }
   static void destruct_L1ObjColl(void *p) {
      typedef ::L1ObjColl current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_L1ObjColl(TBuffer &buf, void *obj) {
      ((::L1ObjColl*)obj)->::L1ObjColl::Streamer(buf);
   }
} // end of namespace ROOT for class ::L1ObjColl

//______________________________________________________________________________
void SynchroCountsObj::Streamer(TBuffer &R__b)
{
   // Stream an object of class SynchroCountsObj.

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TObject::Streamer(R__b);
      R__b >> dccId;
      R__b >> dccInputChannelNum;
      R__b >> tbLinkInputNum;
      R__b >> lbNumInLink;
      R__b >> bx;
      R__b.CheckByteCount(R__s, R__c, SynchroCountsObj::IsA());
   } else {
      R__c = R__b.WriteVersion(SynchroCountsObj::IsA(), kTRUE);
      TObject::Streamer(R__b);
      R__b << dccId;
      R__b << dccInputChannelNum;
      R__b << tbLinkInputNum;
      R__b << lbNumInLink;
      R__b << bx;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void SynchroCountsObj::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class SynchroCountsObj.
      TClass *R__cl = ::SynchroCountsObj::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "dccId", &dccId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "dccInputChannelNum", &dccInputChannelNum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "tbLinkInputNum", &tbLinkInputNum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "lbNumInLink", &lbNumInLink);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "bx", &bx);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_SynchroCountsObj(void *p) {
      return  p ? new(p) ::SynchroCountsObj : new ::SynchroCountsObj;
   }
   static void *newArray_SynchroCountsObj(Long_t nElements, void *p) {
      return p ? new(p) ::SynchroCountsObj[nElements] : new ::SynchroCountsObj[nElements];
   }
   // Wrapper around operator delete
   static void delete_SynchroCountsObj(void *p) {
      delete ((::SynchroCountsObj*)p);
   }
   static void deleteArray_SynchroCountsObj(void *p) {
      delete [] ((::SynchroCountsObj*)p);
   }
   static void destruct_SynchroCountsObj(void *p) {
      typedef ::SynchroCountsObj current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_SynchroCountsObj(TBuffer &buf, void *obj) {
      ((::SynchroCountsObj*)obj)->::SynchroCountsObj::Streamer(buf);
   }
} // end of namespace ROOT for class ::SynchroCountsObj

//______________________________________________________________________________
void SynchroCountsObjVect::Streamer(TBuffer &R__b)
{
   // Stream an object of class SynchroCountsObjVect.

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TObject::Streamer(R__b);
      {
         vector<SynchroCountsObj> &R__stl =  data;
         R__stl.clear();
         int R__i, R__n;
         R__b >> R__n;
         R__stl.reserve(R__n);
         for (R__i = 0; R__i < R__n; R__i++) {
            SynchroCountsObj R__t;
            R__t.Streamer(R__b);
            R__stl.push_back(R__t);
         }
      }
      R__b.CheckByteCount(R__s, R__c, SynchroCountsObjVect::IsA());
   } else {
      R__c = R__b.WriteVersion(SynchroCountsObjVect::IsA(), kTRUE);
      TObject::Streamer(R__b);
      {
         vector<SynchroCountsObj> &R__stl =  data;
         int R__n=(&R__stl) ? int(R__stl.size()) : 0;
         R__b << R__n;
         if(R__n) {
            vector<SynchroCountsObj>::iterator R__k;
            for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
            ((SynchroCountsObj&)(*R__k)).Streamer(R__b);
            }
         }
      }
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void SynchroCountsObjVect::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class SynchroCountsObjVect.
      TClass *R__cl = ::SynchroCountsObjVect::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "data", (void*)&data);
      R__insp.InspectMember("vector<SynchroCountsObj>", (void*)&data, "data.", false);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_SynchroCountsObjVect(void *p) {
      return  p ? new(p) ::SynchroCountsObjVect : new ::SynchroCountsObjVect;
   }
   static void *newArray_SynchroCountsObjVect(Long_t nElements, void *p) {
      return p ? new(p) ::SynchroCountsObjVect[nElements] : new ::SynchroCountsObjVect[nElements];
   }
   // Wrapper around operator delete
   static void delete_SynchroCountsObjVect(void *p) {
      delete ((::SynchroCountsObjVect*)p);
   }
   static void deleteArray_SynchroCountsObjVect(void *p) {
      delete [] ((::SynchroCountsObjVect*)p);
   }
   static void destruct_SynchroCountsObjVect(void *p) {
      typedef ::SynchroCountsObjVect current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_SynchroCountsObjVect(TBuffer &buf, void *obj) {
      ((::SynchroCountsObjVect*)obj)->::SynchroCountsObjVect::Streamer(buf);
   }
} // end of namespace ROOT for class ::SynchroCountsObjVect

//______________________________________________________________________________
void DetCluDigiObj::Streamer(TBuffer &R__b)
{
   // Stream an object of class DetCluDigiObj.

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TObject::Streamer(R__b);
      R__b >> det;
      R__b >> clusterSize;
      R__b >> nDigis;
      R__b.CheckByteCount(R__s, R__c, DetCluDigiObj::IsA());
   } else {
      R__c = R__b.WriteVersion(DetCluDigiObj::IsA(), kTRUE);
      TObject::Streamer(R__b);
      R__b << det;
      R__b << clusterSize;
      R__b << nDigis;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void DetCluDigiObj::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class DetCluDigiObj.
      TClass *R__cl = ::DetCluDigiObj::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "det", &det);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "clusterSize", &clusterSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "nDigis", &nDigis);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_DetCluDigiObj(void *p) {
      return  p ? new(p) ::DetCluDigiObj : new ::DetCluDigiObj;
   }
   static void *newArray_DetCluDigiObj(Long_t nElements, void *p) {
      return p ? new(p) ::DetCluDigiObj[nElements] : new ::DetCluDigiObj[nElements];
   }
   // Wrapper around operator delete
   static void delete_DetCluDigiObj(void *p) {
      delete ((::DetCluDigiObj*)p);
   }
   static void deleteArray_DetCluDigiObj(void *p) {
      delete [] ((::DetCluDigiObj*)p);
   }
   static void destruct_DetCluDigiObj(void *p) {
      typedef ::DetCluDigiObj current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_DetCluDigiObj(TBuffer &buf, void *obj) {
      ((::DetCluDigiObj*)obj)->::DetCluDigiObj::Streamer(buf);
   }
} // end of namespace ROOT for class ::DetCluDigiObj

//______________________________________________________________________________
void DetCluDigiObjVect::Streamer(TBuffer &R__b)
{
   // Stream an object of class DetCluDigiObjVect.

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TObject::Streamer(R__b);
      {
         vector<DetCluDigiObj> &R__stl =  data;
         R__stl.clear();
         int R__i, R__n;
         R__b >> R__n;
         R__stl.reserve(R__n);
         for (R__i = 0; R__i < R__n; R__i++) {
            DetCluDigiObj R__t;
            R__t.Streamer(R__b);
            R__stl.push_back(R__t);
         }
      }
      R__b.CheckByteCount(R__s, R__c, DetCluDigiObjVect::IsA());
   } else {
      R__c = R__b.WriteVersion(DetCluDigiObjVect::IsA(), kTRUE);
      TObject::Streamer(R__b);
      {
         vector<DetCluDigiObj> &R__stl =  data;
         int R__n=(&R__stl) ? int(R__stl.size()) : 0;
         R__b << R__n;
         if(R__n) {
            vector<DetCluDigiObj>::iterator R__k;
            for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
            ((DetCluDigiObj&)(*R__k)).Streamer(R__b);
            }
         }
      }
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void DetCluDigiObjVect::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class DetCluDigiObjVect.
      TClass *R__cl = ::DetCluDigiObjVect::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "data", (void*)&data);
      R__insp.InspectMember("vector<DetCluDigiObj>", (void*)&data, "data.", false);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_DetCluDigiObjVect(void *p) {
      return  p ? new(p) ::DetCluDigiObjVect : new ::DetCluDigiObjVect;
   }
   static void *newArray_DetCluDigiObjVect(Long_t nElements, void *p) {
      return p ? new(p) ::DetCluDigiObjVect[nElements] : new ::DetCluDigiObjVect[nElements];
   }
   // Wrapper around operator delete
   static void delete_DetCluDigiObjVect(void *p) {
      delete ((::DetCluDigiObjVect*)p);
   }
   static void deleteArray_DetCluDigiObjVect(void *p) {
      delete [] ((::DetCluDigiObjVect*)p);
   }
   static void destruct_DetCluDigiObjVect(void *p) {
      typedef ::DetCluDigiObjVect current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_DetCluDigiObjVect(TBuffer &buf, void *obj) {
      ((::DetCluDigiObjVect*)obj)->::DetCluDigiObjVect::Streamer(buf);
   }
} // end of namespace ROOT for class ::DetCluDigiObjVect

//______________________________________________________________________________
void TriggerMenuResultObj::Streamer(TBuffer &R__b)
{
   // Stream an object of class TriggerMenuResultObj.

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TObject::Streamer(R__b);
      {
         vector<std::string> &R__stl =  names;
         R__stl.clear();
         int R__i, R__n;
         R__b >> R__n;
         R__stl.reserve(R__n);
         for (R__i = 0; R__i < R__n; R__i++) {
            string R__t;
            {TString R__str;
             R__str.Streamer(R__b);
             R__t = R__str.Data();}
            R__stl.push_back(R__t);
         }
      }
      {
         vector<unsigned int> &R__stl =  firedAlgos;
         R__stl.clear();
         int R__i, R__n;
         R__b >> R__n;
         R__stl.reserve(R__n);
         for (R__i = 0; R__i < R__n; R__i++) {
            unsigned int R__t;
            R__b >> R__t;
            R__stl.push_back(R__t);
         }
      }
      R__b.CheckByteCount(R__s, R__c, TriggerMenuResultObj::IsA());
   } else {
      R__c = R__b.WriteVersion(TriggerMenuResultObj::IsA(), kTRUE);
      TObject::Streamer(R__b);
      {
         vector<std::string> &R__stl =  names;
         int R__n=(&R__stl) ? int(R__stl.size()) : 0;
         R__b << R__n;
         if(R__n) {
            vector<std::string>::iterator R__k;
            for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
            {TString R__str((*R__k).c_str());
             R__str.Streamer(R__b);};
            }
         }
      }
      {
         vector<unsigned int> &R__stl =  firedAlgos;
         int R__n=(&R__stl) ? int(R__stl.size()) : 0;
         R__b << R__n;
         if(R__n) {
            vector<unsigned int>::iterator R__k;
            for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
            R__b << (*R__k);
            }
         }
      }
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void TriggerMenuResultObj::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TriggerMenuResultObj.
      TClass *R__cl = ::TriggerMenuResultObj::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "names", (void*)&names);
      R__insp.InspectMember("vector<std::string>", (void*)&names, "names.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "firedAlgos", (void*)&firedAlgos);
      R__insp.InspectMember("vector<unsigned int>", (void*)&firedAlgos, "firedAlgos.", false);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TriggerMenuResultObj(void *p) {
      return  p ? new(p) ::TriggerMenuResultObj : new ::TriggerMenuResultObj;
   }
   static void *newArray_TriggerMenuResultObj(Long_t nElements, void *p) {
      return p ? new(p) ::TriggerMenuResultObj[nElements] : new ::TriggerMenuResultObj[nElements];
   }
   // Wrapper around operator delete
   static void delete_TriggerMenuResultObj(void *p) {
      delete ((::TriggerMenuResultObj*)p);
   }
   static void deleteArray_TriggerMenuResultObj(void *p) {
      delete [] ((::TriggerMenuResultObj*)p);
   }
   static void destruct_TriggerMenuResultObj(void *p) {
      typedef ::TriggerMenuResultObj current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TriggerMenuResultObj(TBuffer &buf, void *obj) {
      ((::TriggerMenuResultObj*)obj)->::TriggerMenuResultObj::Streamer(buf);
   }
} // end of namespace ROOT for class ::TriggerMenuResultObj

//______________________________________________________________________________
void HitSpecObj::Streamer(TBuffer &R__b)
{
   // Stream an object of class HitSpecObj.

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TObject::Streamer(R__b);
      R__b >> theRawId;
      R__b >> pos_x;
      R__b >> pos_y;
      R__b >> pos_z;
      R__b >> mom_x;
      R__b >> mom_y;
      R__b >> mom_z;
      R__b.CheckByteCount(R__s, R__c, HitSpecObj::IsA());
   } else {
      R__c = R__b.WriteVersion(HitSpecObj::IsA(), kTRUE);
      TObject::Streamer(R__b);
      R__b << theRawId;
      R__b << pos_x;
      R__b << pos_y;
      R__b << pos_z;
      R__b << mom_x;
      R__b << mom_y;
      R__b << mom_z;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void HitSpecObj::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class HitSpecObj.
      TClass *R__cl = ::HitSpecObj::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "theRawId", &theRawId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "pos_x", &pos_x);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "pos_y", &pos_y);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "pos_z", &pos_z);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "mom_x", &mom_x);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "mom_y", &mom_y);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "mom_z", &mom_z);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_HitSpecObj(void *p) {
      return  p ? new(p) ::HitSpecObj : new ::HitSpecObj;
   }
   static void *newArray_HitSpecObj(Long_t nElements, void *p) {
      return p ? new(p) ::HitSpecObj[nElements] : new ::HitSpecObj[nElements];
   }
   // Wrapper around operator delete
   static void delete_HitSpecObj(void *p) {
      delete ((::HitSpecObj*)p);
   }
   static void deleteArray_HitSpecObj(void *p) {
      delete [] ((::HitSpecObj*)p);
   }
   static void destruct_HitSpecObj(void *p) {
      typedef ::HitSpecObj current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_HitSpecObj(TBuffer &buf, void *obj) {
      ((::HitSpecObj*)obj)->::HitSpecObj::Streamer(buf);
   }
} // end of namespace ROOT for class ::HitSpecObj

namespace ROOT {
   void vectorlEDetCluDigiObjgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEDetCluDigiObjgR_Dictionary();
   static void *new_vectorlEDetCluDigiObjgR(void *p = 0);
   static void *newArray_vectorlEDetCluDigiObjgR(Long_t size, void *p);
   static void delete_vectorlEDetCluDigiObjgR(void *p);
   static void deleteArray_vectorlEDetCluDigiObjgR(void *p);
   static void destruct_vectorlEDetCluDigiObjgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<DetCluDigiObj>*)
   {
      vector<DetCluDigiObj> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<DetCluDigiObj>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<DetCluDigiObj>", -2, "/opt/cms/slc5_amd64_gcc472/lcg/root/5.34.07/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<DetCluDigiObj>), DefineBehavior(ptr, ptr),
                  0, &vectorlEDetCluDigiObjgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<DetCluDigiObj>) );
      instance.SetNew(&new_vectorlEDetCluDigiObjgR);
      instance.SetNewArray(&newArray_vectorlEDetCluDigiObjgR);
      instance.SetDelete(&delete_vectorlEDetCluDigiObjgR);
      instance.SetDeleteArray(&deleteArray_vectorlEDetCluDigiObjgR);
      instance.SetDestructor(&destruct_vectorlEDetCluDigiObjgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<DetCluDigiObj> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<DetCluDigiObj>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEDetCluDigiObjgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const vector<DetCluDigiObj>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEDetCluDigiObjgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<DetCluDigiObj> : new vector<DetCluDigiObj>;
   }
   static void *newArray_vectorlEDetCluDigiObjgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<DetCluDigiObj>[nElements] : new vector<DetCluDigiObj>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEDetCluDigiObjgR(void *p) {
      delete ((vector<DetCluDigiObj>*)p);
   }
   static void deleteArray_vectorlEDetCluDigiObjgR(void *p) {
      delete [] ((vector<DetCluDigiObj>*)p);
   }
   static void destruct_vectorlEDetCluDigiObjgR(void *p) {
      typedef vector<DetCluDigiObj> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<DetCluDigiObj>

namespace ROOT {
   void vectorlEL1ObjgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEL1ObjgR_Dictionary();
   static void *new_vectorlEL1ObjgR(void *p = 0);
   static void *newArray_vectorlEL1ObjgR(Long_t size, void *p);
   static void delete_vectorlEL1ObjgR(void *p);
   static void deleteArray_vectorlEL1ObjgR(void *p);
   static void destruct_vectorlEL1ObjgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<L1Obj>*)
   {
      vector<L1Obj> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<L1Obj>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<L1Obj>", -2, "/opt/cms/slc5_amd64_gcc472/lcg/root/5.34.07/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<L1Obj>), DefineBehavior(ptr, ptr),
                  0, &vectorlEL1ObjgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<L1Obj>) );
      instance.SetNew(&new_vectorlEL1ObjgR);
      instance.SetNewArray(&newArray_vectorlEL1ObjgR);
      instance.SetDelete(&delete_vectorlEL1ObjgR);
      instance.SetDeleteArray(&deleteArray_vectorlEL1ObjgR);
      instance.SetDestructor(&destruct_vectorlEL1ObjgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<L1Obj> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<L1Obj>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEL1ObjgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const vector<L1Obj>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEL1ObjgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<L1Obj> : new vector<L1Obj>;
   }
   static void *newArray_vectorlEL1ObjgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<L1Obj>[nElements] : new vector<L1Obj>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEL1ObjgR(void *p) {
      delete ((vector<L1Obj>*)p);
   }
   static void deleteArray_vectorlEL1ObjgR(void *p) {
      delete [] ((vector<L1Obj>*)p);
   }
   static void destruct_vectorlEL1ObjgR(void *p) {
      typedef vector<L1Obj> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<L1Obj>

namespace ROOT {
   void vectorlESynchroCountsObjgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlESynchroCountsObjgR_Dictionary();
   static void *new_vectorlESynchroCountsObjgR(void *p = 0);
   static void *newArray_vectorlESynchroCountsObjgR(Long_t size, void *p);
   static void delete_vectorlESynchroCountsObjgR(void *p);
   static void deleteArray_vectorlESynchroCountsObjgR(void *p);
   static void destruct_vectorlESynchroCountsObjgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<SynchroCountsObj>*)
   {
      vector<SynchroCountsObj> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<SynchroCountsObj>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<SynchroCountsObj>", -2, "/opt/cms/slc5_amd64_gcc472/lcg/root/5.34.07/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<SynchroCountsObj>), DefineBehavior(ptr, ptr),
                  0, &vectorlESynchroCountsObjgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<SynchroCountsObj>) );
      instance.SetNew(&new_vectorlESynchroCountsObjgR);
      instance.SetNewArray(&newArray_vectorlESynchroCountsObjgR);
      instance.SetDelete(&delete_vectorlESynchroCountsObjgR);
      instance.SetDeleteArray(&deleteArray_vectorlESynchroCountsObjgR);
      instance.SetDestructor(&destruct_vectorlESynchroCountsObjgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<SynchroCountsObj> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<SynchroCountsObj>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlESynchroCountsObjgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const vector<SynchroCountsObj>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlESynchroCountsObjgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<SynchroCountsObj> : new vector<SynchroCountsObj>;
   }
   static void *newArray_vectorlESynchroCountsObjgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<SynchroCountsObj>[nElements] : new vector<SynchroCountsObj>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlESynchroCountsObjgR(void *p) {
      delete ((vector<SynchroCountsObj>*)p);
   }
   static void deleteArray_vectorlESynchroCountsObjgR(void *p) {
      delete [] ((vector<SynchroCountsObj>*)p);
   }
   static void destruct_vectorlESynchroCountsObjgR(void *p) {
      typedef vector<SynchroCountsObj> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<SynchroCountsObj>

namespace ROOT {
   void vectorlEboolgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEboolgR_Dictionary();
   static void *new_vectorlEboolgR(void *p = 0);
   static void *newArray_vectorlEboolgR(Long_t size, void *p);
   static void delete_vectorlEboolgR(void *p);
   static void deleteArray_vectorlEboolgR(void *p);
   static void destruct_vectorlEboolgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<bool>*)
   {
      vector<bool> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<bool>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<bool>", -2, "vectorbool.dll", 0,
                  typeid(vector<bool>), DefineBehavior(ptr, ptr),
                  0, &vectorlEboolgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<bool>) );
      instance.SetNew(&new_vectorlEboolgR);
      instance.SetNewArray(&newArray_vectorlEboolgR);
      instance.SetDelete(&delete_vectorlEboolgR);
      instance.SetDeleteArray(&deleteArray_vectorlEboolgR);
      instance.SetDestructor(&destruct_vectorlEboolgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<bool> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<bool>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEboolgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const vector<bool>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEboolgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<bool> : new vector<bool>;
   }
   static void *newArray_vectorlEboolgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<bool>[nElements] : new vector<bool>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEboolgR(void *p) {
      delete ((vector<bool>*)p);
   }
   static void deleteArray_vectorlEboolgR(void *p) {
      delete [] ((vector<bool>*)p);
   }
   static void destruct_vectorlEboolgR(void *p) {
      typedef vector<bool> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<bool>

namespace ROOT {
   void vectorlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEdoublegR_Dictionary();
   static void *new_vectorlEdoublegR(void *p = 0);
   static void *newArray_vectorlEdoublegR(Long_t size, void *p);
   static void delete_vectorlEdoublegR(void *p);
   static void deleteArray_vectorlEdoublegR(void *p);
   static void destruct_vectorlEdoublegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<double>*)
   {
      vector<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<double>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<double>", -2, "vector.dll", 0,
                  typeid(vector<double>), DefineBehavior(ptr, ptr),
                  0, &vectorlEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(vector<double>) );
      instance.SetNew(&new_vectorlEdoublegR);
      instance.SetNewArray(&newArray_vectorlEdoublegR);
      instance.SetDelete(&delete_vectorlEdoublegR);
      instance.SetDeleteArray(&deleteArray_vectorlEdoublegR);
      instance.SetDestructor(&destruct_vectorlEdoublegR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<double> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const vector<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double> : new vector<double>;
   }
   static void *newArray_vectorlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double>[nElements] : new vector<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEdoublegR(void *p) {
      delete ((vector<double>*)p);
   }
   static void deleteArray_vectorlEdoublegR(void *p) {
      delete [] ((vector<double>*)p);
   }
   static void destruct_vectorlEdoublegR(void *p) {
      typedef vector<double> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<double>

namespace ROOT {
   void vectorlEstringgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEstringgR_Dictionary();
   static void *new_vectorlEstringgR(void *p = 0);
   static void *newArray_vectorlEstringgR(Long_t size, void *p);
   static void delete_vectorlEstringgR(void *p);
   static void deleteArray_vectorlEstringgR(void *p);
   static void destruct_vectorlEstringgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<string>*)
   {
      vector<string> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<string>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<string>", -2, "/opt/cms/slc5_amd64_gcc472/lcg/root/5.34.07/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<string>), DefineBehavior(ptr, ptr),
                  0, &vectorlEstringgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<string>) );
      instance.SetNew(&new_vectorlEstringgR);
      instance.SetNewArray(&newArray_vectorlEstringgR);
      instance.SetDelete(&delete_vectorlEstringgR);
      instance.SetDeleteArray(&deleteArray_vectorlEstringgR);
      instance.SetDestructor(&destruct_vectorlEstringgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<string> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<string>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEstringgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const vector<string>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEstringgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<string> : new vector<string>;
   }
   static void *newArray_vectorlEstringgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<string>[nElements] : new vector<string>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEstringgR(void *p) {
      delete ((vector<string>*)p);
   }
   static void deleteArray_vectorlEstringgR(void *p) {
      delete [] ((vector<string>*)p);
   }
   static void destruct_vectorlEstringgR(void *p) {
      typedef vector<string> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<string>

namespace ROOT {
   void vectorlEunsignedsPintgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEunsignedsPintgR_Dictionary();
   static void *new_vectorlEunsignedsPintgR(void *p = 0);
   static void *newArray_vectorlEunsignedsPintgR(Long_t size, void *p);
   static void delete_vectorlEunsignedsPintgR(void *p);
   static void deleteArray_vectorlEunsignedsPintgR(void *p);
   static void destruct_vectorlEunsignedsPintgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<unsigned int>*)
   {
      vector<unsigned int> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<unsigned int>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<unsigned int>", -2, "vector.dll", 0,
                  typeid(vector<unsigned int>), DefineBehavior(ptr, ptr),
                  0, &vectorlEunsignedsPintgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<unsigned int>) );
      instance.SetNew(&new_vectorlEunsignedsPintgR);
      instance.SetNewArray(&newArray_vectorlEunsignedsPintgR);
      instance.SetDelete(&delete_vectorlEunsignedsPintgR);
      instance.SetDeleteArray(&deleteArray_vectorlEunsignedsPintgR);
      instance.SetDestructor(&destruct_vectorlEunsignedsPintgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<unsigned int> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<unsigned int>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEunsignedsPintgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const vector<unsigned int>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEunsignedsPintgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<unsigned int> : new vector<unsigned int>;
   }
   static void *newArray_vectorlEunsignedsPintgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<unsigned int>[nElements] : new vector<unsigned int>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEunsignedsPintgR(void *p) {
      delete ((vector<unsigned int>*)p);
   }
   static void deleteArray_vectorlEunsignedsPintgR(void *p) {
      delete [] ((vector<unsigned int>*)p);
   }
   static void destruct_vectorlEunsignedsPintgR(void *p) {
      typedef vector<unsigned int> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<unsigned int>

/********************************************************
* rootMAnaDict.cc
* CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED
*          FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX().
*          CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE.
********************************************************/

#ifdef G__MEMTEST
#undef malloc
#undef free
#endif

#if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif

extern "C" void G__cpp_reset_tagtablerootMAnaDict();

extern "C" void G__set_cpp_environmentrootMAnaDict() {
  G__cpp_reset_tagtablerootMAnaDict();
}
#include <new>
extern "C" int G__cpp_dllrevrootMAnaDict() { return(30051515); }

/*********************************************************
* Member function Interface Method
*********************************************************/

/* EventObj */
static int G__rootMAnaDict_168_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) EventObj::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_168_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) EventObj::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_168_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) EventObj::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_168_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      EventObj::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_168_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((EventObj*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_168_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) EventObj::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_168_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) EventObj::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_168_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) EventObj::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_168_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) EventObj::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__rootMAnaDict_168_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   EventObj *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new EventObj[n];
     } else {
       p = new((void*) gvp) EventObj[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new EventObj;
     } else {
       p = new((void*) gvp) EventObj;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_EventObj));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__rootMAnaDict_168_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   EventObj* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new EventObj(*(EventObj*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_EventObj));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef EventObj G__TEventObj;
static int G__rootMAnaDict_168_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (EventObj*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((EventObj*) (soff+(sizeof(EventObj)*i)))->~G__TEventObj();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (EventObj*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((EventObj*) (soff))->~G__TEventObj();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__rootMAnaDict_168_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   EventObj* dest = (EventObj*) G__getstructoffset();
   *dest = *(EventObj*) libp->para[0].ref;
   const EventObj& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* L1Obj */
static int G__rootMAnaDict_169_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   L1Obj* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new L1Obj[n];
     } else {
       p = new((void*) gvp) L1Obj[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new L1Obj;
     } else {
       p = new((void*) gvp) L1Obj;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_L1Obj));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_169_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const L1Obj*) G__getstructoffset())->isValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_169_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) L1Obj::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_169_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) L1Obj::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_169_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) L1Obj::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_169_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      L1Obj::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_169_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((L1Obj*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_169_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) L1Obj::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_169_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) L1Obj::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_169_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) L1Obj::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_169_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) L1Obj::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__rootMAnaDict_169_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   L1Obj* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new L1Obj(*(L1Obj*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_L1Obj));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef L1Obj G__TL1Obj;
static int G__rootMAnaDict_169_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (L1Obj*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((L1Obj*) (soff+(sizeof(L1Obj)*i)))->~G__TL1Obj();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (L1Obj*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((L1Obj*) (soff))->~G__TL1Obj();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__rootMAnaDict_169_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   L1Obj* dest = (L1Obj*) G__getstructoffset();
   *dest = *(L1Obj*) libp->para[0].ref;
   const L1Obj& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* EventData */
static int G__rootMAnaDict_171_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   EventData* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new EventData[n];
     } else {
       p = new((void*) gvp) EventData[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new EventData;
     } else {
       p = new((void*) gvp) EventData;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_EventData));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_171_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((EventData*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_171_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) EventData::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_171_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) EventData::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_171_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) EventData::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_171_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      EventData::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_171_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((EventData*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_171_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) EventData::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_171_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) EventData::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_171_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) EventData::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_171_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) EventData::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__rootMAnaDict_171_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   EventData* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new EventData(*(EventData*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_EventData));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef EventData G__TEventData;
static int G__rootMAnaDict_171_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (EventData*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((EventData*) (soff+(sizeof(EventData)*i)))->~G__TEventData();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (EventData*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((EventData*) (soff))->~G__TEventData();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__rootMAnaDict_171_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   EventData* dest = (EventData*) G__getstructoffset();
   *dest = *(EventData*) libp->para[0].ref;
   const EventData& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TrackObj */
static int G__rootMAnaDict_176_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TrackObj* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TrackObj(
(float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]), (int) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TrackObj(
(float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]), (int) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TrackObj(
(float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TrackObj(
(float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TrackObj((float) G__double(libp->para[0]), (float) G__double(libp->para[1]));
     } else {
       p = new((void*) gvp) TrackObj((float) G__double(libp->para[0]), (float) G__double(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TrackObj((float) G__double(libp->para[0]));
     } else {
       p = new((void*) gvp) TrackObj((float) G__double(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TrackObj[n];
       } else {
         p = new((void*) gvp) TrackObj[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TrackObj;
       } else {
         p = new((void*) gvp) TrackObj;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_TrackObj));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_176_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TrackObj*) G__getstructoffset())->setKine((float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]), (int) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_176_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TrackObj*) G__getstructoffset())->pt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_176_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TrackObj*) G__getstructoffset())->eta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_176_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TrackObj*) G__getstructoffset())->phi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_176_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TrackObj*) G__getstructoffset())->charge());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_176_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TrackObj::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_176_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TrackObj::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_176_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TrackObj::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_176_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TrackObj::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_176_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TrackObj*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_176_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TrackObj::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_176_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TrackObj::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_176_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TrackObj::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_176_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TrackObj::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__rootMAnaDict_176_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TrackObj* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TrackObj(*(TrackObj*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_TrackObj));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TrackObj G__TTrackObj;
static int G__rootMAnaDict_176_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TrackObj*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TrackObj*) (soff+(sizeof(TrackObj)*i)))->~G__TTrackObj();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TrackObj*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TrackObj*) (soff))->~G__TTrackObj();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__rootMAnaDict_176_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TrackObj* dest = (TrackObj*) G__getstructoffset();
   *dest = *(TrackObj*) libp->para[0].ref;
   const TrackObj& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* MuonObj */
static int G__rootMAnaDict_177_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   MuonObj* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new MuonObj(
(float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]), (float) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) MuonObj(
(float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]), (float) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new MuonObj(
(float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) MuonObj(
(float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new MuonObj((float) G__double(libp->para[0]), (float) G__double(libp->para[1]));
     } else {
       p = new((void*) gvp) MuonObj((float) G__double(libp->para[0]), (float) G__double(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new MuonObj((float) G__double(libp->para[0]));
     } else {
       p = new((void*) gvp) MuonObj((float) G__double(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new MuonObj[n];
       } else {
         p = new((void*) gvp) MuonObj[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new MuonObj;
       } else {
         p = new((void*) gvp) MuonObj;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_MuonObj));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_177_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((MuonObj*) G__getstructoffset())->setBits((bool) G__int(libp->para[0]), (bool) G__int(libp->para[1])
, (bool) G__int(libp->para[2]), (bool) G__int(libp->para[3])
, (bool) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_177_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const MuonObj*) G__getstructoffset())->isGlobal());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_177_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const MuonObj*) G__getstructoffset())->isTracker());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_177_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const MuonObj*) G__getstructoffset())->isOuter());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_177_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const MuonObj*) G__getstructoffset())->isCalo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_177_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const MuonObj*) G__getstructoffset())->isMatched());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_177_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) MuonObj::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_177_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) MuonObj::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_177_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) MuonObj::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_177_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      MuonObj::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_177_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((MuonObj*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_177_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) MuonObj::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_177_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) MuonObj::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_177_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) MuonObj::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_177_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) MuonObj::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__rootMAnaDict_177_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   MuonObj* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new MuonObj(*(MuonObj*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_MuonObj));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef MuonObj G__TMuonObj;
static int G__rootMAnaDict_177_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (MuonObj*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((MuonObj*) (soff+(sizeof(MuonObj)*i)))->~G__TMuonObj();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (MuonObj*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((MuonObj*) (soff))->~G__TMuonObj();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__rootMAnaDict_177_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   MuonObj* dest = (MuonObj*) G__getstructoffset();
   *dest = *(MuonObj*) libp->para[0].ref;
   const MuonObj& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* L1ObjColl */
static int G__rootMAnaDict_179_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   L1ObjColl* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new L1ObjColl[n];
     } else {
       p = new((void*) gvp) L1ObjColl[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new L1ObjColl;
     } else {
       p = new((void*) gvp) L1ObjColl;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((L1ObjColl*) G__getstructoffset())->set(*(vector<L1Obj>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((L1ObjColl*) G__getstructoffset())->set(*(vector<bool>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((L1ObjColl*) G__getstructoffset())->set(*(vector<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((L1ObjColl*) G__getstructoffset())->push_back(*(L1Obj*) libp->para[0].ref, (bool) G__int(libp->para[1])
, (double) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<L1Obj>& obj = ((const L1ObjColl*) G__getstructoffset())->getL1Objs();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<L1Obj>& obj = ((const L1ObjColl*) G__getstructoffset())->operator const ::std::vector<L1Obj>&();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<bool>& obj = ((const L1ObjColl*) G__getstructoffset())->getL1ObjsMatching();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>& obj = ((const L1ObjColl*) G__getstructoffset())->getL1ObjDeltaR();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const L1ObjColl* pobj;
         const L1ObjColl xobj = ((const L1ObjColl*) G__getstructoffset())->l1RpcColl();
         pobj = new L1ObjColl(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const L1ObjColl* pobj;
         const L1ObjColl xobj = ((const L1ObjColl*) G__getstructoffset())->l1RpcCollEmu();
         pobj = new L1ObjColl(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const L1ObjColl* pobj;
         const L1ObjColl xobj = ((const L1ObjColl*) G__getstructoffset())->l1OthColl();
         pobj = new L1ObjColl(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const L1ObjColl* pobj;
         const L1ObjColl xobj = ((const L1ObjColl*) G__getstructoffset())->selectByType((L1ObjColl::TYPE) G__int(libp->para[0]));
         pobj = new L1ObjColl(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const L1ObjColl* pobj;
         const L1ObjColl xobj = ((const L1ObjColl*) G__getstructoffset())->selectByPt((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
         pobj = new L1ObjColl(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         const L1ObjColl* pobj;
         const L1ObjColl xobj = ((const L1ObjColl*) G__getstructoffset())->selectByPt((double) G__double(libp->para[0]));
         pobj = new L1ObjColl(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 0:
      {
         const L1ObjColl* pobj;
         const L1ObjColl xobj = ((const L1ObjColl*) G__getstructoffset())->selectByPt();
         pobj = new L1ObjColl(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      {
         const L1ObjColl* pobj;
         const L1ObjColl xobj = ((const L1ObjColl*) G__getstructoffset())->selectByPtMin((double) G__double(libp->para[0]));
         pobj = new L1ObjColl(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 0:
      {
         const L1ObjColl* pobj;
         const L1ObjColl xobj = ((const L1ObjColl*) G__getstructoffset())->selectByPtMin();
         pobj = new L1ObjColl(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const L1ObjColl* pobj;
         const L1ObjColl xobj = ((const L1ObjColl*) G__getstructoffset())->selectByEta((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
         pobj = new L1ObjColl(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         const L1ObjColl* pobj;
         const L1ObjColl xobj = ((const L1ObjColl*) G__getstructoffset())->selectByEta((double) G__double(libp->para[0]));
         pobj = new L1ObjColl(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 0:
      {
         const L1ObjColl* pobj;
         const L1ObjColl xobj = ((const L1ObjColl*) G__getstructoffset())->selectByEta();
         pobj = new L1ObjColl(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const L1ObjColl* pobj;
         const L1ObjColl xobj = ((const L1ObjColl*) G__getstructoffset())->selectByBx((int) G__int(libp->para[0]), (int) G__int(libp->para[1]));
         pobj = new L1ObjColl(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         const L1ObjColl* pobj;
         const L1ObjColl xobj = ((const L1ObjColl*) G__getstructoffset())->selectByBx((int) G__int(libp->para[0]));
         pobj = new L1ObjColl(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 0:
      {
         const L1ObjColl* pobj;
         const L1ObjColl xobj = ((const L1ObjColl*) G__getstructoffset())->selectByBx();
         pobj = new L1ObjColl(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const L1ObjColl* pobj;
         const L1ObjColl xobj = ((const L1ObjColl*) G__getstructoffset())->selectByQuality((int) G__int(libp->para[0]), (int) G__int(libp->para[1]));
         pobj = new L1ObjColl(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         const L1ObjColl* pobj;
         const L1ObjColl xobj = ((const L1ObjColl*) G__getstructoffset())->selectByQuality((int) G__int(libp->para[0]));
         pobj = new L1ObjColl(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 0:
      {
         const L1ObjColl* pobj;
         const L1ObjColl xobj = ((const L1ObjColl*) G__getstructoffset())->selectByQuality();
         pobj = new L1ObjColl(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const L1ObjColl* pobj;
         const L1ObjColl xobj = ((const L1ObjColl*) G__getstructoffset())->selectByMatched();
         pobj = new L1ObjColl(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const L1ObjColl* pobj;
         const L1ObjColl xobj = ((const L1ObjColl*) G__getstructoffset())->selectByDeltaR((double) G__double(libp->para[0]));
         pobj = new L1ObjColl(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const L1ObjColl* pobj;
         const L1ObjColl xobj = ((const L1ObjColl*) G__getstructoffset())->operator+(*(L1ObjColl*) libp->para[0].ref);
         pobj = new L1ObjColl(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const L1ObjColl*) G__getstructoffset())->operator bool());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const L1ObjColl*) G__getstructoffset())->operator!());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const L1ObjColl*) G__getstructoffset())->isMatching_DRBx_At((double) G__double(libp->para[0]), (int) G__int(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (double) G__double(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) ((const L1ObjColl*) G__getstructoffset())->isMatching_DRBx((double) G__double(libp->para[0]), (int) G__int(libp->para[1])
, (double) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) ((const L1ObjColl*) G__getstructoffset())->isMatching_DRBx((double) G__double(libp->para[0]), (int) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const L1ObjColl*) G__getstructoffset())->isMatching_PtminPtmaxBx((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (int) G__int(libp->para[2]), (bool) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      {
         const vector<L1Obj>* pobj;
         const vector<L1Obj> xobj = ((const L1ObjColl*) G__getstructoffset())->getL1ObjsMatched((double) G__double(libp->para[0]));
         pobj = new vector<L1Obj>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 0:
      {
         const vector<L1Obj>* pobj;
         const vector<L1Obj> xobj = ((const L1ObjColl*) G__getstructoffset())->getL1ObjsMatched();
         pobj = new vector<L1Obj>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 12:
      {
         const vector<L1Obj>* pobj;
         const vector<L1Obj> xobj = ((const L1ObjColl*) G__getstructoffset())->getL1ObjsSelected(
(bool) G__int(libp->para[0]), (bool) G__int(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])
, (double) G__double(libp->para[6]), (double) G__double(libp->para[7])
, (double) G__double(libp->para[8]), (double) G__double(libp->para[9])
, (int) G__int(libp->para[10]), (int) G__int(libp->para[11]));
         pobj = new vector<L1Obj>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 11:
      {
         const vector<L1Obj>* pobj;
         const vector<L1Obj> xobj = ((const L1ObjColl*) G__getstructoffset())->getL1ObjsSelected(
(bool) G__int(libp->para[0]), (bool) G__int(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])
, (double) G__double(libp->para[6]), (double) G__double(libp->para[7])
, (double) G__double(libp->para[8]), (double) G__double(libp->para[9])
, (int) G__int(libp->para[10]));
         pobj = new vector<L1Obj>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 10:
      {
         const vector<L1Obj>* pobj;
         const vector<L1Obj> xobj = ((const L1ObjColl*) G__getstructoffset())->getL1ObjsSelected(
(bool) G__int(libp->para[0]), (bool) G__int(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])
, (double) G__double(libp->para[6]), (double) G__double(libp->para[7])
, (double) G__double(libp->para[8]), (double) G__double(libp->para[9]));
         pobj = new vector<L1Obj>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 9:
      {
         const vector<L1Obj>* pobj;
         const vector<L1Obj> xobj = ((const L1ObjColl*) G__getstructoffset())->getL1ObjsSelected(
(bool) G__int(libp->para[0]), (bool) G__int(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])
, (double) G__double(libp->para[6]), (double) G__double(libp->para[7])
, (double) G__double(libp->para[8]));
         pobj = new vector<L1Obj>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 8:
      {
         const vector<L1Obj>* pobj;
         const vector<L1Obj> xobj = ((const L1ObjColl*) G__getstructoffset())->getL1ObjsSelected(
(bool) G__int(libp->para[0]), (bool) G__int(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])
, (double) G__double(libp->para[6]), (double) G__double(libp->para[7]));
         pobj = new vector<L1Obj>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 7:
      {
         const vector<L1Obj>* pobj;
         const vector<L1Obj> xobj = ((const L1ObjColl*) G__getstructoffset())->getL1ObjsSelected(
(bool) G__int(libp->para[0]), (bool) G__int(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])
, (double) G__double(libp->para[6]));
         pobj = new vector<L1Obj>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 6:
      {
         const vector<L1Obj>* pobj;
         const vector<L1Obj> xobj = ((const L1ObjColl*) G__getstructoffset())->getL1ObjsSelected((bool) G__int(libp->para[0]), (bool) G__int(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5]));
         pobj = new vector<L1Obj>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 5:
      {
         const vector<L1Obj>* pobj;
         const vector<L1Obj> xobj = ((const L1ObjColl*) G__getstructoffset())->getL1ObjsSelected((bool) G__int(libp->para[0]), (bool) G__int(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (int) G__int(libp->para[4]));
         pobj = new vector<L1Obj>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         const vector<L1Obj>* pobj;
         const vector<L1Obj> xobj = ((const L1ObjColl*) G__getstructoffset())->getL1ObjsSelected((bool) G__int(libp->para[0]), (bool) G__int(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3]));
         pobj = new vector<L1Obj>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 3:
      {
         const vector<L1Obj>* pobj;
         const vector<L1Obj> xobj = ((const L1ObjColl*) G__getstructoffset())->getL1ObjsSelected((bool) G__int(libp->para[0]), (bool) G__int(libp->para[1])
, (double) G__double(libp->para[2]));
         pobj = new vector<L1Obj>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 2:
      {
         const vector<L1Obj>* pobj;
         const vector<L1Obj> xobj = ((const L1ObjColl*) G__getstructoffset())->getL1ObjsSelected((bool) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
         pobj = new vector<L1Obj>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         const vector<L1Obj>* pobj;
         const vector<L1Obj> xobj = ((const L1ObjColl*) G__getstructoffset())->getL1ObjsSelected((bool) G__int(libp->para[0]));
         pobj = new vector<L1Obj>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 0:
      {
         const vector<L1Obj>* pobj;
         const vector<L1Obj> xobj = ((const L1ObjColl*) G__getstructoffset())->getL1ObjsSelected();
         pobj = new vector<L1Obj>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      {
         vector<L1Obj>* pobj;
         vector<L1Obj> xobj = L1ObjColl::typeSelector(*(vector<L1Obj>*) libp->para[0].ref, (L1ObjColl::TYPE) G__int(libp->para[1])
, (L1ObjColl::TYPE) G__int(libp->para[2]), (L1ObjColl::TYPE) G__int(libp->para[3])
, (L1ObjColl::TYPE) G__int(libp->para[4]));
         pobj = new vector<L1Obj>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         vector<L1Obj>* pobj;
         vector<L1Obj> xobj = L1ObjColl::typeSelector(*(vector<L1Obj>*) libp->para[0].ref, (L1ObjColl::TYPE) G__int(libp->para[1])
, (L1ObjColl::TYPE) G__int(libp->para[2]), (L1ObjColl::TYPE) G__int(libp->para[3]));
         pobj = new vector<L1Obj>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 3:
      {
         vector<L1Obj>* pobj;
         vector<L1Obj> xobj = L1ObjColl::typeSelector(*(vector<L1Obj>*) libp->para[0].ref, (L1ObjColl::TYPE) G__int(libp->para[1])
, (L1ObjColl::TYPE) G__int(libp->para[2]));
         pobj = new vector<L1Obj>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 2:
      {
         vector<L1Obj>* pobj;
         vector<L1Obj> xobj = L1ObjColl::typeSelector(*(vector<L1Obj>*) libp->para[0].ref, (L1ObjColl::TYPE) G__int(libp->para[1]));
         pobj = new vector<L1Obj>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         vector<L1Obj>* pobj;
         vector<L1Obj> xobj = L1ObjColl::typeSelector(*(vector<L1Obj>*) libp->para[0].ref);
         pobj = new vector<L1Obj>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) L1ObjColl::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) L1ObjColl::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) L1ObjColl::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      L1ObjColl::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((L1ObjColl*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) L1ObjColl::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) L1ObjColl::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) L1ObjColl::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_179_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) L1ObjColl::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__rootMAnaDict_179_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   L1ObjColl* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new L1ObjColl(*(L1ObjColl*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef L1ObjColl G__TL1ObjColl;
static int G__rootMAnaDict_179_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (L1ObjColl*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((L1ObjColl*) (soff+(sizeof(L1ObjColl)*i)))->~G__TL1ObjColl();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (L1ObjColl*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((L1ObjColl*) (soff))->~G__TL1ObjColl();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__rootMAnaDict_179_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   L1ObjColl* dest = (L1ObjColl*) G__getstructoffset();
   *dest = *(L1ObjColl*) libp->para[0].ref;
   const L1ObjColl& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* SynchroCountsObj */
static int G__rootMAnaDict_180_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) SynchroCountsObj::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_180_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) SynchroCountsObj::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_180_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) SynchroCountsObj::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_180_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      SynchroCountsObj::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_180_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((SynchroCountsObj*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_180_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) SynchroCountsObj::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_180_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) SynchroCountsObj::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_180_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) SynchroCountsObj::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_180_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) SynchroCountsObj::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__rootMAnaDict_180_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   SynchroCountsObj *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new SynchroCountsObj[n];
     } else {
       p = new((void*) gvp) SynchroCountsObj[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new SynchroCountsObj;
     } else {
       p = new((void*) gvp) SynchroCountsObj;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_SynchroCountsObj));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__rootMAnaDict_180_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   SynchroCountsObj* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new SynchroCountsObj(*(SynchroCountsObj*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_SynchroCountsObj));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef SynchroCountsObj G__TSynchroCountsObj;
static int G__rootMAnaDict_180_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (SynchroCountsObj*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((SynchroCountsObj*) (soff+(sizeof(SynchroCountsObj)*i)))->~G__TSynchroCountsObj();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (SynchroCountsObj*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((SynchroCountsObj*) (soff))->~G__TSynchroCountsObj();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__rootMAnaDict_180_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   SynchroCountsObj* dest = (SynchroCountsObj*) G__getstructoffset();
   *dest = *(SynchroCountsObj*) libp->para[0].ref;
   const SynchroCountsObj& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* SynchroCountsObjVect */
static int G__rootMAnaDict_181_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) SynchroCountsObjVect::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_181_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) SynchroCountsObjVect::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_181_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) SynchroCountsObjVect::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_181_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      SynchroCountsObjVect::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_181_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((SynchroCountsObjVect*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_181_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) SynchroCountsObjVect::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_181_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) SynchroCountsObjVect::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_181_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) SynchroCountsObjVect::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_181_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) SynchroCountsObjVect::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__rootMAnaDict_181_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   SynchroCountsObjVect *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new SynchroCountsObjVect[n];
     } else {
       p = new((void*) gvp) SynchroCountsObjVect[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new SynchroCountsObjVect;
     } else {
       p = new((void*) gvp) SynchroCountsObjVect;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_SynchroCountsObjVect));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__rootMAnaDict_181_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   SynchroCountsObjVect* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new SynchroCountsObjVect(*(SynchroCountsObjVect*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_SynchroCountsObjVect));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef SynchroCountsObjVect G__TSynchroCountsObjVect;
static int G__rootMAnaDict_181_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (SynchroCountsObjVect*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((SynchroCountsObjVect*) (soff+(sizeof(SynchroCountsObjVect)*i)))->~G__TSynchroCountsObjVect();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (SynchroCountsObjVect*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((SynchroCountsObjVect*) (soff))->~G__TSynchroCountsObjVect();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__rootMAnaDict_181_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   SynchroCountsObjVect* dest = (SynchroCountsObjVect*) G__getstructoffset();
   *dest = *(SynchroCountsObjVect*) libp->para[0].ref;
   const SynchroCountsObjVect& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* DetCluDigiObj */
static int G__rootMAnaDict_186_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) DetCluDigiObj::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_186_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) DetCluDigiObj::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_186_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) DetCluDigiObj::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_186_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      DetCluDigiObj::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_186_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((DetCluDigiObj*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_186_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) DetCluDigiObj::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_186_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) DetCluDigiObj::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_186_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) DetCluDigiObj::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_186_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) DetCluDigiObj::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__rootMAnaDict_186_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   DetCluDigiObj *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new DetCluDigiObj[n];
     } else {
       p = new((void*) gvp) DetCluDigiObj[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new DetCluDigiObj;
     } else {
       p = new((void*) gvp) DetCluDigiObj;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_DetCluDigiObj));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__rootMAnaDict_186_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   DetCluDigiObj* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new DetCluDigiObj(*(DetCluDigiObj*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_DetCluDigiObj));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef DetCluDigiObj G__TDetCluDigiObj;
static int G__rootMAnaDict_186_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (DetCluDigiObj*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((DetCluDigiObj*) (soff+(sizeof(DetCluDigiObj)*i)))->~G__TDetCluDigiObj();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (DetCluDigiObj*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((DetCluDigiObj*) (soff))->~G__TDetCluDigiObj();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__rootMAnaDict_186_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   DetCluDigiObj* dest = (DetCluDigiObj*) G__getstructoffset();
   *dest = *(DetCluDigiObj*) libp->para[0].ref;
   const DetCluDigiObj& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* DetCluDigiObjVect */
static int G__rootMAnaDict_187_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) DetCluDigiObjVect::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_187_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) DetCluDigiObjVect::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_187_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) DetCluDigiObjVect::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_187_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      DetCluDigiObjVect::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_187_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((DetCluDigiObjVect*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_187_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) DetCluDigiObjVect::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_187_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) DetCluDigiObjVect::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_187_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) DetCluDigiObjVect::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_187_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) DetCluDigiObjVect::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__rootMAnaDict_187_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   DetCluDigiObjVect *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new DetCluDigiObjVect[n];
     } else {
       p = new((void*) gvp) DetCluDigiObjVect[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new DetCluDigiObjVect;
     } else {
       p = new((void*) gvp) DetCluDigiObjVect;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_DetCluDigiObjVect));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__rootMAnaDict_187_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   DetCluDigiObjVect* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new DetCluDigiObjVect(*(DetCluDigiObjVect*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_DetCluDigiObjVect));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef DetCluDigiObjVect G__TDetCluDigiObjVect;
static int G__rootMAnaDict_187_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (DetCluDigiObjVect*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((DetCluDigiObjVect*) (soff+(sizeof(DetCluDigiObjVect)*i)))->~G__TDetCluDigiObjVect();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (DetCluDigiObjVect*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((DetCluDigiObjVect*) (soff))->~G__TDetCluDigiObjVect();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__rootMAnaDict_187_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   DetCluDigiObjVect* dest = (DetCluDigiObjVect*) G__getstructoffset();
   *dest = *(DetCluDigiObjVect*) libp->para[0].ref;
   const DetCluDigiObjVect& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TriggerMenuResultObj */
static int G__rootMAnaDict_192_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TriggerMenuResultObj::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_192_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TriggerMenuResultObj::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_192_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TriggerMenuResultObj::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_192_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TriggerMenuResultObj::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_192_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TriggerMenuResultObj*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_192_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TriggerMenuResultObj::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_192_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TriggerMenuResultObj::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_192_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TriggerMenuResultObj::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_192_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TriggerMenuResultObj::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__rootMAnaDict_192_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TriggerMenuResultObj *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TriggerMenuResultObj[n];
     } else {
       p = new((void*) gvp) TriggerMenuResultObj[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TriggerMenuResultObj;
     } else {
       p = new((void*) gvp) TriggerMenuResultObj;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_TriggerMenuResultObj));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__rootMAnaDict_192_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TriggerMenuResultObj* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TriggerMenuResultObj(*(TriggerMenuResultObj*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_TriggerMenuResultObj));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TriggerMenuResultObj G__TTriggerMenuResultObj;
static int G__rootMAnaDict_192_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TriggerMenuResultObj*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TriggerMenuResultObj*) (soff+(sizeof(TriggerMenuResultObj)*i)))->~G__TTriggerMenuResultObj();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TriggerMenuResultObj*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TriggerMenuResultObj*) (soff))->~G__TTriggerMenuResultObj();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__rootMAnaDict_192_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TriggerMenuResultObj* dest = (TriggerMenuResultObj*) G__getstructoffset();
   *dest = *(TriggerMenuResultObj*) libp->para[0].ref;
   const TriggerMenuResultObj& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* HitSpecObj */
static int G__rootMAnaDict_234_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   HitSpecObj* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new HitSpecObj(
(unsigned int) G__int(libp->para[0]), *(GlobalPoint*) libp->para[1].ref
, *(GlobalVector*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) HitSpecObj(
(unsigned int) G__int(libp->para[0]), *(GlobalPoint*) libp->para[1].ref
, *(GlobalVector*) libp->para[2].ref);
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new HitSpecObj((unsigned int) G__int(libp->para[0]), *(GlobalPoint*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) HitSpecObj((unsigned int) G__int(libp->para[0]), *(GlobalPoint*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new HitSpecObj((unsigned int) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) HitSpecObj((unsigned int) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new HitSpecObj[n];
       } else {
         p = new((void*) gvp) HitSpecObj[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new HitSpecObj;
       } else {
         p = new((void*) gvp) HitSpecObj;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_HitSpecObj));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_234_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const HitSpecObj*) G__getstructoffset())->rawId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_234_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const GlobalPoint* pobj;
         const GlobalPoint xobj = ((const HitSpecObj*) G__getstructoffset())->position();
         pobj = new GlobalPoint(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_234_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const GlobalVector* pobj;
         const GlobalVector xobj = ((const HitSpecObj*) G__getstructoffset())->momentum();
         pobj = new GlobalVector(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_234_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) HitSpecObj::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_234_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) HitSpecObj::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_234_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) HitSpecObj::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_234_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      HitSpecObj::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_234_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((HitSpecObj*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_234_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) HitSpecObj::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_234_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) HitSpecObj::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_234_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) HitSpecObj::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_234_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) HitSpecObj::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__rootMAnaDict_234_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   HitSpecObj* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new HitSpecObj(*(HitSpecObj*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_HitSpecObj));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef HitSpecObj G__THitSpecObj;
static int G__rootMAnaDict_234_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (HitSpecObj*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((HitSpecObj*) (soff+(sizeof(HitSpecObj)*i)))->~G__THitSpecObj();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (HitSpecObj*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((HitSpecObj*) (soff))->~G__THitSpecObj();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__rootMAnaDict_234_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   HitSpecObj* dest = (HitSpecObj*) G__getstructoffset();
   *dest = *(HitSpecObj*) libp->para[0].ref;
   const HitSpecObj& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */

/*********************************************************
* Member function Stub
*********************************************************/

/* EventObj */

/* L1Obj */

/* EventData */

/* TrackObj */

/* MuonObj */

/* L1ObjColl */

/* SynchroCountsObj */

/* SynchroCountsObjVect */

/* DetCluDigiObj */

/* DetCluDigiObjVect */

/* TriggerMenuResultObj */

/* HitSpecObj */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncrootMAnaDict {
 public:
  G__Sizep2memfuncrootMAnaDict(): p(&G__Sizep2memfuncrootMAnaDict::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncrootMAnaDict::*p)();
};

size_t G__get_sizep2memfuncrootMAnaDict()
{
  G__Sizep2memfuncrootMAnaDict a;
  G__setsizep2memfunc((int)a.sizep2memfunc());
  return((size_t)a.sizep2memfunc());
}


/*********************************************************
* virtual base class offset calculation interface
*********************************************************/

   /* Setting up class inheritance */

/*********************************************************
* Inheritance information setup/
*********************************************************/
extern "C" void G__cpp_setup_inheritancerootMAnaDict() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__rootMAnaDictLN_EventObj))) {
     EventObj *G__Lderived;
     G__Lderived=(EventObj*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_EventObj),G__get_linked_tagnum(&G__rootMAnaDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__rootMAnaDictLN_L1Obj))) {
     L1Obj *G__Lderived;
     G__Lderived=(L1Obj*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_L1Obj),G__get_linked_tagnum(&G__rootMAnaDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__rootMAnaDictLN_EventData))) {
     EventData *G__Lderived;
     G__Lderived=(EventData*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_EventData),G__get_linked_tagnum(&G__rootMAnaDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__rootMAnaDictLN_TrackObj))) {
     TrackObj *G__Lderived;
     G__Lderived=(TrackObj*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_TrackObj),G__get_linked_tagnum(&G__rootMAnaDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__rootMAnaDictLN_MuonObj))) {
     MuonObj *G__Lderived;
     G__Lderived=(MuonObj*)0x1000;
     {
       TrackObj *G__Lpbase=(TrackObj*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_MuonObj),G__get_linked_tagnum(&G__rootMAnaDictLN_TrackObj),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_MuonObj),G__get_linked_tagnum(&G__rootMAnaDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl))) {
     L1ObjColl *G__Lderived;
     G__Lderived=(L1ObjColl*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl),G__get_linked_tagnum(&G__rootMAnaDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__rootMAnaDictLN_SynchroCountsObj))) {
     SynchroCountsObj *G__Lderived;
     G__Lderived=(SynchroCountsObj*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_SynchroCountsObj),G__get_linked_tagnum(&G__rootMAnaDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__rootMAnaDictLN_SynchroCountsObjVect))) {
     SynchroCountsObjVect *G__Lderived;
     G__Lderived=(SynchroCountsObjVect*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_SynchroCountsObjVect),G__get_linked_tagnum(&G__rootMAnaDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__rootMAnaDictLN_DetCluDigiObj))) {
     DetCluDigiObj *G__Lderived;
     G__Lderived=(DetCluDigiObj*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_DetCluDigiObj),G__get_linked_tagnum(&G__rootMAnaDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__rootMAnaDictLN_DetCluDigiObjVect))) {
     DetCluDigiObjVect *G__Lderived;
     G__Lderived=(DetCluDigiObjVect*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_DetCluDigiObjVect),G__get_linked_tagnum(&G__rootMAnaDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__rootMAnaDictLN_TriggerMenuResultObj))) {
     TriggerMenuResultObj *G__Lderived;
     G__Lderived=(TriggerMenuResultObj*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_TriggerMenuResultObj),G__get_linked_tagnum(&G__rootMAnaDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__rootMAnaDictLN_HitSpecObj))) {
     HitSpecObj *G__Lderived;
     G__Lderived=(HitSpecObj*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_HitSpecObj),G__get_linked_tagnum(&G__rootMAnaDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetablerootMAnaDict() {

   /* Setting up typedef entry */
   G__search_typename2("Version_t",115,-1,0,-1);
   G__setnewtype(-1,"Class version identifier (short)",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<L1Obj>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEL1ObjcOallocatorlEL1ObjgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_reverse_iteratorlEvectorlEL1ObjcOallocatorlEL1ObjgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEL1ObjcOallocatorlEL1ObjgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_reverse_iteratorlEvectorlEL1ObjcOallocatorlEL1ObjgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEL1ObjcOallocatorlEL1ObjgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TYPE",117,G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjcLcLTYPE),0,G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<SynchroCountsObj>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlESynchroCountsObjcOallocatorlESynchroCountsObjgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_reverse_iteratorlEvectorlESynchroCountsObjcOallocatorlESynchroCountsObjgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlESynchroCountsObjcOallocatorlESynchroCountsObjgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_reverse_iteratorlEvectorlESynchroCountsObjcOallocatorlESynchroCountsObjgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlESynchroCountsObjcOallocatorlESynchroCountsObjgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<DetCluDigiObj>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEDetCluDigiObjcOallocatorlEDetCluDigiObjgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_reverse_iteratorlEvectorlEDetCluDigiObjcOallocatorlEDetCluDigiObjgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEDetCluDigiObjcOallocatorlEDetCluDigiObjgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_reverse_iteratorlEvectorlEDetCluDigiObjcOallocatorlEDetCluDigiObjgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEDetCluDigiObjcOallocatorlEDetCluDigiObjgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::string>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<string>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<string>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("GlobalPoint",117,G__get_linked_tagnum(&G__rootMAnaDictLN_Point3DBaselEfloatcOGlobalTaggR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("GlobalVector",117,G__get_linked_tagnum(&G__rootMAnaDictLN_Vector3DBaselEfloatcOGlobalTaggR),0,-1);
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* EventObj */
static void G__setup_memvarEventObj(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_EventObj));
   { EventObj *p; p=(EventObj*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->bx)-(long)(p)),104,0,0,-1,-1,-1,1,"bx=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->id)-(long)(p)),104,0,0,-1,-1,-1,1,"id=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->lumi)-(long)(p)),104,0,0,-1,-1,-1,1,"lumi=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->run)-(long)(p)),104,0,0,-1,-1,-1,1,"run=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->time)-(long)(p)),109,0,0,-1,G__defined_typename("ULong64_t"),-1,1,"time=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->orbit)-(long)(p)),109,0,0,-1,G__defined_typename("ULong64_t"),-1,1,"orbit=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* L1Obj */
static void G__setup_memvarL1Obj(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_L1Obj));
   { L1Obj *p; p=(L1Obj*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjcLcLTYPE),-1,-2,1,G__FastAllocString(4096).Format("NONE=%lldLL",(long long)L1Obj::NONE).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjcLcLTYPE),-1,-2,1,G__FastAllocString(4096).Format("RPCb=%lldLL",(long long)L1Obj::RPCb).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjcLcLTYPE),-1,-2,1,G__FastAllocString(4096).Format("RPCf=%lldLL",(long long)L1Obj::RPCf).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjcLcLTYPE),-1,-2,1,G__FastAllocString(4096).Format("DT=%lldLL",(long long)L1Obj::DT).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjcLcLTYPE),-1,-2,1,G__FastAllocString(4096).Format("CSC=%lldLL",(long long)L1Obj::CSC).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjcLcLTYPE),-1,-2,1,G__FastAllocString(4096).Format("GMT=%lldLL",(long long)L1Obj::GMT).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjcLcLTYPE),-1,-2,1,G__FastAllocString(4096).Format("RPCb_emu=%lldLL",(long long)L1Obj::RPCb_emu).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjcLcLTYPE),-1,-2,1,G__FastAllocString(4096).Format("RPCf_emu=%lldLL",(long long)L1Obj::RPCf_emu).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjcLcLTYPE),-1,-2,1,G__FastAllocString(4096).Format("GMT_emu=%lldLL",(long long)L1Obj::GMT_emu).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjcLcLTYPE),-1,-2,1,G__FastAllocString(4096).Format("OTF=%lldLL",(long long)L1Obj::OTF).data(),0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->pt)-(long)(p)),102,0,0,-1,-1,-1,1,"pt=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->eta)-(long)(p)),102,0,0,-1,-1,-1,1,"eta=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->phi)-(long)(p)),102,0,0,-1,-1,-1,1,"phi=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->bx)-(long)(p)),105,0,0,-1,-1,-1,1,"bx=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->q)-(long)(p)),105,0,0,-1,-1,-1,1,"q=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->charge)-(long)(p)),105,0,0,-1,-1,-1,1,"charge=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->type)-(long)(p)),105,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjcLcLTYPE),-1,-1,1,"type=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* EventData */
static void G__setup_memvarEventData(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_EventData));
   { EventData *p; p=(EventData*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->weight)-(long)(p)),102,0,0,-1,-1,-1,1,"weight=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->pt)-(long)(p)),102,0,0,-1,-1,-1,1,"pt=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->eta)-(long)(p)),102,0,0,-1,-1,-1,1,"eta=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->phi)-(long)(p)),102,0,0,-1,-1,-1,1,"phi=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->phiHit)-(long)(p)),102,0,0,-1,-1,-1,1,"phiHit=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->etaHit)-(long)(p)),102,0,0,-1,-1,-1,1,"etaHit=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->charge)-(long)(p)),105,0,0,-1,-1,-1,1,"charge=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->l1ObjectsOtf)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEL1ObjcOallocatorlEL1ObjgRsPgR),G__defined_typename("vector<L1Obj>"),-1,1,"l1ObjectsOtf=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->l1ObjectsGmt)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEL1ObjcOallocatorlEL1ObjgRsPgR),G__defined_typename("vector<L1Obj>"),-1,1,"l1ObjectsGmt=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TrackObj */
static void G__setup_memvarTrackObj(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_TrackObj));
   { TrackObj *p; p=(TrackObj*)0x1000; if (p) { }
   G__memvar_setup((void*)0,102,0,0,-1,-1,-1,4,"thePt=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,-1,-1,4,"theEta=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,-1,-1,4,"thePhi=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"theCharge=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* MuonObj */
static void G__setup_memvarMuonObj(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_MuonObj));
   { MuonObj *p; p=(MuonObj*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->nRPCHits)-(long)(p)),104,0,0,-1,-1,-1,1,"nRPCHits=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->nDTHits)-(long)(p)),104,0,0,-1,-1,-1,1,"nDTHits=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->nCSCHits)-(long)(p)),104,0,0,-1,-1,-1,1,"nCSCHits=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->nTrackerHits)-(long)(p)),104,0,0,-1,-1,-1,1,"nTrackerHits=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->nMatchedStations)-(long)(p)),104,0,0,-1,-1,-1,1,"nMatchedStations=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->isUnique)-(long)(p)),103,0,0,-1,-1,-1,1,"isUnique=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->nAllMuons)-(long)(p)),104,0,0,-1,-1,-1,1,"nAllMuons=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"theMuonBits=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* L1ObjColl */
static void G__setup_memvarL1ObjColl(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl));
   { L1ObjColl *p; p=(L1ObjColl*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEL1ObjcOallocatorlEL1ObjgRsPgR),G__defined_typename("vector<L1Obj>"),-1,4,"theL1Obj=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEboolcOallocatorlEboolgRsPgR),G__defined_typename("vector<bool>"),-1,4,"theL1Matching=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"theDeltaR=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* SynchroCountsObj */
static void G__setup_memvarSynchroCountsObj(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_SynchroCountsObj));
   { SynchroCountsObj *p; p=(SynchroCountsObj*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->dccId)-(long)(p)),105,0,0,-1,-1,-1,1,"dccId=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->dccInputChannelNum)-(long)(p)),105,0,0,-1,-1,-1,1,"dccInputChannelNum=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->tbLinkInputNum)-(long)(p)),105,0,0,-1,-1,-1,1,"tbLinkInputNum=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->lbNumInLink)-(long)(p)),105,0,0,-1,-1,-1,1,"lbNumInLink=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->bx)-(long)(p)),105,0,0,-1,-1,-1,1,"bx=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* SynchroCountsObjVect */
static void G__setup_memvarSynchroCountsObjVect(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_SynchroCountsObjVect));
   { SynchroCountsObjVect *p; p=(SynchroCountsObjVect*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->data)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlESynchroCountsObjcOallocatorlESynchroCountsObjgRsPgR),G__defined_typename("vector<SynchroCountsObj>"),-1,1,"data=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* DetCluDigiObj */
static void G__setup_memvarDetCluDigiObj(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_DetCluDigiObj));
   { DetCluDigiObj *p; p=(DetCluDigiObj*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->det)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"det=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->clusterSize)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"clusterSize=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->nDigis)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"nDigis=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* DetCluDigiObjVect */
static void G__setup_memvarDetCluDigiObjVect(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_DetCluDigiObjVect));
   { DetCluDigiObjVect *p; p=(DetCluDigiObjVect*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->data)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEDetCluDigiObjcOallocatorlEDetCluDigiObjgRsPgR),G__defined_typename("vector<DetCluDigiObj>"),-1,1,"data=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TriggerMenuResultObj */
static void G__setup_memvarTriggerMenuResultObj(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_TriggerMenuResultObj));
   { TriggerMenuResultObj *p; p=(TriggerMenuResultObj*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->names)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEstringcOallocatorlEstringgRsPgR),G__defined_typename("vector<std::string>"),-1,1,"names=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->firedAlgos)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),G__defined_typename("vector<unsigned int>"),-1,1,"firedAlgos=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* HitSpecObj */
static void G__setup_memvarHitSpecObj(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_HitSpecObj));
   { HitSpecObj *p; p=(HitSpecObj*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"theRawId=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"pos_x=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"pos_y=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"pos_z=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"mom_x=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"mom_y=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"mom_z=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarrootMAnaDict() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncEventObj(void) {
   /* EventObj */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_EventObj));
   G__memfunc_setup("Class",502,G__rootMAnaDict_168_0_1, 85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&EventObj::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__rootMAnaDict_168_0_2, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&EventObj::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__rootMAnaDict_168_0_3, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&EventObj::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__rootMAnaDict_168_0_4, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&EventObj::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__rootMAnaDict_168_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__rootMAnaDict_168_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&EventObj::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__rootMAnaDict_168_0_10, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&EventObj::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__rootMAnaDict_168_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&EventObj::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__rootMAnaDict_168_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&EventObj::DeclFileLine) ), 0);
   // automatic default constructor
   G__memfunc_setup("EventObj", 797, G__rootMAnaDict_168_0_13, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_EventObj), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("EventObj", 797, G__rootMAnaDict_168_0_14, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_EventObj), -1, 0, 1, 1, 1, 0, "u 'EventObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~EventObj", 923, G__rootMAnaDict_168_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__rootMAnaDict_168_0_16, (int) ('u'), G__get_linked_tagnum(&G__rootMAnaDictLN_EventObj), -1, 1, 1, 1, 1, 0, "u 'EventObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncL1Obj(void) {
   /* L1Obj */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_L1Obj));
   G__memfunc_setup("L1Obj",408,G__rootMAnaDict_169_0_1, 105, G__get_linked_tagnum(&G__rootMAnaDictLN_L1Obj), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("isValid",716,G__rootMAnaDict_169_0_2, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__rootMAnaDict_169_0_3, 85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&L1Obj::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__rootMAnaDict_169_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&L1Obj::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__rootMAnaDict_169_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&L1Obj::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__rootMAnaDict_169_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&L1Obj::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__rootMAnaDict_169_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__rootMAnaDict_169_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&L1Obj::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__rootMAnaDict_169_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&L1Obj::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__rootMAnaDict_169_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&L1Obj::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__rootMAnaDict_169_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&L1Obj::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("L1Obj", 408, G__rootMAnaDict_169_0_15, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_L1Obj), -1, 0, 1, 1, 1, 0, "u 'L1Obj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~L1Obj", 534, G__rootMAnaDict_169_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__rootMAnaDict_169_0_17, (int) ('u'), G__get_linked_tagnum(&G__rootMAnaDictLN_L1Obj), -1, 1, 1, 1, 1, 0, "u 'L1Obj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncEventData(void) {
   /* EventData */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_EventData));
   G__memfunc_setup("EventData",892,G__rootMAnaDict_171_0_1, 105, G__get_linked_tagnum(&G__rootMAnaDictLN_EventData), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__rootMAnaDict_171_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__rootMAnaDict_171_0_3, 85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&EventData::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__rootMAnaDict_171_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&EventData::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__rootMAnaDict_171_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&EventData::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__rootMAnaDict_171_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&EventData::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__rootMAnaDict_171_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__rootMAnaDict_171_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&EventData::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__rootMAnaDict_171_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&EventData::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__rootMAnaDict_171_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&EventData::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__rootMAnaDict_171_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&EventData::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("EventData", 892, G__rootMAnaDict_171_0_15, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_EventData), -1, 0, 1, 1, 1, 0, "u 'EventData' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~EventData", 1018, G__rootMAnaDict_171_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__rootMAnaDict_171_0_17, (int) ('u'), G__get_linked_tagnum(&G__rootMAnaDictLN_EventData), -1, 1, 1, 1, 1, 0, "u 'EventData' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTrackObj(void) {
   /* TrackObj */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_TrackObj));
   G__memfunc_setup("TrackObj",784,G__rootMAnaDict_176_0_1, 105, G__get_linked_tagnum(&G__rootMAnaDictLN_TrackObj), -1, 0, 4, 1, 1, 0, 
"f - - 0 '0.' pt f - - 0 '0.' eta "
"f - - 0 '0.' phi i - - 0 '0' charge", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setKine",723,G__rootMAnaDict_176_0_2, 121, -1, -1, 0, 4, 1, 1, 0, 
"f - - 0 - pt f - - 0 - eta "
"f - - 0 - phi i - - 0 - charge", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pt",228,G__rootMAnaDict_176_0_3, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("eta",314,G__rootMAnaDict_176_0_4, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("phi",321,G__rootMAnaDict_176_0_5, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("charge",618,G__rootMAnaDict_176_0_6, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__rootMAnaDict_176_0_7, 85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TrackObj::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__rootMAnaDict_176_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TrackObj::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__rootMAnaDict_176_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TrackObj::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__rootMAnaDict_176_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TrackObj::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__rootMAnaDict_176_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__rootMAnaDict_176_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TrackObj::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__rootMAnaDict_176_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TrackObj::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__rootMAnaDict_176_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TrackObj::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__rootMAnaDict_176_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TrackObj::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TrackObj", 784, G__rootMAnaDict_176_0_19, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_TrackObj), -1, 0, 1, 1, 1, 0, "u 'TrackObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TrackObj", 910, G__rootMAnaDict_176_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__rootMAnaDict_176_0_21, (int) ('u'), G__get_linked_tagnum(&G__rootMAnaDictLN_TrackObj), -1, 1, 1, 1, 1, 0, "u 'TrackObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncMuonObj(void) {
   /* MuonObj */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_MuonObj));
   G__memfunc_setup("MuonObj",698,G__rootMAnaDict_177_0_1, 105, G__get_linked_tagnum(&G__rootMAnaDictLN_MuonObj), -1, 0, 4, 1, 1, 0, 
"f - - 0 '0.' pt f - - 0 '0.' eta "
"f - - 0 '0.' phi f - - 0 '0.' charge", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setBits",734,G__rootMAnaDict_177_0_2, 121, -1, -1, 0, 5, 1, 1, 0, 
"g - - 0 - isGlobal g - - 0 - isTracker "
"g - - 0 - isOuter g - - 0 - isCalo "
"g - - 0 - isMatched", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("isGlobal",813,G__rootMAnaDict_177_0_3, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("isTracker",936,G__rootMAnaDict_177_0_4, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("isOuter",747,G__rootMAnaDict_177_0_5, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("isCalo",603,G__rootMAnaDict_177_0_6, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("isMatched",914,G__rootMAnaDict_177_0_7, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__rootMAnaDict_177_0_8, 85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&MuonObj::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__rootMAnaDict_177_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&MuonObj::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__rootMAnaDict_177_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&MuonObj::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__rootMAnaDict_177_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&MuonObj::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__rootMAnaDict_177_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__rootMAnaDict_177_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&MuonObj::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__rootMAnaDict_177_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&MuonObj::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__rootMAnaDict_177_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&MuonObj::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__rootMAnaDict_177_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&MuonObj::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("MuonObj", 698, G__rootMAnaDict_177_0_20, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_MuonObj), -1, 0, 1, 1, 1, 0, "u 'MuonObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MuonObj", 824, G__rootMAnaDict_177_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__rootMAnaDict_177_0_22, (int) ('u'), G__get_linked_tagnum(&G__rootMAnaDictLN_MuonObj), -1, 1, 1, 1, 1, 0, "u 'MuonObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncL1ObjColl(void) {
   /* L1ObjColl */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl));
   G__memfunc_setup("L1ObjColl",802,G__rootMAnaDict_179_0_1, 105, G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("set",332,G__rootMAnaDict_179_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<L1Obj,allocator<L1Obj> >' 'vector<L1Obj>' 11 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("set",332,G__rootMAnaDict_179_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<bool,allocator<bool> >' 'vector<bool>' 11 - comp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("set",332,G__rootMAnaDict_179_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - dr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__rootMAnaDict_179_0_5, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'L1Obj' - 11 - obj g - - 0 - match "
"d - - 0 - deltaR", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getL1Objs",843,G__rootMAnaDict_179_0_6, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEL1ObjcOallocatorlEL1ObjgRsPgR), G__defined_typename("vector<L1Obj>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator const std::vector<L1Obj>&",3165,G__rootMAnaDict_179_0_7, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEL1ObjcOallocatorlEL1ObjgRsPgR), G__defined_typename("vector<L1Obj>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getL1ObjsMatching",1654,G__rootMAnaDict_179_0_8, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEboolcOallocatorlEboolgRsPgR), G__defined_typename("vector<bool>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getL1ObjDeltaR",1300,G__rootMAnaDict_179_0_9, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("l1RpcColl",844,G__rootMAnaDict_179_0_10, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("l1RpcCollEmu",1139,G__rootMAnaDict_179_0_11, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("l1OthColl",850,G__rootMAnaDict_179_0_12, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("selectByType",1245,G__rootMAnaDict_179_0_13, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl), -1, 0, 1, 1, 1, 8, "u 'L1Obj::TYPE' 'L1ObjColl::TYPE' 0 - t1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("selectByPt",1023,G__rootMAnaDict_179_0_14, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl), -1, 0, 2, 1, 1, 8, 
"d - - 0 '0.' ptMin d - - 0 '161.' ptMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("selectByPtMin",1315,G__rootMAnaDict_179_0_15, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl), -1, 0, 1, 1, 1, 8, "d - - 0 '0.' ptMin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("selectByEta",1109,G__rootMAnaDict_179_0_16, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl), -1, 0, 2, 1, 1, 8, 
"d - - 0 '-1.61' etaMin d - - 0 '1.61' etaMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("selectByBx",1013,G__rootMAnaDict_179_0_17, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl), -1, 0, 2, 1, 1, 8, 
"i - - 0 '0' bxMin i - - 0 '0' bxMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("selectByQuality",1572,G__rootMAnaDict_179_0_18, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl), -1, 0, 2, 1, 1, 8, 
"i - - 0 '0' qMin i - - 0 '7' qMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("selectByMatched",1521,G__rootMAnaDict_179_0_19, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("selectByDeltaR",1399,G__rootMAnaDict_179_0_20, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl), -1, 0, 1, 1, 1, 8, "d - - 0 - deltaRMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+",919,G__rootMAnaDict_179_0_21, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl), -1, 0, 1, 1, 1, 8, "u 'L1ObjColl' - 11 - o", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator bool",1336,G__rootMAnaDict_179_0_22, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!",909,G__rootMAnaDict_179_0_23, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("isMatching_DRBx_At",1738,G__rootMAnaDict_179_0_24, 103, -1, -1, 0, 5, 1, 1, 8, 
"d - - 0 - deltaR i - - 0 - bx "
"d - - 0 - ptMin d - - 0 - eta "
"d - - 0 - phi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("isMatching_DRBx",1462,G__rootMAnaDict_179_0_25, 103, -1, -1, 0, 3, 1, 1, 8, 
"d - - 0 - deltaR i - - 0 - bx "
"d - - 0 '0.' ptMin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("isMatching_PtminPtmaxBx",2354,G__rootMAnaDict_179_0_26, 103, -1, -1, 0, 4, 1, 1, 8, 
"d - - 0 - ptMin d - - 0 - ptMax "
"i - - 0 - bx g - - 0 - firstBXonly", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getL1ObjsMatched",1537,G__rootMAnaDict_179_0_27, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEL1ObjcOallocatorlEL1ObjgRsPgR), G__defined_typename("vector<L1Obj>"), 0, 1, 1, 1, 8, "d - - 0 '0' ptMin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getL1ObjsSelected",1652,G__rootMAnaDict_179_0_28, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEL1ObjcOallocatorlEL1ObjgRsPgR), G__defined_typename("vector<L1Obj>"), 0, 12, 1, 1, 8, 
"g - - 0 'true' requireMatched g - - 0 'false' requireNonMatched "
"d - - 0 '0.' ptMin d - - 0 '161.' ptMax "
"i - - 0 '0' bxMin i - - 0 '0' bxMax "
"d - - 0 '-2.5' etaMin d - - 0 '2.5' etaMax "
"d - - 0 '0.' phiMin d - - 0 '7.' phiMax "
"i - - 0 '0' qMin i - - 0 '99' qMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("typeSelector",1283,G__rootMAnaDict_179_0_29, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEL1ObjcOallocatorlEL1ObjgRsPgR), G__defined_typename("vector<L1Obj>"), 0, 5, 3, 1, 0, 
"u 'vector<L1Obj,allocator<L1Obj> >' 'vector<L1Obj>' 11 - col u 'L1Obj::TYPE' 'L1ObjColl::TYPE' 0 'L1Obj::NONE' t1 "
"u 'L1Obj::TYPE' 'L1ObjColl::TYPE' 0 'L1Obj::NONE' t2 u 'L1Obj::TYPE' 'L1ObjColl::TYPE' 0 'L1Obj::NONE' t3 "
"u 'L1Obj::TYPE' 'L1ObjColl::TYPE' 0 'L1Obj::NONE' t4", (char*)NULL, (void*) G__func2void( (vector<L1Obj> (*)(const vector<L1Obj>&, L1ObjColl::TYPE, L1ObjColl::TYPE, L1ObjColl::TYPE, L1ObjColl::TYPE))(&L1ObjColl::typeSelector) ), 0);
   G__memfunc_setup("Class",502,G__rootMAnaDict_179_0_30, 85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&L1ObjColl::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__rootMAnaDict_179_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&L1ObjColl::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__rootMAnaDict_179_0_32, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&L1ObjColl::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__rootMAnaDict_179_0_33, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&L1ObjColl::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__rootMAnaDict_179_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__rootMAnaDict_179_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&L1ObjColl::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__rootMAnaDict_179_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&L1ObjColl::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__rootMAnaDict_179_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&L1ObjColl::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__rootMAnaDict_179_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&L1ObjColl::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("L1ObjColl", 802, G__rootMAnaDict_179_0_42, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl), -1, 0, 1, 1, 1, 0, "u 'L1ObjColl' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~L1ObjColl", 928, G__rootMAnaDict_179_0_43, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__rootMAnaDict_179_0_44, (int) ('u'), G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl), -1, 1, 1, 1, 1, 0, "u 'L1ObjColl' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncSynchroCountsObj(void) {
   /* SynchroCountsObj */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_SynchroCountsObj));
   G__memfunc_setup("Class",502,G__rootMAnaDict_180_0_1, 85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&SynchroCountsObj::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__rootMAnaDict_180_0_2, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&SynchroCountsObj::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__rootMAnaDict_180_0_3, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&SynchroCountsObj::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__rootMAnaDict_180_0_4, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&SynchroCountsObj::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__rootMAnaDict_180_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__rootMAnaDict_180_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&SynchroCountsObj::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__rootMAnaDict_180_0_10, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&SynchroCountsObj::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__rootMAnaDict_180_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&SynchroCountsObj::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__rootMAnaDict_180_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&SynchroCountsObj::DeclFileLine) ), 0);
   // automatic default constructor
   G__memfunc_setup("SynchroCountsObj", 1661, G__rootMAnaDict_180_0_13, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_SynchroCountsObj), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("SynchroCountsObj", 1661, G__rootMAnaDict_180_0_14, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_SynchroCountsObj), -1, 0, 1, 1, 1, 0, "u 'SynchroCountsObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~SynchroCountsObj", 1787, G__rootMAnaDict_180_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__rootMAnaDict_180_0_16, (int) ('u'), G__get_linked_tagnum(&G__rootMAnaDictLN_SynchroCountsObj), -1, 1, 1, 1, 1, 0, "u 'SynchroCountsObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncSynchroCountsObjVect(void) {
   /* SynchroCountsObjVect */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_SynchroCountsObjVect));
   G__memfunc_setup("Class",502,G__rootMAnaDict_181_0_1, 85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&SynchroCountsObjVect::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__rootMAnaDict_181_0_2, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&SynchroCountsObjVect::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__rootMAnaDict_181_0_3, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&SynchroCountsObjVect::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__rootMAnaDict_181_0_4, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&SynchroCountsObjVect::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__rootMAnaDict_181_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__rootMAnaDict_181_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&SynchroCountsObjVect::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__rootMAnaDict_181_0_10, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&SynchroCountsObjVect::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__rootMAnaDict_181_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&SynchroCountsObjVect::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__rootMAnaDict_181_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&SynchroCountsObjVect::DeclFileLine) ), 0);
   // automatic default constructor
   G__memfunc_setup("SynchroCountsObjVect", 2063, G__rootMAnaDict_181_0_13, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_SynchroCountsObjVect), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("SynchroCountsObjVect", 2063, G__rootMAnaDict_181_0_14, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_SynchroCountsObjVect), -1, 0, 1, 1, 1, 0, "u 'SynchroCountsObjVect' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~SynchroCountsObjVect", 2189, G__rootMAnaDict_181_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__rootMAnaDict_181_0_16, (int) ('u'), G__get_linked_tagnum(&G__rootMAnaDictLN_SynchroCountsObjVect), -1, 1, 1, 1, 1, 0, "u 'SynchroCountsObjVect' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncDetCluDigiObj(void) {
   /* DetCluDigiObj */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_DetCluDigiObj));
   G__memfunc_setup("Class",502,G__rootMAnaDict_186_0_1, 85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&DetCluDigiObj::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__rootMAnaDict_186_0_2, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&DetCluDigiObj::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__rootMAnaDict_186_0_3, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&DetCluDigiObj::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__rootMAnaDict_186_0_4, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&DetCluDigiObj::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__rootMAnaDict_186_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__rootMAnaDict_186_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&DetCluDigiObj::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__rootMAnaDict_186_0_10, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&DetCluDigiObj::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__rootMAnaDict_186_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&DetCluDigiObj::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__rootMAnaDict_186_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&DetCluDigiObj::DeclFileLine) ), 0);
   // automatic default constructor
   G__memfunc_setup("DetCluDigiObj", 1241, G__rootMAnaDict_186_0_13, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_DetCluDigiObj), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("DetCluDigiObj", 1241, G__rootMAnaDict_186_0_14, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_DetCluDigiObj), -1, 0, 1, 1, 1, 0, "u 'DetCluDigiObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~DetCluDigiObj", 1367, G__rootMAnaDict_186_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__rootMAnaDict_186_0_16, (int) ('u'), G__get_linked_tagnum(&G__rootMAnaDictLN_DetCluDigiObj), -1, 1, 1, 1, 1, 0, "u 'DetCluDigiObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncDetCluDigiObjVect(void) {
   /* DetCluDigiObjVect */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_DetCluDigiObjVect));
   G__memfunc_setup("Class",502,G__rootMAnaDict_187_0_1, 85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&DetCluDigiObjVect::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__rootMAnaDict_187_0_2, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&DetCluDigiObjVect::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__rootMAnaDict_187_0_3, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&DetCluDigiObjVect::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__rootMAnaDict_187_0_4, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&DetCluDigiObjVect::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__rootMAnaDict_187_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__rootMAnaDict_187_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&DetCluDigiObjVect::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__rootMAnaDict_187_0_10, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&DetCluDigiObjVect::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__rootMAnaDict_187_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&DetCluDigiObjVect::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__rootMAnaDict_187_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&DetCluDigiObjVect::DeclFileLine) ), 0);
   // automatic default constructor
   G__memfunc_setup("DetCluDigiObjVect", 1643, G__rootMAnaDict_187_0_13, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_DetCluDigiObjVect), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("DetCluDigiObjVect", 1643, G__rootMAnaDict_187_0_14, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_DetCluDigiObjVect), -1, 0, 1, 1, 1, 0, "u 'DetCluDigiObjVect' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~DetCluDigiObjVect", 1769, G__rootMAnaDict_187_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__rootMAnaDict_187_0_16, (int) ('u'), G__get_linked_tagnum(&G__rootMAnaDictLN_DetCluDigiObjVect), -1, 1, 1, 1, 1, 0, "u 'DetCluDigiObjVect' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTriggerMenuResultObj(void) {
   /* TriggerMenuResultObj */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_TriggerMenuResultObj));
   G__memfunc_setup("Class",502,G__rootMAnaDict_192_0_1, 85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TriggerMenuResultObj::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__rootMAnaDict_192_0_2, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TriggerMenuResultObj::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__rootMAnaDict_192_0_3, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TriggerMenuResultObj::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__rootMAnaDict_192_0_4, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TriggerMenuResultObj::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__rootMAnaDict_192_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__rootMAnaDict_192_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TriggerMenuResultObj::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__rootMAnaDict_192_0_10, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TriggerMenuResultObj::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__rootMAnaDict_192_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TriggerMenuResultObj::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__rootMAnaDict_192_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TriggerMenuResultObj::DeclFileLine) ), 0);
   // automatic default constructor
   G__memfunc_setup("TriggerMenuResultObj", 2051, G__rootMAnaDict_192_0_13, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_TriggerMenuResultObj), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TriggerMenuResultObj", 2051, G__rootMAnaDict_192_0_14, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_TriggerMenuResultObj), -1, 0, 1, 1, 1, 0, "u 'TriggerMenuResultObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TriggerMenuResultObj", 2177, G__rootMAnaDict_192_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__rootMAnaDict_192_0_16, (int) ('u'), G__get_linked_tagnum(&G__rootMAnaDictLN_TriggerMenuResultObj), -1, 1, 1, 1, 1, 0, "u 'TriggerMenuResultObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncHitSpecObj(void) {
   /* HitSpecObj */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_HitSpecObj));
   G__memfunc_setup("HitSpecObj",971,G__rootMAnaDict_234_0_1, 105, G__get_linked_tagnum(&G__rootMAnaDictLN_HitSpecObj), -1, 0, 3, 5, 1, 0, 
"h - - 0 '0' id u 'Point3DBase<float,GlobalTag>' 'GlobalPoint' 11 'GlobalPoint()' pos "
"u 'Vector3DBase<float,GlobalTag>' 'GlobalVector' 11 'GlobalVector()' mom", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rawId",503,G__rootMAnaDict_234_0_2, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("position",885,G__rootMAnaDict_234_0_3, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_Point3DBaselEfloatcOGlobalTaggR), G__defined_typename("GlobalPoint"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("momentum",882,G__rootMAnaDict_234_0_4, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_Vector3DBaselEfloatcOGlobalTaggR), G__defined_typename("GlobalVector"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__rootMAnaDict_234_0_5, 85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&HitSpecObj::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__rootMAnaDict_234_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&HitSpecObj::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__rootMAnaDict_234_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&HitSpecObj::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__rootMAnaDict_234_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&HitSpecObj::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__rootMAnaDict_234_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__rootMAnaDict_234_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&HitSpecObj::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__rootMAnaDict_234_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&HitSpecObj::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__rootMAnaDict_234_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&HitSpecObj::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__rootMAnaDict_234_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&HitSpecObj::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("HitSpecObj", 971, G__rootMAnaDict_234_0_17, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_HitSpecObj), -1, 0, 1, 1, 1, 0, "u 'HitSpecObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~HitSpecObj", 1097, G__rootMAnaDict_234_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__rootMAnaDict_234_0_19, (int) ('u'), G__get_linked_tagnum(&G__rootMAnaDictLN_HitSpecObj), -1, 1, 1, 1, 1, 0, "u 'HitSpecObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}


/*********************************************************
* Member function information setup
*********************************************************/
extern "C" void G__cpp_setup_memfuncrootMAnaDict() {
}

/*********************************************************
* Global variable information setup for each class
*********************************************************/
static void G__cpp_setup_global0() {

   /* Setting up global variables */
   G__resetplocal();

}

static void G__cpp_setup_global1() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalrootMAnaDict() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {
}

static void G__cpp_setup_func4() {
}

static void G__cpp_setup_func5() {
}

static void G__cpp_setup_func6() {
}

static void G__cpp_setup_func7() {
}

static void G__cpp_setup_func8() {
}

static void G__cpp_setup_func9() {
}

static void G__cpp_setup_func10() {
}

static void G__cpp_setup_func11() {
}

static void G__cpp_setup_func12() {
}

static void G__cpp_setup_func13() {
}

static void G__cpp_setup_func14() {
}

static void G__cpp_setup_func15() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcrootMAnaDict() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
  G__cpp_setup_func5();
  G__cpp_setup_func6();
  G__cpp_setup_func7();
  G__cpp_setup_func8();
  G__cpp_setup_func9();
  G__cpp_setup_func10();
  G__cpp_setup_func11();
  G__cpp_setup_func12();
  G__cpp_setup_func13();
  G__cpp_setup_func14();
  G__cpp_setup_func15();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__rootMAnaDictLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_vectorlEboolcOallocatorlEboolgRsPgR = { "vector<bool,allocator<bool> >" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_EventObj = { "EventObj" , 115 , -1 };
G__linked_taginfo G__rootMAnaDictLN_L1Obj = { "L1Obj" , 115 , -1 };
G__linked_taginfo G__rootMAnaDictLN_L1ObjcLcLTYPE = { "L1Obj::TYPE" , 101 , -1 };
G__linked_taginfo G__rootMAnaDictLN_EventData = { "EventData" , 115 , -1 };
G__linked_taginfo G__rootMAnaDictLN_vectorlEL1ObjcOallocatorlEL1ObjgRsPgR = { "vector<L1Obj,allocator<L1Obj> >" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_reverse_iteratorlEvectorlEL1ObjcOallocatorlEL1ObjgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<L1Obj,allocator<L1Obj> >::iterator>" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_TrackObj = { "TrackObj" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_MuonObj = { "MuonObj" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_L1ObjColl = { "L1ObjColl" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_SynchroCountsObj = { "SynchroCountsObj" , 115 , -1 };
G__linked_taginfo G__rootMAnaDictLN_SynchroCountsObjVect = { "SynchroCountsObjVect" , 115 , -1 };
G__linked_taginfo G__rootMAnaDictLN_vectorlESynchroCountsObjcOallocatorlESynchroCountsObjgRsPgR = { "vector<SynchroCountsObj,allocator<SynchroCountsObj> >" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_reverse_iteratorlEvectorlESynchroCountsObjcOallocatorlESynchroCountsObjgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<SynchroCountsObj,allocator<SynchroCountsObj> >::iterator>" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_DetCluDigiObj = { "DetCluDigiObj" , 115 , -1 };
G__linked_taginfo G__rootMAnaDictLN_DetCluDigiObjVect = { "DetCluDigiObjVect" , 115 , -1 };
G__linked_taginfo G__rootMAnaDictLN_vectorlEDetCluDigiObjcOallocatorlEDetCluDigiObjgRsPgR = { "vector<DetCluDigiObj,allocator<DetCluDigiObj> >" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_reverse_iteratorlEvectorlEDetCluDigiObjcOallocatorlEDetCluDigiObjgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<DetCluDigiObj,allocator<DetCluDigiObj> >::iterator>" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_TriggerMenuResultObj = { "TriggerMenuResultObj" , 115 , -1 };
G__linked_taginfo G__rootMAnaDictLN_vectorlEstringcOallocatorlEstringgRsPgR = { "vector<string,allocator<string> >" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<string,allocator<string> >::iterator>" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_Point3DBaselEfloatcOGlobalTaggR = { "Point3DBase<float,GlobalTag>" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_Vector3DBaselEfloatcOGlobalTaggR = { "Vector3DBase<float,GlobalTag>" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_HitSpecObj = { "HitSpecObj" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtablerootMAnaDict() {
  G__rootMAnaDictLN_TClass.tagnum = -1 ;
  G__rootMAnaDictLN_TBuffer.tagnum = -1 ;
  G__rootMAnaDictLN_TMemberInspector.tagnum = -1 ;
  G__rootMAnaDictLN_TObject.tagnum = -1 ;
  G__rootMAnaDictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
  G__rootMAnaDictLN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
  G__rootMAnaDictLN_vectorlEboolcOallocatorlEboolgRsPgR.tagnum = -1 ;
  G__rootMAnaDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__rootMAnaDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__rootMAnaDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__rootMAnaDictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__rootMAnaDictLN_EventObj.tagnum = -1 ;
  G__rootMAnaDictLN_L1Obj.tagnum = -1 ;
  G__rootMAnaDictLN_L1ObjcLcLTYPE.tagnum = -1 ;
  G__rootMAnaDictLN_EventData.tagnum = -1 ;
  G__rootMAnaDictLN_vectorlEL1ObjcOallocatorlEL1ObjgRsPgR.tagnum = -1 ;
  G__rootMAnaDictLN_reverse_iteratorlEvectorlEL1ObjcOallocatorlEL1ObjgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__rootMAnaDictLN_TrackObj.tagnum = -1 ;
  G__rootMAnaDictLN_MuonObj.tagnum = -1 ;
  G__rootMAnaDictLN_L1ObjColl.tagnum = -1 ;
  G__rootMAnaDictLN_SynchroCountsObj.tagnum = -1 ;
  G__rootMAnaDictLN_SynchroCountsObjVect.tagnum = -1 ;
  G__rootMAnaDictLN_vectorlESynchroCountsObjcOallocatorlESynchroCountsObjgRsPgR.tagnum = -1 ;
  G__rootMAnaDictLN_reverse_iteratorlEvectorlESynchroCountsObjcOallocatorlESynchroCountsObjgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__rootMAnaDictLN_DetCluDigiObj.tagnum = -1 ;
  G__rootMAnaDictLN_DetCluDigiObjVect.tagnum = -1 ;
  G__rootMAnaDictLN_vectorlEDetCluDigiObjcOallocatorlEDetCluDigiObjgRsPgR.tagnum = -1 ;
  G__rootMAnaDictLN_reverse_iteratorlEvectorlEDetCluDigiObjcOallocatorlEDetCluDigiObjgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__rootMAnaDictLN_TriggerMenuResultObj.tagnum = -1 ;
  G__rootMAnaDictLN_vectorlEstringcOallocatorlEstringgRsPgR.tagnum = -1 ;
  G__rootMAnaDictLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__rootMAnaDictLN_Point3DBaselEfloatcOGlobalTaggR.tagnum = -1 ;
  G__rootMAnaDictLN_Vector3DBaselEfloatcOGlobalTaggR.tagnum = -1 ;
  G__rootMAnaDictLN_HitSpecObj.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtablerootMAnaDict() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_TClass);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_TObject);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_vectorlEdoublecOallocatorlEdoublegRsPgR);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_vectorlEboolcOallocatorlEboolgRsPgR);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_EventObj),sizeof(EventObj),-1,28672,(char*)NULL,G__setup_memvarEventObj,G__setup_memfuncEventObj);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_L1Obj),sizeof(L1Obj),-1,28928,(char*)NULL,G__setup_memvarL1Obj,G__setup_memfuncL1Obj);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_L1ObjcLcLTYPE);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_EventData),sizeof(EventData),-1,29952,(char*)NULL,G__setup_memvarEventData,G__setup_memfuncEventData);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_vectorlEL1ObjcOallocatorlEL1ObjgRsPgR);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_reverse_iteratorlEvectorlEL1ObjcOallocatorlEL1ObjgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_TrackObj),sizeof(TrackObj),-1,29952,(char*)NULL,G__setup_memvarTrackObj,G__setup_memfuncTrackObj);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_MuonObj),sizeof(MuonObj),-1,29952,(char*)NULL,G__setup_memvarMuonObj,G__setup_memfuncMuonObj);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_L1ObjColl),sizeof(L1ObjColl),-1,29952,(char*)NULL,G__setup_memvarL1ObjColl,G__setup_memfuncL1ObjColl);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_SynchroCountsObj),sizeof(SynchroCountsObj),-1,28672,(char*)NULL,G__setup_memvarSynchroCountsObj,G__setup_memfuncSynchroCountsObj);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_SynchroCountsObjVect),sizeof(SynchroCountsObjVect),-1,28672,(char*)NULL,G__setup_memvarSynchroCountsObjVect,G__setup_memfuncSynchroCountsObjVect);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_vectorlESynchroCountsObjcOallocatorlESynchroCountsObjgRsPgR);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_reverse_iteratorlEvectorlESynchroCountsObjcOallocatorlESynchroCountsObjgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_DetCluDigiObj),sizeof(DetCluDigiObj),-1,28672,(char*)NULL,G__setup_memvarDetCluDigiObj,G__setup_memfuncDetCluDigiObj);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_DetCluDigiObjVect),sizeof(DetCluDigiObjVect),-1,28672,(char*)NULL,G__setup_memvarDetCluDigiObjVect,G__setup_memfuncDetCluDigiObjVect);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_vectorlEDetCluDigiObjcOallocatorlEDetCluDigiObjgRsPgR);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_reverse_iteratorlEvectorlEDetCluDigiObjcOallocatorlEDetCluDigiObjgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_TriggerMenuResultObj),sizeof(TriggerMenuResultObj),-1,28672,(char*)NULL,G__setup_memvarTriggerMenuResultObj,G__setup_memfuncTriggerMenuResultObj);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_vectorlEstringcOallocatorlEstringgRsPgR);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_Point3DBaselEfloatcOGlobalTaggR);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_Vector3DBaselEfloatcOGlobalTaggR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_HitSpecObj),sizeof(HitSpecObj),-1,28928,(char*)NULL,G__setup_memvarHitSpecObj,G__setup_memfuncHitSpecObj);
}
extern "C" void G__cpp_setuprootMAnaDict(void) {
  G__check_setup_version(30051515,"G__cpp_setuprootMAnaDict()");
  G__set_cpp_environmentrootMAnaDict();
  G__cpp_setup_tagtablerootMAnaDict();

  G__cpp_setup_inheritancerootMAnaDict();

  G__cpp_setup_typetablerootMAnaDict();

  G__cpp_setup_memvarrootMAnaDict();

  G__cpp_setup_memfuncrootMAnaDict();
  G__cpp_setup_globalrootMAnaDict();
  G__cpp_setup_funcrootMAnaDict();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncrootMAnaDict();
  return;
}
class G__cpp_setup_initrootMAnaDict {
  public:
    G__cpp_setup_initrootMAnaDict() { G__add_setup_func("rootMAnaDict",(G__incsetup)(&G__cpp_setuprootMAnaDict)); G__call_setup_funcs(); }
   ~G__cpp_setup_initrootMAnaDict() { G__remove_setup_func("rootMAnaDict"); }
};
G__cpp_setup_initrootMAnaDict G__cpp_setup_initializerrootMAnaDict;

Revision:	1.18
Committed:	Thu Jul 11 11:25:22 2013 UTC (11 years, 9 months ago) by akalinow
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Artur_11_07_2013_B, Artur_11_07_2013_A, Artur_11_07_2013, HEAD
Changes since 1.17:	+1039 -623 lines
Log Message:	*last commit before migration to Git.