// Do NOT change. Changes will be lost next time file is generated #define R__DICTIONARY_FILENAME DCEEvent_dict #define R__NO_DEPRECATION /*******************************************************************/ #include #include #include #include #include #define G__DICTIONARY #include "ROOT/RConfig.hxx" #include "TClass.h" #include "TDictAttributeMap.h" #include "TInterpreter.h" #include "TROOT.h" #include "TBuffer.h" #include "TMemberInspector.h" #include "TInterpreter.h" #include "TVirtualMutex.h" #include "TError.h" #ifndef G__ROOT #define G__ROOT #endif #include "RtypesImp.h" #include "TIsAProxy.h" #include "TFileMergeInfo.h" #include #include "TCollectionProxyInfo.h" /*******************************************************************/ #include "TDataMember.h" // Header files passed as explicit arguments #include "DCEEvent.hh" // Header files passed via #pragma extra_include // The generated code does not explicitly qualify STL entities namespace std {} using namespace std; namespace EUpp { namespace ROOTDict { inline ::ROOT::TGenericClassInfo *GenerateInitInstance(); static TClass *EUpp_Dictionary(); // Function generating the singleton type initializer inline ::ROOT::TGenericClassInfo *GenerateInitInstance() { static ::ROOT::TGenericClassInfo instance("EUpp", 0 /*version*/, "DCELightEUpp.hh", 16, ::ROOT::Internal::DefineBehavior((void*)nullptr,(void*)nullptr), &EUpp_Dictionary, 0); return &instance; } // Insure that the inline function is _not_ optimized away by the compiler ::ROOT::TGenericClassInfo *(*_R__UNIQUE_DICT_(InitFunctionKeeper))() = &GenerateInitInstance; // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *EUpp_Dictionary() { return GenerateInitInstance()->GetClass(); } } } namespace ROOT { static void *new_ParamStore(void *p = nullptr); static void *newArray_ParamStore(Long_t size, void *p); static void delete_ParamStore(void *p); static void deleteArray_ParamStore(void *p); static void destruct_ParamStore(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::ParamStore*) { ::ParamStore *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::ParamStore >(nullptr); static ::ROOT::TGenericClassInfo instance("ParamStore", ::ParamStore::Class_Version(), "DCEParamStore.hh", 22, typeid(::ParamStore), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::ParamStore::Dictionary, isa_proxy, 4, sizeof(::ParamStore) ); instance.SetNew(&new_ParamStore); instance.SetNewArray(&newArray_ParamStore); instance.SetDelete(&delete_ParamStore); instance.SetDeleteArray(&deleteArray_ParamStore); instance.SetDestructor(&destruct_ParamStore); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::ParamStore*) { return GenerateInitInstanceLocal(static_cast<::ParamStore*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static TClass *IProcess_Dictionary(); static void IProcess_TClassManip(TClass*); static void delete_IProcess(void *p); static void deleteArray_IProcess(void *p); static void destruct_IProcess(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::IProcess*) { ::IProcess *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IProcess)); static ::ROOT::TGenericClassInfo instance("IProcess", "DCEIProcess.hh", 18, typeid(::IProcess), ::ROOT::Internal::DefineBehavior(ptr, ptr), &IProcess_Dictionary, isa_proxy, 4, sizeof(::IProcess) ); instance.SetDelete(&delete_IProcess); instance.SetDeleteArray(&deleteArray_IProcess); instance.SetDestructor(&destruct_IProcess); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::IProcess*) { return GenerateInitInstanceLocal(static_cast<::IProcess*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *IProcess_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); IProcess_TClassManip(theClass); return theClass; } static void IProcess_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static void *new_InfoUnit(void *p = nullptr); static void *newArray_InfoUnit(Long_t size, void *p); static void delete_InfoUnit(void *p); static void deleteArray_InfoUnit(void *p); static void destruct_InfoUnit(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::InfoUnit*) { ::InfoUnit *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::InfoUnit >(nullptr); static ::ROOT::TGenericClassInfo instance("InfoUnit", ::InfoUnit::Class_Version(), "DCEInfoUnit.hh", 20, typeid(::InfoUnit), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::InfoUnit::Dictionary, isa_proxy, 4, sizeof(::InfoUnit) ); instance.SetNew(&new_InfoUnit); instance.SetNewArray(&newArray_InfoUnit); instance.SetDelete(&delete_InfoUnit); instance.SetDeleteArray(&deleteArray_InfoUnit); instance.SetDestructor(&destruct_InfoUnit); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::InfoUnit*) { return GenerateInitInstanceLocal(static_cast<::InfoUnit*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static TClass *Processor_Dictionary(); static void Processor_TClassManip(TClass*); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::Processor*) { ::Processor *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Processor)); static ::ROOT::TGenericClassInfo instance("Processor", "DCEProcessor.hh", 30, typeid(::Processor), ::ROOT::Internal::DefineBehavior(ptr, ptr), &Processor_Dictionary, isa_proxy, 4, sizeof(::Processor) ); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::Processor*) { return GenerateInitInstanceLocal(static_cast<::Processor*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *Processor_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); Processor_TClassManip(theClass); return theClass; } static void Processor_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *LoopProcessor_Dictionary(); static void LoopProcessor_TClassManip(TClass*); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::LoopProcessor*) { ::LoopProcessor *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::LoopProcessor)); static ::ROOT::TGenericClassInfo instance("LoopProcessor", "DCELoopProcessor.hh", 27, typeid(::LoopProcessor), ::ROOT::Internal::DefineBehavior(ptr, ptr), &LoopProcessor_Dictionary, isa_proxy, 4, sizeof(::LoopProcessor) ); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::LoopProcessor*) { return GenerateInitInstanceLocal(static_cast<::LoopProcessor*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *LoopProcessor_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); LoopProcessor_TClassManip(theClass); return theClass; } static void LoopProcessor_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static void *new_PMTHit(void *p = nullptr); static void *newArray_PMTHit(Long_t size, void *p); static void delete_PMTHit(void *p); static void deleteArray_PMTHit(void *p); static void destruct_PMTHit(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::PMTHit*) { ::PMTHit *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::PMTHit >(nullptr); static ::ROOT::TGenericClassInfo instance("PMTHit", ::PMTHit::Class_Version(), "DCEPMTHit.hh", 18, typeid(::PMTHit), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::PMTHit::Dictionary, isa_proxy, 4, sizeof(::PMTHit) ); instance.SetNew(&new_PMTHit); instance.SetNewArray(&newArray_PMTHit); instance.SetDelete(&delete_PMTHit); instance.SetDeleteArray(&deleteArray_PMTHit); instance.SetDestructor(&destruct_PMTHit); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::PMTHit*) { return GenerateInitInstanceLocal(static_cast<::PMTHit*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_ParameterInfo(void *p = nullptr); static void *newArray_ParameterInfo(Long_t size, void *p); static void delete_ParameterInfo(void *p); static void deleteArray_ParameterInfo(void *p); static void destruct_ParameterInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::ParameterInfo*) { ::ParameterInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::ParameterInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("ParameterInfo", ::ParameterInfo::Class_Version(), "DCEParameterInfo.hh", 21, typeid(::ParameterInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::ParameterInfo::Dictionary, isa_proxy, 4, sizeof(::ParameterInfo) ); instance.SetNew(&new_ParameterInfo); instance.SetNewArray(&newArray_ParameterInfo); instance.SetDelete(&delete_ParameterInfo); instance.SetDeleteArray(&deleteArray_ParameterInfo); instance.SetDestructor(&destruct_ParameterInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::ParameterInfo*) { return GenerateInitInstanceLocal(static_cast<::ParameterInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_OVHit(void *p = nullptr); static void *newArray_OVHit(Long_t size, void *p); static void delete_OVHit(void *p); static void deleteArray_OVHit(void *p); static void destruct_OVHit(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OVHit*) { ::OVHit *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::OVHit >(nullptr); static ::ROOT::TGenericClassInfo instance("OVHit", ::OVHit::Class_Version(), "DCEOVHit.hh", 33, typeid(::OVHit), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::OVHit::Dictionary, isa_proxy, 4, sizeof(::OVHit) ); instance.SetNew(&new_OVHit); instance.SetNewArray(&newArray_OVHit); instance.SetDelete(&delete_OVHit); instance.SetDeleteArray(&deleteArray_OVHit); instance.SetDestructor(&destruct_OVHit); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OVHit*) { return GenerateInitInstanceLocal(static_cast<::OVHit*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_OVInfo(void *p = nullptr); static void *newArray_OVInfo(Long_t size, void *p); static void delete_OVInfo(void *p); static void deleteArray_OVInfo(void *p); static void destruct_OVInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OVInfo*) { ::OVInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::OVInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("OVInfo", ::OVInfo::Class_Version(), "DCEOVInfo.hh", 24, typeid(::OVInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::OVInfo::Dictionary, isa_proxy, 4, sizeof(::OVInfo) ); instance.SetNew(&new_OVInfo); instance.SetNewArray(&newArray_OVInfo); instance.SetDelete(&delete_OVInfo); instance.SetDeleteArray(&deleteArray_OVInfo); instance.SetDestructor(&destruct_OVInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OVInfo*) { return GenerateInitInstanceLocal(static_cast<::OVInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_OVCell(void *p = nullptr); static void *newArray_OVCell(Long_t size, void *p); static void delete_OVCell(void *p); static void deleteArray_OVCell(void *p); static void destruct_OVCell(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OVCell*) { ::OVCell *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::OVCell >(nullptr); static ::ROOT::TGenericClassInfo instance("OVCell", ::OVCell::Class_Version(), "DCEOVInfo.hh", 51, typeid(::OVCell), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::OVCell::Dictionary, isa_proxy, 4, sizeof(::OVCell) ); instance.SetNew(&new_OVCell); instance.SetNewArray(&newArray_OVCell); instance.SetDelete(&delete_OVCell); instance.SetDeleteArray(&deleteArray_OVCell); instance.SetDestructor(&destruct_OVCell); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OVCell*) { return GenerateInitInstanceLocal(static_cast<::OVCell*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static TClass *FileDB_Dictionary(); static void FileDB_TClassManip(TClass*); static void *new_FileDB(void *p = nullptr); static void *newArray_FileDB(Long_t size, void *p); static void delete_FileDB(void *p); static void deleteArray_FileDB(void *p); static void destruct_FileDB(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::FileDB*) { ::FileDB *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::FileDB)); static ::ROOT::TGenericClassInfo instance("FileDB", "DCEFileDB.hh", 48, typeid(::FileDB), ::ROOT::Internal::DefineBehavior(ptr, ptr), &FileDB_Dictionary, isa_proxy, 4, sizeof(::FileDB) ); instance.SetNew(&new_FileDB); instance.SetNewArray(&newArray_FileDB); instance.SetDelete(&delete_FileDB); instance.SetDeleteArray(&deleteArray_FileDB); instance.SetDestructor(&destruct_FileDB); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::FileDB*) { return GenerateInitInstanceLocal(static_cast<::FileDB*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *FileDB_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); FileDB_TClassManip(theClass); return theClass; } static void FileDB_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static TClass *InfoIO_Dictionary(); static void InfoIO_TClassManip(TClass*); static void *new_InfoIO(void *p = nullptr); static void *newArray_InfoIO(Long_t size, void *p); static void delete_InfoIO(void *p); static void deleteArray_InfoIO(void *p); static void destruct_InfoIO(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::InfoIO*) { ::InfoIO *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::InfoIO)); static ::ROOT::TGenericClassInfo instance("InfoIO", "DCEInfoIO.hh", 37, typeid(::InfoIO), ::ROOT::Internal::DefineBehavior(ptr, ptr), &InfoIO_Dictionary, isa_proxy, 4, sizeof(::InfoIO) ); instance.SetNew(&new_InfoIO); instance.SetNewArray(&newArray_InfoIO); instance.SetDelete(&delete_InfoIO); instance.SetDeleteArray(&deleteArray_InfoIO); instance.SetDestructor(&destruct_InfoIO); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::InfoIO*) { return GenerateInitInstanceLocal(static_cast<::InfoIO*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *InfoIO_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); InfoIO_TClassManip(theClass); return theClass; } static void InfoIO_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static void *new_GlobalInfo(void *p = nullptr); static void *newArray_GlobalInfo(Long_t size, void *p); static void delete_GlobalInfo(void *p); static void deleteArray_GlobalInfo(void *p); static void destruct_GlobalInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::GlobalInfo*) { ::GlobalInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::GlobalInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("GlobalInfo", ::GlobalInfo::Class_Version(), "DCEGlobalInfo.hh", 26, typeid(::GlobalInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::GlobalInfo::Dictionary, isa_proxy, 4, sizeof(::GlobalInfo) ); instance.SetNew(&new_GlobalInfo); instance.SetNewArray(&newArray_GlobalInfo); instance.SetDelete(&delete_GlobalInfo); instance.SetDeleteArray(&deleteArray_GlobalInfo); instance.SetDestructor(&destruct_GlobalInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::GlobalInfo*) { return GenerateInitInstanceLocal(static_cast<::GlobalInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_GlobalThInfo(void *p = nullptr); static void *newArray_GlobalThInfo(Long_t size, void *p); static void delete_GlobalThInfo(void *p); static void deleteArray_GlobalThInfo(void *p); static void destruct_GlobalThInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::GlobalThInfo*) { ::GlobalThInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::GlobalThInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("GlobalThInfo", ::GlobalThInfo::Class_Version(), "DCEGlobalThInfo.hh", 21, typeid(::GlobalThInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::GlobalThInfo::Dictionary, isa_proxy, 4, sizeof(::GlobalThInfo) ); instance.SetNew(&new_GlobalThInfo); instance.SetNewArray(&newArray_GlobalThInfo); instance.SetDelete(&delete_GlobalThInfo); instance.SetDeleteArray(&deleteArray_GlobalThInfo); instance.SetDestructor(&destruct_GlobalThInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::GlobalThInfo*) { return GenerateInitInstanceLocal(static_cast<::GlobalThInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_PulseInfo(void *p = nullptr); static void *newArray_PulseInfo(Long_t size, void *p); static void delete_PulseInfo(void *p); static void deleteArray_PulseInfo(void *p); static void destruct_PulseInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::PulseInfo*) { ::PulseInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::PulseInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("PulseInfo", ::PulseInfo::Class_Version(), "DCEPulseInfo.hh", 26, typeid(::PulseInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::PulseInfo::Dictionary, isa_proxy, 4, sizeof(::PulseInfo) ); instance.SetNew(&new_PulseInfo); instance.SetNewArray(&newArray_PulseInfo); instance.SetDelete(&delete_PulseInfo); instance.SetDeleteArray(&deleteArray_PulseInfo); instance.SetDestructor(&destruct_PulseInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::PulseInfo*) { return GenerateInitInstanceLocal(static_cast<::PulseInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_PulsePeakWinInfo(void *p = nullptr); static void *newArray_PulsePeakWinInfo(Long_t size, void *p); static void delete_PulsePeakWinInfo(void *p); static void deleteArray_PulsePeakWinInfo(void *p); static void destruct_PulsePeakWinInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::PulsePeakWinInfo*) { ::PulsePeakWinInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::PulsePeakWinInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("PulsePeakWinInfo", ::PulsePeakWinInfo::Class_Version(), "DCEPulsePeakWinInfo.hh", 18, typeid(::PulsePeakWinInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::PulsePeakWinInfo::Dictionary, isa_proxy, 4, sizeof(::PulsePeakWinInfo) ); instance.SetNew(&new_PulsePeakWinInfo); instance.SetNewArray(&newArray_PulsePeakWinInfo); instance.SetDelete(&delete_PulsePeakWinInfo); instance.SetDeleteArray(&deleteArray_PulsePeakWinInfo); instance.SetDestructor(&destruct_PulsePeakWinInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::PulsePeakWinInfo*) { return GenerateInitInstanceLocal(static_cast<::PulsePeakWinInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_PulseSlideWinInfo(void *p = nullptr); static void *newArray_PulseSlideWinInfo(Long_t size, void *p); static void delete_PulseSlideWinInfo(void *p); static void deleteArray_PulseSlideWinInfo(void *p); static void destruct_PulseSlideWinInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::PulseSlideWinInfo*) { ::PulseSlideWinInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::PulseSlideWinInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("PulseSlideWinInfo", ::PulseSlideWinInfo::Class_Version(), "DCEPulseSlideWinInfo.hh", 19, typeid(::PulseSlideWinInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::PulseSlideWinInfo::Dictionary, isa_proxy, 4, sizeof(::PulseSlideWinInfo) ); instance.SetNew(&new_PulseSlideWinInfo); instance.SetNewArray(&newArray_PulseSlideWinInfo); instance.SetDelete(&delete_PulseSlideWinInfo); instance.SetDeleteArray(&deleteArray_PulseSlideWinInfo); instance.SetDestructor(&destruct_PulseSlideWinInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::PulseSlideWinInfo*) { return GenerateInitInstanceLocal(static_cast<::PulseSlideWinInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_PulseThInfo(void *p = nullptr); static void *newArray_PulseThInfo(Long_t size, void *p); static void delete_PulseThInfo(void *p); static void deleteArray_PulseThInfo(void *p); static void destruct_PulseThInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::PulseThInfo*) { ::PulseThInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::PulseThInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("PulseThInfo", ::PulseThInfo::Class_Version(), "DCEPulseThInfo.hh", 19, typeid(::PulseThInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::PulseThInfo::Dictionary, isa_proxy, 4, sizeof(::PulseThInfo) ); instance.SetNew(&new_PulseThInfo); instance.SetNewArray(&newArray_PulseThInfo); instance.SetDelete(&delete_PulseThInfo); instance.SetDeleteArray(&deleteArray_PulseThInfo); instance.SetDestructor(&destruct_PulseThInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::PulseThInfo*) { return GenerateInitInstanceLocal(static_cast<::PulseThInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_PulseProfInfo(void *p = nullptr); static void *newArray_PulseProfInfo(Long_t size, void *p); static void delete_PulseProfInfo(void *p); static void deleteArray_PulseProfInfo(void *p); static void destruct_PulseProfInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::PulseProfInfo*) { ::PulseProfInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::PulseProfInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("PulseProfInfo", ::PulseProfInfo::Class_Version(), "DCEPulseProfInfo.hh", 20, typeid(::PulseProfInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::PulseProfInfo::Dictionary, isa_proxy, 4, sizeof(::PulseProfInfo) ); instance.SetNew(&new_PulseProfInfo); instance.SetNewArray(&newArray_PulseProfInfo); instance.SetDelete(&delete_PulseProfInfo); instance.SetDeleteArray(&deleteArray_PulseProfInfo); instance.SetDestructor(&destruct_PulseProfInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::PulseProfInfo*) { return GenerateInitInstanceLocal(static_cast<::PulseProfInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_PulseProfThInfo(void *p = nullptr); static void *newArray_PulseProfThInfo(Long_t size, void *p); static void delete_PulseProfThInfo(void *p); static void deleteArray_PulseProfThInfo(void *p); static void destruct_PulseProfThInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::PulseProfThInfo*) { ::PulseProfThInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::PulseProfThInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("PulseProfThInfo", ::PulseProfThInfo::Class_Version(), "DCEPulseProfThInfo.hh", 19, typeid(::PulseProfThInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::PulseProfThInfo::Dictionary, isa_proxy, 4, sizeof(::PulseProfThInfo) ); instance.SetNew(&new_PulseProfThInfo); instance.SetNewArray(&newArray_PulseProfThInfo); instance.SetDelete(&delete_PulseProfThInfo); instance.SetDeleteArray(&deleteArray_PulseProfThInfo); instance.SetDestructor(&destruct_PulseProfThInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::PulseProfThInfo*) { return GenerateInitInstanceLocal(static_cast<::PulseProfThInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_MuPulseInfo(void *p = nullptr); static void *newArray_MuPulseInfo(Long_t size, void *p); static void delete_MuPulseInfo(void *p); static void deleteArray_MuPulseInfo(void *p); static void destruct_MuPulseInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::MuPulseInfo*) { ::MuPulseInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::MuPulseInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("MuPulseInfo", ::MuPulseInfo::Class_Version(), "DCEMuPulseInfo.hh", 18, typeid(::MuPulseInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::MuPulseInfo::Dictionary, isa_proxy, 4, sizeof(::MuPulseInfo) ); instance.SetNew(&new_MuPulseInfo); instance.SetNewArray(&newArray_MuPulseInfo); instance.SetDelete(&delete_MuPulseInfo); instance.SetDeleteArray(&deleteArray_MuPulseInfo); instance.SetDestructor(&destruct_MuPulseInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::MuPulseInfo*) { return GenerateInitInstanceLocal(static_cast<::MuPulseInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_MuPulseThInfo(void *p = nullptr); static void *newArray_MuPulseThInfo(Long_t size, void *p); static void delete_MuPulseThInfo(void *p); static void deleteArray_MuPulseThInfo(void *p); static void destruct_MuPulseThInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::MuPulseThInfo*) { ::MuPulseThInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::MuPulseThInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("MuPulseThInfo", ::MuPulseThInfo::Class_Version(), "DCEMuPulseThInfo.hh", 18, typeid(::MuPulseThInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::MuPulseThInfo::Dictionary, isa_proxy, 4, sizeof(::MuPulseThInfo) ); instance.SetNew(&new_MuPulseThInfo); instance.SetNewArray(&newArray_MuPulseThInfo); instance.SetDelete(&delete_MuPulseThInfo); instance.SetDeleteArray(&deleteArray_MuPulseThInfo); instance.SetDestructor(&destruct_MuPulseThInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::MuPulseThInfo*) { return GenerateInitInstanceLocal(static_cast<::MuPulseThInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_MuPulseProfInfo(void *p = nullptr); static void *newArray_MuPulseProfInfo(Long_t size, void *p); static void delete_MuPulseProfInfo(void *p); static void deleteArray_MuPulseProfInfo(void *p); static void destruct_MuPulseProfInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::MuPulseProfInfo*) { ::MuPulseProfInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::MuPulseProfInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("MuPulseProfInfo", ::MuPulseProfInfo::Class_Version(), "DCEMuPulseProfInfo.hh", 19, typeid(::MuPulseProfInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::MuPulseProfInfo::Dictionary, isa_proxy, 4, sizeof(::MuPulseProfInfo) ); instance.SetNew(&new_MuPulseProfInfo); instance.SetNewArray(&newArray_MuPulseProfInfo); instance.SetDelete(&delete_MuPulseProfInfo); instance.SetDeleteArray(&deleteArray_MuPulseProfInfo); instance.SetDestructor(&destruct_MuPulseProfInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::MuPulseProfInfo*) { return GenerateInitInstanceLocal(static_cast<::MuPulseProfInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_MuPulseProfThInfo(void *p = nullptr); static void *newArray_MuPulseProfThInfo(Long_t size, void *p); static void delete_MuPulseProfThInfo(void *p); static void deleteArray_MuPulseProfThInfo(void *p); static void destruct_MuPulseProfThInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::MuPulseProfThInfo*) { ::MuPulseProfThInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::MuPulseProfThInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("MuPulseProfThInfo", ::MuPulseProfThInfo::Class_Version(), "DCEMuPulseProfThInfo.hh", 18, typeid(::MuPulseProfThInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::MuPulseProfThInfo::Dictionary, isa_proxy, 4, sizeof(::MuPulseProfThInfo) ); instance.SetNew(&new_MuPulseProfThInfo); instance.SetNewArray(&newArray_MuPulseProfThInfo); instance.SetDelete(&delete_MuPulseProfThInfo); instance.SetDeleteArray(&deleteArray_MuPulseProfThInfo); instance.SetDestructor(&destruct_MuPulseProfThInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::MuPulseProfThInfo*) { return GenerateInitInstanceLocal(static_cast<::MuPulseProfThInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RecoVertexInfo(void *p = nullptr); static void *newArray_RecoVertexInfo(Long_t size, void *p); static void delete_RecoVertexInfo(void *p); static void deleteArray_RecoVertexInfo(void *p); static void destruct_RecoVertexInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RecoVertexInfo*) { ::RecoVertexInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RecoVertexInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("RecoVertexInfo", ::RecoVertexInfo::Class_Version(), "DCERecoVertexInfo.hh", 21, typeid(::RecoVertexInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RecoVertexInfo::Dictionary, isa_proxy, 4, sizeof(::RecoVertexInfo) ); instance.SetNew(&new_RecoVertexInfo); instance.SetNewArray(&newArray_RecoVertexInfo); instance.SetDelete(&delete_RecoVertexInfo); instance.SetDeleteArray(&deleteArray_RecoVertexInfo); instance.SetDestructor(&destruct_RecoVertexInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RecoVertexInfo*) { return GenerateInitInstanceLocal(static_cast<::RecoVertexInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RecoTrackInfo(void *p = nullptr); static void *newArray_RecoTrackInfo(Long_t size, void *p); static void delete_RecoTrackInfo(void *p); static void deleteArray_RecoTrackInfo(void *p); static void destruct_RecoTrackInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RecoTrackInfo*) { ::RecoTrackInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RecoTrackInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("RecoTrackInfo", ::RecoTrackInfo::Class_Version(), "DCERecoTrackInfo.hh", 18, typeid(::RecoTrackInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RecoTrackInfo::Dictionary, isa_proxy, 4, sizeof(::RecoTrackInfo) ); instance.SetNew(&new_RecoTrackInfo); instance.SetNewArray(&newArray_RecoTrackInfo); instance.SetDelete(&delete_RecoTrackInfo); instance.SetDeleteArray(&deleteArray_RecoTrackInfo); instance.SetDestructor(&destruct_RecoTrackInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RecoTrackInfo*) { return GenerateInitInstanceLocal(static_cast<::RecoTrackInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RecoMOSCOWInfo(void *p = nullptr); static void *newArray_RecoMOSCOWInfo(Long_t size, void *p); static void delete_RecoMOSCOWInfo(void *p); static void deleteArray_RecoMOSCOWInfo(void *p); static void destruct_RecoMOSCOWInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RecoMOSCOWInfo*) { ::RecoMOSCOWInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RecoMOSCOWInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("RecoMOSCOWInfo", ::RecoMOSCOWInfo::Class_Version(), "DCERecoMOSCOWInfo.hh", 19, typeid(::RecoMOSCOWInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RecoMOSCOWInfo::Dictionary, isa_proxy, 4, sizeof(::RecoMOSCOWInfo) ); instance.SetNew(&new_RecoMOSCOWInfo); instance.SetNewArray(&newArray_RecoMOSCOWInfo); instance.SetDelete(&delete_RecoMOSCOWInfo); instance.SetDeleteArray(&deleteArray_RecoMOSCOWInfo); instance.SetDestructor(&destruct_RecoMOSCOWInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RecoMOSCOWInfo*) { return GenerateInitInstanceLocal(static_cast<::RecoMOSCOWInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RecoTOFInfo(void *p = nullptr); static void *newArray_RecoTOFInfo(Long_t size, void *p); static void delete_RecoTOFInfo(void *p); static void deleteArray_RecoTOFInfo(void *p); static void destruct_RecoTOFInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RecoTOFInfo*) { ::RecoTOFInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RecoTOFInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("RecoTOFInfo", ::RecoTOFInfo::Class_Version(), "DCERecoTOFInfo.hh", 17, typeid(::RecoTOFInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RecoTOFInfo::Dictionary, isa_proxy, 4, sizeof(::RecoTOFInfo) ); instance.SetNew(&new_RecoTOFInfo); instance.SetNewArray(&newArray_RecoTOFInfo); instance.SetDelete(&delete_RecoTOFInfo); instance.SetDeleteArray(&deleteArray_RecoTOFInfo); instance.SetDestructor(&destruct_RecoTOFInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RecoTOFInfo*) { return GenerateInitInstanceLocal(static_cast<::RecoTOFInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RecoBAMAInfo(void *p = nullptr); static void *newArray_RecoBAMAInfo(Long_t size, void *p); static void delete_RecoBAMAInfo(void *p); static void deleteArray_RecoBAMAInfo(void *p); static void destruct_RecoBAMAInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RecoBAMAInfo*) { ::RecoBAMAInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RecoBAMAInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("RecoBAMAInfo", ::RecoBAMAInfo::Class_Version(), "DCERecoBAMAInfo.hh", 19, typeid(::RecoBAMAInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RecoBAMAInfo::Dictionary, isa_proxy, 4, sizeof(::RecoBAMAInfo) ); instance.SetNew(&new_RecoBAMAInfo); instance.SetNewArray(&newArray_RecoBAMAInfo); instance.SetDelete(&delete_RecoBAMAInfo); instance.SetDeleteArray(&deleteArray_RecoBAMAInfo); instance.SetDestructor(&destruct_RecoBAMAInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RecoBAMAInfo*) { return GenerateInitInstanceLocal(static_cast<::RecoBAMAInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RecoNNIVInfo(void *p = nullptr); static void *newArray_RecoNNIVInfo(Long_t size, void *p); static void delete_RecoNNIVInfo(void *p); static void deleteArray_RecoNNIVInfo(void *p); static void destruct_RecoNNIVInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RecoNNIVInfo*) { ::RecoNNIVInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RecoNNIVInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("RecoNNIVInfo", ::RecoNNIVInfo::Class_Version(), "DCERecoNNIVInfo.hh", 19, typeid(::RecoNNIVInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RecoNNIVInfo::Dictionary, isa_proxy, 4, sizeof(::RecoNNIVInfo) ); instance.SetNew(&new_RecoNNIVInfo); instance.SetNewArray(&newArray_RecoNNIVInfo); instance.SetDelete(&delete_RecoNNIVInfo); instance.SetDeleteArray(&deleteArray_RecoNNIVInfo); instance.SetDestructor(&destruct_RecoNNIVInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RecoNNIVInfo*) { return GenerateInitInstanceLocal(static_cast<::RecoNNIVInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_CocoRecoInfo(void *p = nullptr); static void *newArray_CocoRecoInfo(Long_t size, void *p); static void delete_CocoRecoInfo(void *p); static void deleteArray_CocoRecoInfo(void *p); static void destruct_CocoRecoInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::CocoRecoInfo*) { ::CocoRecoInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::CocoRecoInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("CocoRecoInfo", ::CocoRecoInfo::Class_Version(), "DCECocoRecoInfo.hh", 20, typeid(::CocoRecoInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::CocoRecoInfo::Dictionary, isa_proxy, 4, sizeof(::CocoRecoInfo) ); instance.SetNew(&new_CocoRecoInfo); instance.SetNewArray(&newArray_CocoRecoInfo); instance.SetDelete(&delete_CocoRecoInfo); instance.SetDeleteArray(&deleteArray_CocoRecoInfo); instance.SetDestructor(&destruct_CocoRecoInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::CocoRecoInfo*) { return GenerateInitInstanceLocal(static_cast<::CocoRecoInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RecoEnergyInfo(void *p = nullptr); static void *newArray_RecoEnergyInfo(Long_t size, void *p); static void delete_RecoEnergyInfo(void *p); static void deleteArray_RecoEnergyInfo(void *p); static void destruct_RecoEnergyInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RecoEnergyInfo*) { ::RecoEnergyInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RecoEnergyInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("RecoEnergyInfo", ::RecoEnergyInfo::Class_Version(), "DCERecoEnergyInfo.hh", 18, typeid(::RecoEnergyInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RecoEnergyInfo::Dictionary, isa_proxy, 4, sizeof(::RecoEnergyInfo) ); instance.SetNew(&new_RecoEnergyInfo); instance.SetNewArray(&newArray_RecoEnergyInfo); instance.SetDelete(&delete_RecoEnergyInfo); instance.SetDeleteArray(&deleteArray_RecoEnergyInfo); instance.SetDestructor(&destruct_RecoEnergyInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RecoEnergyInfo*) { return GenerateInitInstanceLocal(static_cast<::RecoEnergyInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_ERecoHDInfo(void *p = nullptr); static void *newArray_ERecoHDInfo(Long_t size, void *p); static void delete_ERecoHDInfo(void *p); static void deleteArray_ERecoHDInfo(void *p); static void destruct_ERecoHDInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::ERecoHDInfo*) { ::ERecoHDInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::ERecoHDInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("ERecoHDInfo", ::ERecoHDInfo::Class_Version(), "DCEERecoHDInfo.hh", 27, typeid(::ERecoHDInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::ERecoHDInfo::Dictionary, isa_proxy, 4, sizeof(::ERecoHDInfo) ); instance.SetNew(&new_ERecoHDInfo); instance.SetNewArray(&newArray_ERecoHDInfo); instance.SetDelete(&delete_ERecoHDInfo); instance.SetDeleteArray(&deleteArray_ERecoHDInfo); instance.SetDestructor(&destruct_ERecoHDInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::ERecoHDInfo*) { return GenerateInitInstanceLocal(static_cast<::ERecoHDInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RecoThInfo(void *p = nullptr); static void *newArray_RecoThInfo(Long_t size, void *p); static void delete_RecoThInfo(void *p); static void deleteArray_RecoThInfo(void *p); static void destruct_RecoThInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RecoThInfo*) { ::RecoThInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RecoThInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("RecoThInfo", ::RecoThInfo::Class_Version(), "DCERecoThInfo.hh", 19, typeid(::RecoThInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RecoThInfo::Dictionary, isa_proxy, 4, sizeof(::RecoThInfo) ); instance.SetNew(&new_RecoThInfo); instance.SetNewArray(&newArray_RecoThInfo); instance.SetDelete(&delete_RecoThInfo); instance.SetDeleteArray(&deleteArray_RecoThInfo); instance.SetDestructor(&destruct_RecoThInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RecoThInfo*) { return GenerateInitInstanceLocal(static_cast<::RecoThInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RecoMuonInfo(void *p = nullptr); static void *newArray_RecoMuonInfo(Long_t size, void *p); static void delete_RecoMuonInfo(void *p); static void deleteArray_RecoMuonInfo(void *p); static void destruct_RecoMuonInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RecoMuonInfo*) { ::RecoMuonInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RecoMuonInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("RecoMuonInfo", ::RecoMuonInfo::Class_Version(), "DCERecoMuonInfo.hh", 22, typeid(::RecoMuonInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RecoMuonInfo::Dictionary, isa_proxy, 4, sizeof(::RecoMuonInfo) ); instance.SetNew(&new_RecoMuonInfo); instance.SetNewArray(&newArray_RecoMuonInfo); instance.SetDelete(&delete_RecoMuonInfo); instance.SetDeleteArray(&deleteArray_RecoMuonInfo); instance.SetDestructor(&destruct_RecoMuonInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RecoMuonInfo*) { return GenerateInitInstanceLocal(static_cast<::RecoMuonInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RecoMuonThInfo(void *p = nullptr); static void *newArray_RecoMuonThInfo(Long_t size, void *p); static void delete_RecoMuonThInfo(void *p); static void deleteArray_RecoMuonThInfo(void *p); static void destruct_RecoMuonThInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RecoMuonThInfo*) { ::RecoMuonThInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RecoMuonThInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("RecoMuonThInfo", ::RecoMuonThInfo::Class_Version(), "DCERecoMuonThInfo.hh", 18, typeid(::RecoMuonThInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RecoMuonThInfo::Dictionary, isa_proxy, 4, sizeof(::RecoMuonThInfo) ); instance.SetNew(&new_RecoMuonThInfo); instance.SetNewArray(&newArray_RecoMuonThInfo); instance.SetDelete(&delete_RecoMuonThInfo); instance.SetDeleteArray(&deleteArray_RecoMuonThInfo); instance.SetDestructor(&destruct_RecoMuonThInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RecoMuonThInfo*) { return GenerateInitInstanceLocal(static_cast<::RecoMuonThInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RecoMuonAPCInfo(void *p = nullptr); static void *newArray_RecoMuonAPCInfo(Long_t size, void *p); static void delete_RecoMuonAPCInfo(void *p); static void deleteArray_RecoMuonAPCInfo(void *p); static void destruct_RecoMuonAPCInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RecoMuonAPCInfo*) { ::RecoMuonAPCInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RecoMuonAPCInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("RecoMuonAPCInfo", ::RecoMuonAPCInfo::Class_Version(), "DCERecoMuonAPCInfo.hh", 17, typeid(::RecoMuonAPCInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RecoMuonAPCInfo::Dictionary, isa_proxy, 4, sizeof(::RecoMuonAPCInfo) ); instance.SetNew(&new_RecoMuonAPCInfo); instance.SetNewArray(&newArray_RecoMuonAPCInfo); instance.SetDelete(&delete_RecoMuonAPCInfo); instance.SetDeleteArray(&deleteArray_RecoMuonAPCInfo); instance.SetDestructor(&destruct_RecoMuonAPCInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RecoMuonAPCInfo*) { return GenerateInitInstanceLocal(static_cast<::RecoMuonAPCInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RecoMuonIVBCInfo(void *p = nullptr); static void *newArray_RecoMuonIVBCInfo(Long_t size, void *p); static void delete_RecoMuonIVBCInfo(void *p); static void deleteArray_RecoMuonIVBCInfo(void *p); static void destruct_RecoMuonIVBCInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RecoMuonIVBCInfo*) { ::RecoMuonIVBCInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RecoMuonIVBCInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("RecoMuonIVBCInfo", ::RecoMuonIVBCInfo::Class_Version(), "DCERecoMuonIVBCInfo.hh", 21, typeid(::RecoMuonIVBCInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RecoMuonIVBCInfo::Dictionary, isa_proxy, 4, sizeof(::RecoMuonIVBCInfo) ); instance.SetNew(&new_RecoMuonIVBCInfo); instance.SetNewArray(&newArray_RecoMuonIVBCInfo); instance.SetDelete(&delete_RecoMuonIVBCInfo); instance.SetDeleteArray(&deleteArray_RecoMuonIVBCInfo); instance.SetDestructor(&destruct_RecoMuonIVBCInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RecoMuonIVBCInfo*) { return GenerateInitInstanceLocal(static_cast<::RecoMuonIVBCInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RecoMuonIVMLInfo(void *p = nullptr); static void *newArray_RecoMuonIVMLInfo(Long_t size, void *p); static void delete_RecoMuonIVMLInfo(void *p); static void deleteArray_RecoMuonIVMLInfo(void *p); static void destruct_RecoMuonIVMLInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RecoMuonIVMLInfo*) { ::RecoMuonIVMLInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RecoMuonIVMLInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("RecoMuonIVMLInfo", ::RecoMuonIVMLInfo::Class_Version(), "DCERecoMuonIVMLInfo.hh", 21, typeid(::RecoMuonIVMLInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RecoMuonIVMLInfo::Dictionary, isa_proxy, 4, sizeof(::RecoMuonIVMLInfo) ); instance.SetNew(&new_RecoMuonIVMLInfo); instance.SetNewArray(&newArray_RecoMuonIVMLInfo); instance.SetDelete(&delete_RecoMuonIVMLInfo); instance.SetDeleteArray(&deleteArray_RecoMuonIVMLInfo); instance.SetDestructor(&destruct_RecoMuonIVMLInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RecoMuonIVMLInfo*) { return GenerateInitInstanceLocal(static_cast<::RecoMuonIVMLInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RecoMuHamIDInfo(void *p = nullptr); static void *newArray_RecoMuHamIDInfo(Long_t size, void *p); static void delete_RecoMuHamIDInfo(void *p); static void deleteArray_RecoMuHamIDInfo(void *p); static void destruct_RecoMuHamIDInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RecoMuHamIDInfo*) { ::RecoMuHamIDInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RecoMuHamIDInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("RecoMuHamIDInfo", ::RecoMuHamIDInfo::Class_Version(), "DCERecoMuHamIDInfo.hh", 23, typeid(::RecoMuHamIDInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RecoMuHamIDInfo::Dictionary, isa_proxy, 4, sizeof(::RecoMuHamIDInfo) ); instance.SetNew(&new_RecoMuHamIDInfo); instance.SetNewArray(&newArray_RecoMuHamIDInfo); instance.SetDelete(&delete_RecoMuHamIDInfo); instance.SetDeleteArray(&deleteArray_RecoMuHamIDInfo); instance.SetDestructor(&destruct_RecoMuHamIDInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RecoMuHamIDInfo*) { return GenerateInitInstanceLocal(static_cast<::RecoMuHamIDInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RecoMuonFIDOInfo(void *p = nullptr); static void *newArray_RecoMuonFIDOInfo(Long_t size, void *p); static void delete_RecoMuonFIDOInfo(void *p); static void deleteArray_RecoMuonFIDOInfo(void *p); static void destruct_RecoMuonFIDOInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RecoMuonFIDOInfo*) { ::RecoMuonFIDOInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RecoMuonFIDOInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("RecoMuonFIDOInfo", ::RecoMuonFIDOInfo::Class_Version(), "DCERecoMuonFIDOInfo.hh", 17, typeid(::RecoMuonFIDOInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RecoMuonFIDOInfo::Dictionary, isa_proxy, 4, sizeof(::RecoMuonFIDOInfo) ); instance.SetNew(&new_RecoMuonFIDOInfo); instance.SetNewArray(&newArray_RecoMuonFIDOInfo); instance.SetDelete(&delete_RecoMuonFIDOInfo); instance.SetDeleteArray(&deleteArray_RecoMuonFIDOInfo); instance.SetDestructor(&destruct_RecoMuonFIDOInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RecoMuonFIDOInfo*) { return GenerateInitInstanceLocal(static_cast<::RecoMuonFIDOInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RecoOVMergeInfo(void *p = nullptr); static void *newArray_RecoOVMergeInfo(Long_t size, void *p); static void delete_RecoOVMergeInfo(void *p); static void deleteArray_RecoOVMergeInfo(void *p); static void destruct_RecoOVMergeInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RecoOVMergeInfo*) { ::RecoOVMergeInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RecoOVMergeInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("RecoOVMergeInfo", ::RecoOVMergeInfo::Class_Version(), "DCERecoOVMergeInfo.hh", 17, typeid(::RecoOVMergeInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RecoOVMergeInfo::Dictionary, isa_proxy, 4, sizeof(::RecoOVMergeInfo) ); instance.SetNew(&new_RecoOVMergeInfo); instance.SetNewArray(&newArray_RecoOVMergeInfo); instance.SetDelete(&delete_RecoOVMergeInfo); instance.SetDeleteArray(&deleteArray_RecoOVMergeInfo); instance.SetDestructor(&destruct_RecoOVMergeInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RecoOVMergeInfo*) { return GenerateInitInstanceLocal(static_cast<::RecoOVMergeInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_OVXYInFile(void *p = nullptr); static void *newArray_OVXYInFile(Long_t size, void *p); static void delete_OVXYInFile(void *p); static void deleteArray_OVXYInFile(void *p); static void destruct_OVXYInFile(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OVXYInFile*) { ::OVXYInFile *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::OVXYInFile >(nullptr); static ::ROOT::TGenericClassInfo instance("OVXYInFile", ::OVXYInFile::Class_Version(), "OVXYInFile.h", 31, typeid(::OVXYInFile), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::OVXYInFile::Dictionary, isa_proxy, 4, sizeof(::OVXYInFile) ); instance.SetNew(&new_OVXYInFile); instance.SetNewArray(&newArray_OVXYInFile); instance.SetDelete(&delete_OVXYInFile); instance.SetDeleteArray(&deleteArray_OVXYInFile); instance.SetDestructor(&destruct_OVXYInFile); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OVXYInFile*) { return GenerateInitInstanceLocal(static_cast<::OVXYInFile*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_OVTrackInFile(void *p = nullptr); static void *newArray_OVTrackInFile(Long_t size, void *p); static void delete_OVTrackInFile(void *p); static void deleteArray_OVTrackInFile(void *p); static void destruct_OVTrackInFile(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OVTrackInFile*) { ::OVTrackInFile *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::OVTrackInFile >(nullptr); static ::ROOT::TGenericClassInfo instance("OVTrackInFile", ::OVTrackInFile::Class_Version(), "OVTrackInFile.h", 28, typeid(::OVTrackInFile), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::OVTrackInFile::Dictionary, isa_proxy, 4, sizeof(::OVTrackInFile) ); instance.SetNew(&new_OVTrackInFile); instance.SetNewArray(&newArray_OVTrackInFile); instance.SetDelete(&delete_OVTrackInFile); instance.SetDeleteArray(&deleteArray_OVTrackInFile); instance.SetDestructor(&destruct_OVTrackInFile); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OVTrackInFile*) { return GenerateInitInstanceLocal(static_cast<::OVTrackInFile*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RecoDtInfo(void *p = nullptr); static void *newArray_RecoDtInfo(Long_t size, void *p); static void delete_RecoDtInfo(void *p); static void deleteArray_RecoDtInfo(void *p); static void destruct_RecoDtInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RecoDtInfo*) { ::RecoDtInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RecoDtInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("RecoDtInfo", ::RecoDtInfo::Class_Version(), "DCERecoDtInfo.hh", 23, typeid(::RecoDtInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RecoDtInfo::Dictionary, isa_proxy, 4, sizeof(::RecoDtInfo) ); instance.SetNew(&new_RecoDtInfo); instance.SetNewArray(&newArray_RecoDtInfo); instance.SetDelete(&delete_RecoDtInfo); instance.SetDeleteArray(&deleteArray_RecoDtInfo); instance.SetDestructor(&destruct_RecoDtInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RecoDtInfo*) { return GenerateInitInstanceLocal(static_cast<::RecoDtInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_CalibrationInfo(void *p = nullptr); static void *newArray_CalibrationInfo(Long_t size, void *p); static void delete_CalibrationInfo(void *p); static void deleteArray_CalibrationInfo(void *p); static void destruct_CalibrationInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::CalibrationInfo*) { ::CalibrationInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::CalibrationInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("CalibrationInfo", ::CalibrationInfo::Class_Version(), "DCECalibrationInfo.hh", 19, typeid(::CalibrationInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::CalibrationInfo::Dictionary, isa_proxy, 4, sizeof(::CalibrationInfo) ); instance.SetNew(&new_CalibrationInfo); instance.SetNewArray(&newArray_CalibrationInfo); instance.SetDelete(&delete_CalibrationInfo); instance.SetDeleteArray(&deleteArray_CalibrationInfo); instance.SetDestructor(&destruct_CalibrationInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::CalibrationInfo*) { return GenerateInitInstanceLocal(static_cast<::CalibrationInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_IDLIInfo(void *p = nullptr); static void *newArray_IDLIInfo(Long_t size, void *p); static void delete_IDLIInfo(void *p); static void deleteArray_IDLIInfo(void *p); static void destruct_IDLIInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::IDLIInfo*) { ::IDLIInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::IDLIInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("IDLIInfo", ::IDLIInfo::Class_Version(), "DCEIDLIInfo.hh", 18, typeid(::IDLIInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::IDLIInfo::Dictionary, isa_proxy, 4, sizeof(::IDLIInfo) ); instance.SetNew(&new_IDLIInfo); instance.SetNewArray(&newArray_IDLIInfo); instance.SetDelete(&delete_IDLIInfo); instance.SetDeleteArray(&deleteArray_IDLIInfo); instance.SetDestructor(&destruct_IDLIInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::IDLIInfo*) { return GenerateInitInstanceLocal(static_cast<::IDLIInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_ParticleThInfo(void *p = nullptr); static void *newArray_ParticleThInfo(Long_t size, void *p); static void delete_ParticleThInfo(void *p); static void deleteArray_ParticleThInfo(void *p); static void destruct_ParticleThInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::ParticleThInfo*) { ::ParticleThInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::ParticleThInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("ParticleThInfo", ::ParticleThInfo::Class_Version(), "DCEParticleThInfo.hh", 20, typeid(::ParticleThInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::ParticleThInfo::Dictionary, isa_proxy, 4, sizeof(::ParticleThInfo) ); instance.SetNew(&new_ParticleThInfo); instance.SetNewArray(&newArray_ParticleThInfo); instance.SetDelete(&delete_ParticleThInfo); instance.SetDeleteArray(&deleteArray_ParticleThInfo); instance.SetDestructor(&destruct_ParticleThInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::ParticleThInfo*) { return GenerateInitInstanceLocal(static_cast<::ParticleThInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_TrackThInfo(void *p = nullptr); static void *newArray_TrackThInfo(Long_t size, void *p); static void delete_TrackThInfo(void *p); static void deleteArray_TrackThInfo(void *p); static void destruct_TrackThInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::TrackThInfo*) { ::TrackThInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TrackThInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("TrackThInfo", ::TrackThInfo::Class_Version(), "DCETrackThInfo.hh", 38, typeid(::TrackThInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::TrackThInfo::Dictionary, isa_proxy, 4, sizeof(::TrackThInfo) ); instance.SetNew(&new_TrackThInfo); instance.SetNewArray(&newArray_TrackThInfo); instance.SetDelete(&delete_TrackThInfo); instance.SetDeleteArray(&deleteArray_TrackThInfo); instance.SetDestructor(&destruct_TrackThInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::TrackThInfo*) { return GenerateInitInstanceLocal(static_cast<::TrackThInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_MCInfo(void *p = nullptr); static void *newArray_MCInfo(Long_t size, void *p); static void delete_MCInfo(void *p); static void deleteArray_MCInfo(void *p); static void destruct_MCInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::MCInfo*) { ::MCInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::MCInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("MCInfo", ::MCInfo::Class_Version(), "DCEMCInfo.hh", 20, typeid(::MCInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::MCInfo::Dictionary, isa_proxy, 4, sizeof(::MCInfo) ); instance.SetNew(&new_MCInfo); instance.SetNewArray(&newArray_MCInfo); instance.SetDelete(&delete_MCInfo); instance.SetDeleteArray(&deleteArray_MCInfo); instance.SetDestructor(&destruct_MCInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::MCInfo*) { return GenerateInitInstanceLocal(static_cast<::MCInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RunInfo(void *p = nullptr); static void *newArray_RunInfo(Long_t size, void *p); static void delete_RunInfo(void *p); static void deleteArray_RunInfo(void *p); static void destruct_RunInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RunInfo*) { ::RunInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RunInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("RunInfo", ::RunInfo::Class_Version(), "DCERunInfo.hh", 24, typeid(::RunInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RunInfo::Dictionary, isa_proxy, 4, sizeof(::RunInfo) ); instance.SetNew(&new_RunInfo); instance.SetNewArray(&newArray_RunInfo); instance.SetDelete(&delete_RunInfo); instance.SetDeleteArray(&deleteArray_RunInfo); instance.SetDestructor(&destruct_RunInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RunInfo*) { return GenerateInitInstanceLocal(static_cast<::RunInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_TMFileThInfo(void *p = nullptr); static void *newArray_TMFileThInfo(Long_t size, void *p); static void delete_TMFileThInfo(void *p); static void deleteArray_TMFileThInfo(void *p); static void destruct_TMFileThInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMFileThInfo*) { ::TMFileThInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMFileThInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("TMFileThInfo", ::TMFileThInfo::Class_Version(), "DCETMFileThInfo.hh", 16, typeid(::TMFileThInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::TMFileThInfo::Dictionary, isa_proxy, 4, sizeof(::TMFileThInfo) ); instance.SetNew(&new_TMFileThInfo); instance.SetNewArray(&newArray_TMFileThInfo); instance.SetDelete(&delete_TMFileThInfo); instance.SetDeleteArray(&deleteArray_TMFileThInfo); instance.SetDestructor(&destruct_TMFileThInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::TMFileThInfo*) { return GenerateInitInstanceLocal(static_cast<::TMFileThInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_DynRunInfo(void *p = nullptr); static void *newArray_DynRunInfo(Long_t size, void *p); static void delete_DynRunInfo(void *p); static void deleteArray_DynRunInfo(void *p); static void destruct_DynRunInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::DynRunInfo*) { ::DynRunInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::DynRunInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("DynRunInfo", ::DynRunInfo::Class_Version(), "DCEDynRunInfo.hh", 21, typeid(::DynRunInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::DynRunInfo::Dictionary, isa_proxy, 4, sizeof(::DynRunInfo) ); instance.SetNew(&new_DynRunInfo); instance.SetNewArray(&newArray_DynRunInfo); instance.SetDelete(&delete_DynRunInfo); instance.SetDeleteArray(&deleteArray_DynRunInfo); instance.SetDestructor(&destruct_DynRunInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::DynRunInfo*) { return GenerateInitInstanceLocal(static_cast<::DynRunInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_DynEventInfo(void *p = nullptr); static void *newArray_DynEventInfo(Long_t size, void *p); static void delete_DynEventInfo(void *p); static void deleteArray_DynEventInfo(void *p); static void destruct_DynEventInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::DynEventInfo*) { ::DynEventInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::DynEventInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("DynEventInfo", ::DynEventInfo::Class_Version(), "DCEDynEventInfo.hh", 21, typeid(::DynEventInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::DynEventInfo::Dictionary, isa_proxy, 4, sizeof(::DynEventInfo) ); instance.SetNew(&new_DynEventInfo); instance.SetNewArray(&newArray_DynEventInfo); instance.SetDelete(&delete_DynEventInfo); instance.SetDeleteArray(&deleteArray_DynEventInfo); instance.SetDestructor(&destruct_DynEventInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::DynEventInfo*) { return GenerateInitInstanceLocal(static_cast<::DynEventInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_NuGenThInfo(void *p = nullptr); static void *newArray_NuGenThInfo(Long_t size, void *p); static void delete_NuGenThInfo(void *p); static void deleteArray_NuGenThInfo(void *p); static void destruct_NuGenThInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::NuGenThInfo*) { ::NuGenThInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::NuGenThInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("NuGenThInfo", ::NuGenThInfo::Class_Version(), "DCENuGenThInfo.hh", 17, typeid(::NuGenThInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::NuGenThInfo::Dictionary, isa_proxy, 4, sizeof(::NuGenThInfo) ); instance.SetNew(&new_NuGenThInfo); instance.SetNewArray(&newArray_NuGenThInfo); instance.SetDelete(&delete_NuGenThInfo); instance.SetDeleteArray(&deleteArray_NuGenThInfo); instance.SetDestructor(&destruct_NuGenThInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::NuGenThInfo*) { return GenerateInitInstanceLocal(static_cast<::NuGenThInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_MCStep(void *p = nullptr); static void *newArray_MCStep(Long_t size, void *p); static void delete_MCStep(void *p); static void deleteArray_MCStep(void *p); static void destruct_MCStep(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::MCStep*) { ::MCStep *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::MCStep >(nullptr); static ::ROOT::TGenericClassInfo instance("MCStep", ::MCStep::Class_Version(), "DCEMCStep.hh", 34, typeid(::MCStep), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::MCStep::Dictionary, isa_proxy, 4, sizeof(::MCStep) ); instance.SetNew(&new_MCStep); instance.SetNewArray(&newArray_MCStep); instance.SetDelete(&delete_MCStep); instance.SetDeleteArray(&deleteArray_MCStep); instance.SetDestructor(&destruct_MCStep); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::MCStep*) { return GenerateInitInstanceLocal(static_cast<::MCStep*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_MCTrack(void *p = nullptr); static void *newArray_MCTrack(Long_t size, void *p); static void delete_MCTrack(void *p); static void deleteArray_MCTrack(void *p); static void destruct_MCTrack(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::MCTrack*) { ::MCTrack *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::MCTrack >(nullptr); static ::ROOT::TGenericClassInfo instance("MCTrack", ::MCTrack::Class_Version(), "DCEMCTrack.hh", 31, typeid(::MCTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::MCTrack::Dictionary, isa_proxy, 4, sizeof(::MCTrack) ); instance.SetNew(&new_MCTrack); instance.SetNewArray(&newArray_MCTrack); instance.SetDelete(&delete_MCTrack); instance.SetDeleteArray(&deleteArray_MCTrack); instance.SetDestructor(&destruct_MCTrack); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::MCTrack*) { return GenerateInitInstanceLocal(static_cast<::MCTrack*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_OVHitInfo(void *p = nullptr); static void *newArray_OVHitInfo(Long_t size, void *p); static void delete_OVHitInfo(void *p); static void deleteArray_OVHitInfo(void *p); static void destruct_OVHitInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OVHitInfo*) { ::OVHitInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::OVHitInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("OVHitInfo", ::OVHitInfo::Class_Version(), "DCEOVHitInfo.hh", 29, typeid(::OVHitInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::OVHitInfo::Dictionary, isa_proxy, 4, sizeof(::OVHitInfo) ); instance.SetNew(&new_OVHitInfo); instance.SetNewArray(&newArray_OVHitInfo); instance.SetDelete(&delete_OVHitInfo); instance.SetDeleteArray(&deleteArray_OVHitInfo); instance.SetDestructor(&destruct_OVHitInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OVHitInfo*) { return GenerateInitInstanceLocal(static_cast<::OVHitInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_OVHitThInfo(void *p = nullptr); static void *newArray_OVHitThInfo(Long_t size, void *p); static void delete_OVHitThInfo(void *p); static void deleteArray_OVHitThInfo(void *p); static void destruct_OVHitThInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::OVHitThInfo*) { ::OVHitThInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::OVHitThInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("OVHitThInfo", ::OVHitThInfo::Class_Version(), "DCEOVHitThInfo.hh", 27, typeid(::OVHitThInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::OVHitThInfo::Dictionary, isa_proxy, 4, sizeof(::OVHitThInfo) ); instance.SetNew(&new_OVHitThInfo); instance.SetNewArray(&newArray_OVHitThInfo); instance.SetDelete(&delete_OVHitThInfo); instance.SetDeleteArray(&deleteArray_OVHitThInfo); instance.SetDestructor(&destruct_OVHitThInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::OVHitThInfo*) { return GenerateInitInstanceLocal(static_cast<::OVHitThInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_TriggerSummarizedInfo(void *p = nullptr); static void *newArray_TriggerSummarizedInfo(Long_t size, void *p); static void delete_TriggerSummarizedInfo(void *p); static void deleteArray_TriggerSummarizedInfo(void *p); static void destruct_TriggerSummarizedInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::TriggerSummarizedInfo*) { ::TriggerSummarizedInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TriggerSummarizedInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("TriggerSummarizedInfo", ::TriggerSummarizedInfo::Class_Version(), "DCETriggerSummarizedInfo.hh", 20, typeid(::TriggerSummarizedInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::TriggerSummarizedInfo::Dictionary, isa_proxy, 4, sizeof(::TriggerSummarizedInfo) ); instance.SetNew(&new_TriggerSummarizedInfo); instance.SetNewArray(&newArray_TriggerSummarizedInfo); instance.SetDelete(&delete_TriggerSummarizedInfo); instance.SetDeleteArray(&deleteArray_TriggerSummarizedInfo); instance.SetDestructor(&destruct_TriggerSummarizedInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::TriggerSummarizedInfo*) { return GenerateInitInstanceLocal(static_cast<::TriggerSummarizedInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_TriggerInfo(void *p = nullptr); static void *newArray_TriggerInfo(Long_t size, void *p); static void delete_TriggerInfo(void *p); static void deleteArray_TriggerInfo(void *p); static void destruct_TriggerInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::TriggerInfo*) { ::TriggerInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TriggerInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("TriggerInfo", ::TriggerInfo::Class_Version(), "DCETriggerInfo.hh", 19, typeid(::TriggerInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::TriggerInfo::Dictionary, isa_proxy, 4, sizeof(::TriggerInfo) ); instance.SetNew(&new_TriggerInfo); instance.SetNewArray(&newArray_TriggerInfo); instance.SetDelete(&delete_TriggerInfo); instance.SetDeleteArray(&deleteArray_TriggerInfo); instance.SetDestructor(&destruct_TriggerInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::TriggerInfo*) { return GenerateInitInstanceLocal(static_cast<::TriggerInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_TBInfo(void *p = nullptr); static void *newArray_TBInfo(Long_t size, void *p); static void delete_TBInfo(void *p); static void deleteArray_TBInfo(void *p); static void destruct_TBInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::TBInfo*) { ::TBInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TBInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("TBInfo", ::TBInfo::Class_Version(), "DCETriggerDiagnosisInfo.hh", 23, typeid(::TBInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::TBInfo::Dictionary, isa_proxy, 4, sizeof(::TBInfo) ); instance.SetNew(&new_TBInfo); instance.SetNewArray(&newArray_TBInfo); instance.SetDelete(&delete_TBInfo); instance.SetDeleteArray(&deleteArray_TBInfo); instance.SetDestructor(&destruct_TBInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::TBInfo*) { return GenerateInitInstanceLocal(static_cast<::TBInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_TMBInfo(void *p = nullptr); static void *newArray_TMBInfo(Long_t size, void *p); static void delete_TMBInfo(void *p); static void deleteArray_TMBInfo(void *p); static void destruct_TMBInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMBInfo*) { ::TMBInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMBInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("TMBInfo", ::TMBInfo::Class_Version(), "DCETriggerDiagnosisInfo.hh", 58, typeid(::TMBInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::TMBInfo::Dictionary, isa_proxy, 4, sizeof(::TMBInfo) ); instance.SetNew(&new_TMBInfo); instance.SetNewArray(&newArray_TMBInfo); instance.SetDelete(&delete_TMBInfo); instance.SetDeleteArray(&deleteArray_TMBInfo); instance.SetDestructor(&destruct_TMBInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::TMBInfo*) { return GenerateInitInstanceLocal(static_cast<::TMBInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_TriggerDiagnosisInfo(void *p = nullptr); static void *newArray_TriggerDiagnosisInfo(Long_t size, void *p); static void delete_TriggerDiagnosisInfo(void *p); static void deleteArray_TriggerDiagnosisInfo(void *p); static void destruct_TriggerDiagnosisInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::TriggerDiagnosisInfo*) { ::TriggerDiagnosisInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TriggerDiagnosisInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("TriggerDiagnosisInfo", ::TriggerDiagnosisInfo::Class_Version(), "DCETriggerDiagnosisInfo.hh", 108, typeid(::TriggerDiagnosisInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::TriggerDiagnosisInfo::Dictionary, isa_proxy, 4, sizeof(::TriggerDiagnosisInfo) ); instance.SetNew(&new_TriggerDiagnosisInfo); instance.SetNewArray(&newArray_TriggerDiagnosisInfo); instance.SetDelete(&delete_TriggerDiagnosisInfo); instance.SetDeleteArray(&deleteArray_TriggerDiagnosisInfo); instance.SetDestructor(&destruct_TriggerDiagnosisInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::TriggerDiagnosisInfo*) { return GenerateInitInstanceLocal(static_cast<::TriggerDiagnosisInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void delete_LightInfo(void *p); static void deleteArray_LightInfo(void *p); static void destruct_LightInfo(void *p); static void streamer_LightInfo(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::LightInfo*) { ::LightInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::LightInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("LightInfo", ::LightInfo::Class_Version(), "DCELightInfo.hh", 18, typeid(::LightInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::LightInfo::Dictionary, isa_proxy, 16, sizeof(::LightInfo) ); instance.SetDelete(&delete_LightInfo); instance.SetDeleteArray(&deleteArray_LightInfo); instance.SetDestructor(&destruct_LightInfo); instance.SetStreamerFunc(&streamer_LightInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::LightInfo*) { return GenerateInitInstanceLocal(static_cast<::LightInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_LightEUpp(void *p = nullptr); static void *newArray_LightEUpp(Long_t size, void *p); static void delete_LightEUpp(void *p); static void deleteArray_LightEUpp(void *p); static void destruct_LightEUpp(void *p); static void streamer_LightEUpp(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::LightEUpp*) { ::LightEUpp *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::LightEUpp >(nullptr); static ::ROOT::TGenericClassInfo instance("LightEUpp", ::LightEUpp::Class_Version(), "DCELightEUpp.hh", 70, typeid(::LightEUpp), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::LightEUpp::Dictionary, isa_proxy, 16, sizeof(::LightEUpp) ); instance.SetNew(&new_LightEUpp); instance.SetNewArray(&newArray_LightEUpp); instance.SetDelete(&delete_LightEUpp); instance.SetDeleteArray(&deleteArray_LightEUpp); instance.SetDestructor(&destruct_LightEUpp); instance.SetStreamerFunc(&streamer_LightEUpp); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::LightEUpp*) { return GenerateInitInstanceLocal(static_cast<::LightEUpp*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_LightJP(void *p = nullptr); static void *newArray_LightJP(Long_t size, void *p); static void delete_LightJP(void *p); static void deleteArray_LightJP(void *p); static void destruct_LightJP(void *p); static void streamer_LightJP(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::LightJP*) { ::LightJP *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::LightJP >(nullptr); static ::ROOT::TGenericClassInfo instance("LightJP", ::LightJP::Class_Version(), "DCELightJP.hh", 15, typeid(::LightJP), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::LightJP::Dictionary, isa_proxy, 16, sizeof(::LightJP) ); instance.SetNew(&new_LightJP); instance.SetNewArray(&newArray_LightJP); instance.SetDelete(&delete_LightJP); instance.SetDeleteArray(&deleteArray_LightJP); instance.SetDestructor(&destruct_LightJP); instance.SetStreamerFunc(&streamer_LightJP); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::LightJP*) { return GenerateInitInstanceLocal(static_cast<::LightJP*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_LightUnited(void *p = nullptr); static void *newArray_LightUnited(Long_t size, void *p); static void delete_LightUnited(void *p); static void deleteArray_LightUnited(void *p); static void destruct_LightUnited(void *p); static void streamer_LightUnited(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::LightUnited*) { ::LightUnited *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::LightUnited >(nullptr); static ::ROOT::TGenericClassInfo instance("LightUnited", ::LightUnited::Class_Version(), "DCELightUnited.hh", 14, typeid(::LightUnited), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::LightUnited::Dictionary, isa_proxy, 16, sizeof(::LightUnited) ); instance.SetNew(&new_LightUnited); instance.SetNewArray(&newArray_LightUnited); instance.SetDelete(&delete_LightUnited); instance.SetDeleteArray(&deleteArray_LightUnited); instance.SetDestructor(&destruct_LightUnited); instance.SetStreamerFunc(&streamer_LightUnited); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::LightUnited*) { return GenerateInitInstanceLocal(static_cast<::LightUnited*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_LightAPCMS(void *p = nullptr); static void *newArray_LightAPCMS(Long_t size, void *p); static void delete_LightAPCMS(void *p); static void deleteArray_LightAPCMS(void *p); static void destruct_LightAPCMS(void *p); static void streamer_LightAPCMS(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::LightAPCMS*) { ::LightAPCMS *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::LightAPCMS >(nullptr); static ::ROOT::TGenericClassInfo instance("LightAPCMS", ::LightAPCMS::Class_Version(), "DCELightAPCMultiS.hh", 13, typeid(::LightAPCMS), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::LightAPCMS::Dictionary, isa_proxy, 16, sizeof(::LightAPCMS) ); instance.SetNew(&new_LightAPCMS); instance.SetNewArray(&newArray_LightAPCMS); instance.SetDelete(&delete_LightAPCMS); instance.SetDeleteArray(&deleteArray_LightAPCMS); instance.SetDestructor(&destruct_LightAPCMS); instance.SetStreamerFunc(&streamer_LightAPCMS); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::LightAPCMS*) { return GenerateInitInstanceLocal(static_cast<::LightAPCMS*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_Accidental(void *p = nullptr); static void *newArray_Accidental(Long_t size, void *p); static void delete_Accidental(void *p); static void deleteArray_Accidental(void *p); static void destruct_Accidental(void *p); static void streamer_Accidental(TBuffer &buf, void *obj); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::Accidental*) { ::Accidental *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Accidental >(nullptr); static ::ROOT::TGenericClassInfo instance("Accidental", ::Accidental::Class_Version(), "DCEAccidental.hh", 15, typeid(::Accidental), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::Accidental::Dictionary, isa_proxy, 16, sizeof(::Accidental) ); instance.SetNew(&new_Accidental); instance.SetNewArray(&newArray_Accidental); instance.SetDelete(&delete_Accidental); instance.SetDeleteArray(&deleteArray_Accidental); instance.SetDestructor(&destruct_Accidental); instance.SetStreamerFunc(&streamer_Accidental); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::Accidental*) { return GenerateInitInstanceLocal(static_cast<::Accidental*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_RecoJPInfo(void *p = nullptr); static void *newArray_RecoJPInfo(Long_t size, void *p); static void delete_RecoJPInfo(void *p); static void deleteArray_RecoJPInfo(void *p); static void destruct_RecoJPInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RecoJPInfo*) { ::RecoJPInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RecoJPInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("RecoJPInfo", ::RecoJPInfo::Class_Version(), "DCERecoJPInfo.hh", 19, typeid(::RecoJPInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::RecoJPInfo::Dictionary, isa_proxy, 4, sizeof(::RecoJPInfo) ); instance.SetNew(&new_RecoJPInfo); instance.SetNewArray(&newArray_RecoJPInfo); instance.SetDelete(&delete_RecoJPInfo); instance.SetDeleteArray(&deleteArray_RecoJPInfo); instance.SetDestructor(&destruct_RecoJPInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RecoJPInfo*) { return GenerateInitInstanceLocal(static_cast<::RecoJPInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_MiniPulseInfo(void *p = nullptr); static void *newArray_MiniPulseInfo(Long_t size, void *p); static void delete_MiniPulseInfo(void *p); static void deleteArray_MiniPulseInfo(void *p); static void destruct_MiniPulseInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::MiniPulseInfo*) { ::MiniPulseInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::MiniPulseInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("MiniPulseInfo", ::MiniPulseInfo::Class_Version(), "DCEMiniPulseInfo.hh", 24, typeid(::MiniPulseInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::MiniPulseInfo::Dictionary, isa_proxy, 4, sizeof(::MiniPulseInfo) ); instance.SetNew(&new_MiniPulseInfo); instance.SetNewArray(&newArray_MiniPulseInfo); instance.SetDelete(&delete_MiniPulseInfo); instance.SetDeleteArray(&deleteArray_MiniPulseInfo); instance.SetDestructor(&destruct_MiniPulseInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::MiniPulseInfo*) { return GenerateInitInstanceLocal(static_cast<::MiniPulseInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static void *new_MuonTDCInfo(void *p = nullptr); static void *newArray_MuonTDCInfo(Long_t size, void *p); static void delete_MuonTDCInfo(void *p); static void deleteArray_MuonTDCInfo(void *p); static void destruct_MuonTDCInfo(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::MuonTDCInfo*) { ::MuonTDCInfo *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::MuonTDCInfo >(nullptr); static ::ROOT::TGenericClassInfo instance("MuonTDCInfo", ::MuonTDCInfo::Class_Version(), "DCEMuonTDCInfo.hh", 23, typeid(::MuonTDCInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::MuonTDCInfo::Dictionary, isa_proxy, 4, sizeof(::MuonTDCInfo) ); instance.SetNew(&new_MuonTDCInfo); instance.SetNewArray(&newArray_MuonTDCInfo); instance.SetDelete(&delete_MuonTDCInfo); instance.SetDeleteArray(&deleteArray_MuonTDCInfo); instance.SetDestructor(&destruct_MuonTDCInfo); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::MuonTDCInfo*) { return GenerateInitInstanceLocal(static_cast<::MuonTDCInfo*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static TClass *RunVLD_Dictionary(); static void RunVLD_TClassManip(TClass*); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::RunVLD*) { ::RunVLD *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RunVLD)); static ::ROOT::TGenericClassInfo instance("RunVLD", "DCERunVLD.hh", 27, typeid(::RunVLD), ::ROOT::Internal::DefineBehavior(ptr, ptr), &RunVLD_Dictionary, isa_proxy, 4, sizeof(::RunVLD) ); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::RunVLD*) { return GenerateInitInstanceLocal(static_cast<::RunVLD*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *RunVLD_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); RunVLD_TClassManip(theClass); return theClass; } static void RunVLD_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { static void *new_EnDep(void *p = nullptr); static void *newArray_EnDep(Long_t size, void *p); static void delete_EnDep(void *p); static void deleteArray_EnDep(void *p); static void destruct_EnDep(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::EnDep*) { ::EnDep *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::EnDep >(nullptr); static ::ROOT::TGenericClassInfo instance("EnDep", ::EnDep::Class_Version(), "DCEEnDep.hh", 32, typeid(::EnDep), ::ROOT::Internal::DefineBehavior(ptr, ptr), &::EnDep::Dictionary, isa_proxy, 4, sizeof(::EnDep) ); instance.SetNew(&new_EnDep); instance.SetNewArray(&newArray_EnDep); instance.SetDelete(&delete_EnDep); instance.SetDeleteArray(&deleteArray_EnDep); instance.SetDestructor(&destruct_EnDep); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::EnDep*) { return GenerateInitInstanceLocal(static_cast<::EnDep*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); } // end of namespace ROOT namespace ROOT { static TClass *Event_Dictionary(); static void Event_TClassManip(TClass*); static void *new_Event(void *p = nullptr); static void *newArray_Event(Long_t size, void *p); static void delete_Event(void *p); static void deleteArray_Event(void *p); static void destruct_Event(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::Event*) { ::Event *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Event)); static ::ROOT::TGenericClassInfo instance("Event", "DCEEvent.hh", 21, typeid(::Event), ::ROOT::Internal::DefineBehavior(ptr, ptr), &Event_Dictionary, isa_proxy, 4, sizeof(::Event) ); instance.SetNew(&new_Event); instance.SetNewArray(&newArray_Event); instance.SetDelete(&delete_Event); instance.SetDeleteArray(&deleteArray_Event); instance.SetDestructor(&destruct_Event); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::Event*) { return GenerateInitInstanceLocal(static_cast<::Event*>(nullptr)); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *Event_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast(nullptr))->GetClass(); Event_TClassManip(theClass); return theClass; } static void Event_TClassManip(TClass* ){ } } // end of namespace ROOT //______________________________________________________________________________ atomic_TClass_ptr ParamStore::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *ParamStore::Class_Name() { return "ParamStore"; } //______________________________________________________________________________ const char *ParamStore::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::ParamStore*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int ParamStore::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::ParamStore*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *ParamStore::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ParamStore*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *ParamStore::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ParamStore*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr InfoUnit::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *InfoUnit::Class_Name() { return "InfoUnit"; } //______________________________________________________________________________ const char *InfoUnit::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::InfoUnit*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int InfoUnit::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::InfoUnit*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *InfoUnit::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::InfoUnit*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *InfoUnit::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::InfoUnit*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr PMTHit::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *PMTHit::Class_Name() { return "PMTHit"; } //______________________________________________________________________________ const char *PMTHit::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::PMTHit*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int PMTHit::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::PMTHit*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *PMTHit::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::PMTHit*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *PMTHit::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::PMTHit*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr ParameterInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *ParameterInfo::Class_Name() { return "ParameterInfo"; } //______________________________________________________________________________ const char *ParameterInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::ParameterInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int ParameterInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::ParameterInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *ParameterInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ParameterInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *ParameterInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ParameterInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr OVHit::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *OVHit::Class_Name() { return "OVHit"; } //______________________________________________________________________________ const char *OVHit::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::OVHit*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int OVHit::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::OVHit*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *OVHit::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::OVHit*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *OVHit::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::OVHit*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr OVInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *OVInfo::Class_Name() { return "OVInfo"; } //______________________________________________________________________________ const char *OVInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::OVInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int OVInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::OVInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *OVInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::OVInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *OVInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::OVInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr OVCell::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *OVCell::Class_Name() { return "OVCell"; } //______________________________________________________________________________ const char *OVCell::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::OVCell*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int OVCell::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::OVCell*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *OVCell::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::OVCell*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *OVCell::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::OVCell*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr GlobalInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *GlobalInfo::Class_Name() { return "GlobalInfo"; } //______________________________________________________________________________ const char *GlobalInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::GlobalInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int GlobalInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::GlobalInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *GlobalInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::GlobalInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *GlobalInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::GlobalInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr GlobalThInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *GlobalThInfo::Class_Name() { return "GlobalThInfo"; } //______________________________________________________________________________ const char *GlobalThInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::GlobalThInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int GlobalThInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::GlobalThInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *GlobalThInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::GlobalThInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *GlobalThInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::GlobalThInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr PulseInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *PulseInfo::Class_Name() { return "PulseInfo"; } //______________________________________________________________________________ const char *PulseInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::PulseInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int PulseInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::PulseInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *PulseInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::PulseInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *PulseInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::PulseInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr PulsePeakWinInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *PulsePeakWinInfo::Class_Name() { return "PulsePeakWinInfo"; } //______________________________________________________________________________ const char *PulsePeakWinInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::PulsePeakWinInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int PulsePeakWinInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::PulsePeakWinInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *PulsePeakWinInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::PulsePeakWinInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *PulsePeakWinInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::PulsePeakWinInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr PulseSlideWinInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *PulseSlideWinInfo::Class_Name() { return "PulseSlideWinInfo"; } //______________________________________________________________________________ const char *PulseSlideWinInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::PulseSlideWinInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int PulseSlideWinInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::PulseSlideWinInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *PulseSlideWinInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::PulseSlideWinInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *PulseSlideWinInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::PulseSlideWinInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr PulseThInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *PulseThInfo::Class_Name() { return "PulseThInfo"; } //______________________________________________________________________________ const char *PulseThInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::PulseThInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int PulseThInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::PulseThInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *PulseThInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::PulseThInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *PulseThInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::PulseThInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr PulseProfInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *PulseProfInfo::Class_Name() { return "PulseProfInfo"; } //______________________________________________________________________________ const char *PulseProfInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::PulseProfInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int PulseProfInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::PulseProfInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *PulseProfInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::PulseProfInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *PulseProfInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::PulseProfInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr PulseProfThInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *PulseProfThInfo::Class_Name() { return "PulseProfThInfo"; } //______________________________________________________________________________ const char *PulseProfThInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::PulseProfThInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int PulseProfThInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::PulseProfThInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *PulseProfThInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::PulseProfThInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *PulseProfThInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::PulseProfThInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr MuPulseInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *MuPulseInfo::Class_Name() { return "MuPulseInfo"; } //______________________________________________________________________________ const char *MuPulseInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::MuPulseInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int MuPulseInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::MuPulseInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *MuPulseInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MuPulseInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *MuPulseInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MuPulseInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr MuPulseThInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *MuPulseThInfo::Class_Name() { return "MuPulseThInfo"; } //______________________________________________________________________________ const char *MuPulseThInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::MuPulseThInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int MuPulseThInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::MuPulseThInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *MuPulseThInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MuPulseThInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *MuPulseThInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MuPulseThInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr MuPulseProfInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *MuPulseProfInfo::Class_Name() { return "MuPulseProfInfo"; } //______________________________________________________________________________ const char *MuPulseProfInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::MuPulseProfInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int MuPulseProfInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::MuPulseProfInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *MuPulseProfInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MuPulseProfInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *MuPulseProfInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MuPulseProfInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr MuPulseProfThInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *MuPulseProfThInfo::Class_Name() { return "MuPulseProfThInfo"; } //______________________________________________________________________________ const char *MuPulseProfThInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::MuPulseProfThInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int MuPulseProfThInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::MuPulseProfThInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *MuPulseProfThInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MuPulseProfThInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *MuPulseProfThInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MuPulseProfThInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr RecoVertexInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *RecoVertexInfo::Class_Name() { return "RecoVertexInfo"; } //______________________________________________________________________________ const char *RecoVertexInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoVertexInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int RecoVertexInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoVertexInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *RecoVertexInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoVertexInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *RecoVertexInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoVertexInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr RecoTrackInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *RecoTrackInfo::Class_Name() { return "RecoTrackInfo"; } //______________________________________________________________________________ const char *RecoTrackInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoTrackInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int RecoTrackInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoTrackInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *RecoTrackInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoTrackInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *RecoTrackInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoTrackInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr RecoMOSCOWInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *RecoMOSCOWInfo::Class_Name() { return "RecoMOSCOWInfo"; } //______________________________________________________________________________ const char *RecoMOSCOWInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoMOSCOWInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int RecoMOSCOWInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoMOSCOWInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *RecoMOSCOWInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoMOSCOWInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *RecoMOSCOWInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoMOSCOWInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr RecoTOFInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *RecoTOFInfo::Class_Name() { return "RecoTOFInfo"; } //______________________________________________________________________________ const char *RecoTOFInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoTOFInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int RecoTOFInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoTOFInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *RecoTOFInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoTOFInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *RecoTOFInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoTOFInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr RecoBAMAInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *RecoBAMAInfo::Class_Name() { return "RecoBAMAInfo"; } //______________________________________________________________________________ const char *RecoBAMAInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoBAMAInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int RecoBAMAInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoBAMAInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *RecoBAMAInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoBAMAInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *RecoBAMAInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoBAMAInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr RecoNNIVInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *RecoNNIVInfo::Class_Name() { return "RecoNNIVInfo"; } //______________________________________________________________________________ const char *RecoNNIVInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoNNIVInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int RecoNNIVInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoNNIVInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *RecoNNIVInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoNNIVInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *RecoNNIVInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoNNIVInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr CocoRecoInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *CocoRecoInfo::Class_Name() { return "CocoRecoInfo"; } //______________________________________________________________________________ const char *CocoRecoInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::CocoRecoInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int CocoRecoInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::CocoRecoInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *CocoRecoInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::CocoRecoInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *CocoRecoInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::CocoRecoInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr RecoEnergyInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *RecoEnergyInfo::Class_Name() { return "RecoEnergyInfo"; } //______________________________________________________________________________ const char *RecoEnergyInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoEnergyInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int RecoEnergyInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoEnergyInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *RecoEnergyInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoEnergyInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *RecoEnergyInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoEnergyInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr ERecoHDInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *ERecoHDInfo::Class_Name() { return "ERecoHDInfo"; } //______________________________________________________________________________ const char *ERecoHDInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::ERecoHDInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int ERecoHDInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::ERecoHDInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *ERecoHDInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ERecoHDInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *ERecoHDInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ERecoHDInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr RecoThInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *RecoThInfo::Class_Name() { return "RecoThInfo"; } //______________________________________________________________________________ const char *RecoThInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoThInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int RecoThInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoThInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *RecoThInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoThInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *RecoThInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoThInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr RecoMuonInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *RecoMuonInfo::Class_Name() { return "RecoMuonInfo"; } //______________________________________________________________________________ const char *RecoMuonInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int RecoMuonInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *RecoMuonInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *RecoMuonInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr RecoMuonThInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *RecoMuonThInfo::Class_Name() { return "RecoMuonThInfo"; } //______________________________________________________________________________ const char *RecoMuonThInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonThInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int RecoMuonThInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonThInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *RecoMuonThInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonThInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *RecoMuonThInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonThInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr RecoMuonAPCInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *RecoMuonAPCInfo::Class_Name() { return "RecoMuonAPCInfo"; } //______________________________________________________________________________ const char *RecoMuonAPCInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonAPCInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int RecoMuonAPCInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonAPCInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *RecoMuonAPCInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonAPCInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *RecoMuonAPCInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonAPCInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr RecoMuonIVBCInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *RecoMuonIVBCInfo::Class_Name() { return "RecoMuonIVBCInfo"; } //______________________________________________________________________________ const char *RecoMuonIVBCInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonIVBCInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int RecoMuonIVBCInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonIVBCInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *RecoMuonIVBCInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonIVBCInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *RecoMuonIVBCInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonIVBCInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr RecoMuonIVMLInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *RecoMuonIVMLInfo::Class_Name() { return "RecoMuonIVMLInfo"; } //______________________________________________________________________________ const char *RecoMuonIVMLInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonIVMLInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int RecoMuonIVMLInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonIVMLInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *RecoMuonIVMLInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonIVMLInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *RecoMuonIVMLInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonIVMLInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr RecoMuHamIDInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *RecoMuHamIDInfo::Class_Name() { return "RecoMuHamIDInfo"; } //______________________________________________________________________________ const char *RecoMuHamIDInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoMuHamIDInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int RecoMuHamIDInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoMuHamIDInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *RecoMuHamIDInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoMuHamIDInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *RecoMuHamIDInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoMuHamIDInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr RecoMuonFIDOInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *RecoMuonFIDOInfo::Class_Name() { return "RecoMuonFIDOInfo"; } //______________________________________________________________________________ const char *RecoMuonFIDOInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonFIDOInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int RecoMuonFIDOInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonFIDOInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *RecoMuonFIDOInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonFIDOInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *RecoMuonFIDOInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoMuonFIDOInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr RecoOVMergeInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *RecoOVMergeInfo::Class_Name() { return "RecoOVMergeInfo"; } //______________________________________________________________________________ const char *RecoOVMergeInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoOVMergeInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int RecoOVMergeInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoOVMergeInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *RecoOVMergeInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoOVMergeInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *RecoOVMergeInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoOVMergeInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr OVXYInFile::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *OVXYInFile::Class_Name() { return "OVXYInFile"; } //______________________________________________________________________________ const char *OVXYInFile::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::OVXYInFile*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int OVXYInFile::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::OVXYInFile*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *OVXYInFile::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::OVXYInFile*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *OVXYInFile::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::OVXYInFile*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr OVTrackInFile::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *OVTrackInFile::Class_Name() { return "OVTrackInFile"; } //______________________________________________________________________________ const char *OVTrackInFile::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::OVTrackInFile*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int OVTrackInFile::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::OVTrackInFile*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *OVTrackInFile::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::OVTrackInFile*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *OVTrackInFile::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::OVTrackInFile*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr RecoDtInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *RecoDtInfo::Class_Name() { return "RecoDtInfo"; } //______________________________________________________________________________ const char *RecoDtInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoDtInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int RecoDtInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoDtInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *RecoDtInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoDtInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *RecoDtInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoDtInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr CalibrationInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *CalibrationInfo::Class_Name() { return "CalibrationInfo"; } //______________________________________________________________________________ const char *CalibrationInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::CalibrationInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int CalibrationInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::CalibrationInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *CalibrationInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::CalibrationInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *CalibrationInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::CalibrationInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr IDLIInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *IDLIInfo::Class_Name() { return "IDLIInfo"; } //______________________________________________________________________________ const char *IDLIInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::IDLIInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int IDLIInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::IDLIInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *IDLIInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::IDLIInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *IDLIInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::IDLIInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr ParticleThInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *ParticleThInfo::Class_Name() { return "ParticleThInfo"; } //______________________________________________________________________________ const char *ParticleThInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::ParticleThInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int ParticleThInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::ParticleThInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *ParticleThInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ParticleThInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *ParticleThInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ParticleThInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr TrackThInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *TrackThInfo::Class_Name() { return "TrackThInfo"; } //______________________________________________________________________________ const char *TrackThInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::TrackThInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int TrackThInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::TrackThInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *TrackThInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TrackThInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *TrackThInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TrackThInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr MCInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *MCInfo::Class_Name() { return "MCInfo"; } //______________________________________________________________________________ const char *MCInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::MCInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int MCInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::MCInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *MCInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MCInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *MCInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MCInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr RunInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *RunInfo::Class_Name() { return "RunInfo"; } //______________________________________________________________________________ const char *RunInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RunInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int RunInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RunInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *RunInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RunInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *RunInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RunInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr TMFileThInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *TMFileThInfo::Class_Name() { return "TMFileThInfo"; } //______________________________________________________________________________ const char *TMFileThInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::TMFileThInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int TMFileThInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::TMFileThInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *TMFileThInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMFileThInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *TMFileThInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMFileThInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr DynRunInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *DynRunInfo::Class_Name() { return "DynRunInfo"; } //______________________________________________________________________________ const char *DynRunInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::DynRunInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int DynRunInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::DynRunInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *DynRunInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::DynRunInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *DynRunInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::DynRunInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr DynEventInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *DynEventInfo::Class_Name() { return "DynEventInfo"; } //______________________________________________________________________________ const char *DynEventInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::DynEventInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int DynEventInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::DynEventInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *DynEventInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::DynEventInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *DynEventInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::DynEventInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr NuGenThInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *NuGenThInfo::Class_Name() { return "NuGenThInfo"; } //______________________________________________________________________________ const char *NuGenThInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::NuGenThInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int NuGenThInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::NuGenThInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *NuGenThInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::NuGenThInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *NuGenThInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::NuGenThInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr MCStep::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *MCStep::Class_Name() { return "MCStep"; } //______________________________________________________________________________ const char *MCStep::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::MCStep*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int MCStep::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::MCStep*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *MCStep::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MCStep*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *MCStep::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MCStep*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr MCTrack::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *MCTrack::Class_Name() { return "MCTrack"; } //______________________________________________________________________________ const char *MCTrack::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::MCTrack*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int MCTrack::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::MCTrack*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *MCTrack::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MCTrack*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *MCTrack::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MCTrack*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr OVHitInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *OVHitInfo::Class_Name() { return "OVHitInfo"; } //______________________________________________________________________________ const char *OVHitInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::OVHitInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int OVHitInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::OVHitInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *OVHitInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::OVHitInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *OVHitInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::OVHitInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr OVHitThInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *OVHitThInfo::Class_Name() { return "OVHitThInfo"; } //______________________________________________________________________________ const char *OVHitThInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::OVHitThInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int OVHitThInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::OVHitThInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *OVHitThInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::OVHitThInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *OVHitThInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::OVHitThInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr TriggerSummarizedInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *TriggerSummarizedInfo::Class_Name() { return "TriggerSummarizedInfo"; } //______________________________________________________________________________ const char *TriggerSummarizedInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::TriggerSummarizedInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int TriggerSummarizedInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::TriggerSummarizedInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *TriggerSummarizedInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TriggerSummarizedInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *TriggerSummarizedInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TriggerSummarizedInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr TriggerInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *TriggerInfo::Class_Name() { return "TriggerInfo"; } //______________________________________________________________________________ const char *TriggerInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::TriggerInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int TriggerInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::TriggerInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *TriggerInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TriggerInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *TriggerInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TriggerInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr TBInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *TBInfo::Class_Name() { return "TBInfo"; } //______________________________________________________________________________ const char *TBInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::TBInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int TBInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::TBInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *TBInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TBInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *TBInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TBInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr TMBInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *TMBInfo::Class_Name() { return "TMBInfo"; } //______________________________________________________________________________ const char *TMBInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::TMBInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int TMBInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::TMBInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *TMBInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMBInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *TMBInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMBInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr TriggerDiagnosisInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *TriggerDiagnosisInfo::Class_Name() { return "TriggerDiagnosisInfo"; } //______________________________________________________________________________ const char *TriggerDiagnosisInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::TriggerDiagnosisInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int TriggerDiagnosisInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::TriggerDiagnosisInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *TriggerDiagnosisInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TriggerDiagnosisInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *TriggerDiagnosisInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TriggerDiagnosisInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr LightInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *LightInfo::Class_Name() { return "LightInfo"; } //______________________________________________________________________________ const char *LightInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::LightInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int LightInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::LightInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *LightInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::LightInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *LightInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::LightInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr LightEUpp::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *LightEUpp::Class_Name() { return "LightEUpp"; } //______________________________________________________________________________ const char *LightEUpp::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::LightEUpp*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int LightEUpp::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::LightEUpp*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *LightEUpp::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::LightEUpp*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *LightEUpp::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::LightEUpp*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr LightJP::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *LightJP::Class_Name() { return "LightJP"; } //______________________________________________________________________________ const char *LightJP::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::LightJP*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int LightJP::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::LightJP*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *LightJP::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::LightJP*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *LightJP::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::LightJP*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr LightUnited::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *LightUnited::Class_Name() { return "LightUnited"; } //______________________________________________________________________________ const char *LightUnited::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::LightUnited*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int LightUnited::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::LightUnited*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *LightUnited::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::LightUnited*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *LightUnited::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::LightUnited*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr LightAPCMS::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *LightAPCMS::Class_Name() { return "LightAPCMS"; } //______________________________________________________________________________ const char *LightAPCMS::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::LightAPCMS*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int LightAPCMS::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::LightAPCMS*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *LightAPCMS::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::LightAPCMS*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *LightAPCMS::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::LightAPCMS*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr Accidental::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *Accidental::Class_Name() { return "Accidental"; } //______________________________________________________________________________ const char *Accidental::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::Accidental*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int Accidental::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::Accidental*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *Accidental::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Accidental*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *Accidental::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Accidental*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr RecoJPInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *RecoJPInfo::Class_Name() { return "RecoJPInfo"; } //______________________________________________________________________________ const char *RecoJPInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoJPInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int RecoJPInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::RecoJPInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *RecoJPInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoJPInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *RecoJPInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::RecoJPInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr MiniPulseInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *MiniPulseInfo::Class_Name() { return "MiniPulseInfo"; } //______________________________________________________________________________ const char *MiniPulseInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::MiniPulseInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int MiniPulseInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::MiniPulseInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *MiniPulseInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MiniPulseInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *MiniPulseInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MiniPulseInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr MuonTDCInfo::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *MuonTDCInfo::Class_Name() { return "MuonTDCInfo"; } //______________________________________________________________________________ const char *MuonTDCInfo::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::MuonTDCInfo*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int MuonTDCInfo::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::MuonTDCInfo*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *MuonTDCInfo::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MuonTDCInfo*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *MuonTDCInfo::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::MuonTDCInfo*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ atomic_TClass_ptr EnDep::fgIsA(nullptr); // static to hold class pointer //______________________________________________________________________________ const char *EnDep::Class_Name() { return "EnDep"; } //______________________________________________________________________________ const char *EnDep::ImplFileName() { return ::ROOT::GenerateInitInstanceLocal((const ::EnDep*)nullptr)->GetImplFileName(); } //______________________________________________________________________________ int EnDep::ImplFileLine() { return ::ROOT::GenerateInitInstanceLocal((const ::EnDep*)nullptr)->GetImplFileLine(); } //______________________________________________________________________________ TClass *EnDep::Dictionary() { fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::EnDep*)nullptr)->GetClass(); return fgIsA; } //______________________________________________________________________________ TClass *EnDep::Class() { if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::EnDep*)nullptr)->GetClass(); } return fgIsA; } //______________________________________________________________________________ void ParamStore::Streamer(TBuffer &R__b) { // Stream an object of class ParamStore. if (R__b.IsReading()) { R__b.ReadClassBuffer(ParamStore::Class(),this); } else { R__b.WriteClassBuffer(ParamStore::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_ParamStore(void *p) { return p ? new(p) ::ParamStore : new ::ParamStore; } static void *newArray_ParamStore(Long_t nElements, void *p) { return p ? new(p) ::ParamStore[nElements] : new ::ParamStore[nElements]; } // Wrapper around operator delete static void delete_ParamStore(void *p) { delete (static_cast<::ParamStore*>(p)); } static void deleteArray_ParamStore(void *p) { delete [] (static_cast<::ParamStore*>(p)); } static void destruct_ParamStore(void *p) { typedef ::ParamStore current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::ParamStore namespace ROOT { // Wrapper around operator delete static void delete_IProcess(void *p) { delete (static_cast<::IProcess*>(p)); } static void deleteArray_IProcess(void *p) { delete [] (static_cast<::IProcess*>(p)); } static void destruct_IProcess(void *p) { typedef ::IProcess current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::IProcess //______________________________________________________________________________ void InfoUnit::Streamer(TBuffer &R__b) { // Stream an object of class InfoUnit. if (R__b.IsReading()) { R__b.ReadClassBuffer(InfoUnit::Class(),this); } else { R__b.WriteClassBuffer(InfoUnit::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_InfoUnit(void *p) { return p ? new(p) ::InfoUnit : new ::InfoUnit; } static void *newArray_InfoUnit(Long_t nElements, void *p) { return p ? new(p) ::InfoUnit[nElements] : new ::InfoUnit[nElements]; } // Wrapper around operator delete static void delete_InfoUnit(void *p) { delete (static_cast<::InfoUnit*>(p)); } static void deleteArray_InfoUnit(void *p) { delete [] (static_cast<::InfoUnit*>(p)); } static void destruct_InfoUnit(void *p) { typedef ::InfoUnit current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::InfoUnit namespace ROOT { } // end of namespace ROOT for class ::Processor namespace ROOT { } // end of namespace ROOT for class ::LoopProcessor //______________________________________________________________________________ void PMTHit::Streamer(TBuffer &R__b) { // Stream an object of class PMTHit. if (R__b.IsReading()) { R__b.ReadClassBuffer(PMTHit::Class(),this); } else { R__b.WriteClassBuffer(PMTHit::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_PMTHit(void *p) { return p ? new(p) ::PMTHit : new ::PMTHit; } static void *newArray_PMTHit(Long_t nElements, void *p) { return p ? new(p) ::PMTHit[nElements] : new ::PMTHit[nElements]; } // Wrapper around operator delete static void delete_PMTHit(void *p) { delete (static_cast<::PMTHit*>(p)); } static void deleteArray_PMTHit(void *p) { delete [] (static_cast<::PMTHit*>(p)); } static void destruct_PMTHit(void *p) { typedef ::PMTHit current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::PMTHit //______________________________________________________________________________ void ParameterInfo::Streamer(TBuffer &R__b) { // Stream an object of class ParameterInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(ParameterInfo::Class(),this); } else { R__b.WriteClassBuffer(ParameterInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_ParameterInfo(void *p) { return p ? new(p) ::ParameterInfo : new ::ParameterInfo; } static void *newArray_ParameterInfo(Long_t nElements, void *p) { return p ? new(p) ::ParameterInfo[nElements] : new ::ParameterInfo[nElements]; } // Wrapper around operator delete static void delete_ParameterInfo(void *p) { delete (static_cast<::ParameterInfo*>(p)); } static void deleteArray_ParameterInfo(void *p) { delete [] (static_cast<::ParameterInfo*>(p)); } static void destruct_ParameterInfo(void *p) { typedef ::ParameterInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::ParameterInfo //______________________________________________________________________________ void OVHit::Streamer(TBuffer &R__b) { // Stream an object of class OVHit. if (R__b.IsReading()) { R__b.ReadClassBuffer(OVHit::Class(),this); } else { R__b.WriteClassBuffer(OVHit::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_OVHit(void *p) { return p ? new(p) ::OVHit : new ::OVHit; } static void *newArray_OVHit(Long_t nElements, void *p) { return p ? new(p) ::OVHit[nElements] : new ::OVHit[nElements]; } // Wrapper around operator delete static void delete_OVHit(void *p) { delete (static_cast<::OVHit*>(p)); } static void deleteArray_OVHit(void *p) { delete [] (static_cast<::OVHit*>(p)); } static void destruct_OVHit(void *p) { typedef ::OVHit current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::OVHit //______________________________________________________________________________ void OVInfo::Streamer(TBuffer &R__b) { // Stream an object of class OVInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(OVInfo::Class(),this); } else { R__b.WriteClassBuffer(OVInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_OVInfo(void *p) { return p ? new(p) ::OVInfo : new ::OVInfo; } static void *newArray_OVInfo(Long_t nElements, void *p) { return p ? new(p) ::OVInfo[nElements] : new ::OVInfo[nElements]; } // Wrapper around operator delete static void delete_OVInfo(void *p) { delete (static_cast<::OVInfo*>(p)); } static void deleteArray_OVInfo(void *p) { delete [] (static_cast<::OVInfo*>(p)); } static void destruct_OVInfo(void *p) { typedef ::OVInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::OVInfo //______________________________________________________________________________ void OVCell::Streamer(TBuffer &R__b) { // Stream an object of class OVCell. if (R__b.IsReading()) { R__b.ReadClassBuffer(OVCell::Class(),this); } else { R__b.WriteClassBuffer(OVCell::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_OVCell(void *p) { return p ? new(p) ::OVCell : new ::OVCell; } static void *newArray_OVCell(Long_t nElements, void *p) { return p ? new(p) ::OVCell[nElements] : new ::OVCell[nElements]; } // Wrapper around operator delete static void delete_OVCell(void *p) { delete (static_cast<::OVCell*>(p)); } static void deleteArray_OVCell(void *p) { delete [] (static_cast<::OVCell*>(p)); } static void destruct_OVCell(void *p) { typedef ::OVCell current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::OVCell namespace ROOT { // Wrappers around operator new static void *new_FileDB(void *p) { return p ? new(p) ::FileDB : new ::FileDB; } static void *newArray_FileDB(Long_t nElements, void *p) { return p ? new(p) ::FileDB[nElements] : new ::FileDB[nElements]; } // Wrapper around operator delete static void delete_FileDB(void *p) { delete (static_cast<::FileDB*>(p)); } static void deleteArray_FileDB(void *p) { delete [] (static_cast<::FileDB*>(p)); } static void destruct_FileDB(void *p) { typedef ::FileDB current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::FileDB namespace ROOT { // Wrappers around operator new static void *new_InfoIO(void *p) { return p ? new(p) ::InfoIO : new ::InfoIO; } static void *newArray_InfoIO(Long_t nElements, void *p) { return p ? new(p) ::InfoIO[nElements] : new ::InfoIO[nElements]; } // Wrapper around operator delete static void delete_InfoIO(void *p) { delete (static_cast<::InfoIO*>(p)); } static void deleteArray_InfoIO(void *p) { delete [] (static_cast<::InfoIO*>(p)); } static void destruct_InfoIO(void *p) { typedef ::InfoIO current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::InfoIO //______________________________________________________________________________ void GlobalInfo::Streamer(TBuffer &R__b) { // Stream an object of class GlobalInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(GlobalInfo::Class(),this); } else { R__b.WriteClassBuffer(GlobalInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_GlobalInfo(void *p) { return p ? new(p) ::GlobalInfo : new ::GlobalInfo; } static void *newArray_GlobalInfo(Long_t nElements, void *p) { return p ? new(p) ::GlobalInfo[nElements] : new ::GlobalInfo[nElements]; } // Wrapper around operator delete static void delete_GlobalInfo(void *p) { delete (static_cast<::GlobalInfo*>(p)); } static void deleteArray_GlobalInfo(void *p) { delete [] (static_cast<::GlobalInfo*>(p)); } static void destruct_GlobalInfo(void *p) { typedef ::GlobalInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::GlobalInfo //______________________________________________________________________________ void GlobalThInfo::Streamer(TBuffer &R__b) { // Stream an object of class GlobalThInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(GlobalThInfo::Class(),this); } else { R__b.WriteClassBuffer(GlobalThInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_GlobalThInfo(void *p) { return p ? new(p) ::GlobalThInfo : new ::GlobalThInfo; } static void *newArray_GlobalThInfo(Long_t nElements, void *p) { return p ? new(p) ::GlobalThInfo[nElements] : new ::GlobalThInfo[nElements]; } // Wrapper around operator delete static void delete_GlobalThInfo(void *p) { delete (static_cast<::GlobalThInfo*>(p)); } static void deleteArray_GlobalThInfo(void *p) { delete [] (static_cast<::GlobalThInfo*>(p)); } static void destruct_GlobalThInfo(void *p) { typedef ::GlobalThInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::GlobalThInfo //______________________________________________________________________________ void PulseInfo::Streamer(TBuffer &R__b) { // Stream an object of class PulseInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(PulseInfo::Class(),this); } else { R__b.WriteClassBuffer(PulseInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_PulseInfo(void *p) { return p ? new(p) ::PulseInfo : new ::PulseInfo; } static void *newArray_PulseInfo(Long_t nElements, void *p) { return p ? new(p) ::PulseInfo[nElements] : new ::PulseInfo[nElements]; } // Wrapper around operator delete static void delete_PulseInfo(void *p) { delete (static_cast<::PulseInfo*>(p)); } static void deleteArray_PulseInfo(void *p) { delete [] (static_cast<::PulseInfo*>(p)); } static void destruct_PulseInfo(void *p) { typedef ::PulseInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::PulseInfo //______________________________________________________________________________ void PulsePeakWinInfo::Streamer(TBuffer &R__b) { // Stream an object of class PulsePeakWinInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(PulsePeakWinInfo::Class(),this); } else { R__b.WriteClassBuffer(PulsePeakWinInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_PulsePeakWinInfo(void *p) { return p ? new(p) ::PulsePeakWinInfo : new ::PulsePeakWinInfo; } static void *newArray_PulsePeakWinInfo(Long_t nElements, void *p) { return p ? new(p) ::PulsePeakWinInfo[nElements] : new ::PulsePeakWinInfo[nElements]; } // Wrapper around operator delete static void delete_PulsePeakWinInfo(void *p) { delete (static_cast<::PulsePeakWinInfo*>(p)); } static void deleteArray_PulsePeakWinInfo(void *p) { delete [] (static_cast<::PulsePeakWinInfo*>(p)); } static void destruct_PulsePeakWinInfo(void *p) { typedef ::PulsePeakWinInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::PulsePeakWinInfo //______________________________________________________________________________ void PulseSlideWinInfo::Streamer(TBuffer &R__b) { // Stream an object of class PulseSlideWinInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(PulseSlideWinInfo::Class(),this); } else { R__b.WriteClassBuffer(PulseSlideWinInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_PulseSlideWinInfo(void *p) { return p ? new(p) ::PulseSlideWinInfo : new ::PulseSlideWinInfo; } static void *newArray_PulseSlideWinInfo(Long_t nElements, void *p) { return p ? new(p) ::PulseSlideWinInfo[nElements] : new ::PulseSlideWinInfo[nElements]; } // Wrapper around operator delete static void delete_PulseSlideWinInfo(void *p) { delete (static_cast<::PulseSlideWinInfo*>(p)); } static void deleteArray_PulseSlideWinInfo(void *p) { delete [] (static_cast<::PulseSlideWinInfo*>(p)); } static void destruct_PulseSlideWinInfo(void *p) { typedef ::PulseSlideWinInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::PulseSlideWinInfo //______________________________________________________________________________ void PulseThInfo::Streamer(TBuffer &R__b) { // Stream an object of class PulseThInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(PulseThInfo::Class(),this); } else { R__b.WriteClassBuffer(PulseThInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_PulseThInfo(void *p) { return p ? new(p) ::PulseThInfo : new ::PulseThInfo; } static void *newArray_PulseThInfo(Long_t nElements, void *p) { return p ? new(p) ::PulseThInfo[nElements] : new ::PulseThInfo[nElements]; } // Wrapper around operator delete static void delete_PulseThInfo(void *p) { delete (static_cast<::PulseThInfo*>(p)); } static void deleteArray_PulseThInfo(void *p) { delete [] (static_cast<::PulseThInfo*>(p)); } static void destruct_PulseThInfo(void *p) { typedef ::PulseThInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::PulseThInfo //______________________________________________________________________________ void PulseProfInfo::Streamer(TBuffer &R__b) { // Stream an object of class PulseProfInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(PulseProfInfo::Class(),this); } else { R__b.WriteClassBuffer(PulseProfInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_PulseProfInfo(void *p) { return p ? new(p) ::PulseProfInfo : new ::PulseProfInfo; } static void *newArray_PulseProfInfo(Long_t nElements, void *p) { return p ? new(p) ::PulseProfInfo[nElements] : new ::PulseProfInfo[nElements]; } // Wrapper around operator delete static void delete_PulseProfInfo(void *p) { delete (static_cast<::PulseProfInfo*>(p)); } static void deleteArray_PulseProfInfo(void *p) { delete [] (static_cast<::PulseProfInfo*>(p)); } static void destruct_PulseProfInfo(void *p) { typedef ::PulseProfInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::PulseProfInfo //______________________________________________________________________________ void PulseProfThInfo::Streamer(TBuffer &R__b) { // Stream an object of class PulseProfThInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(PulseProfThInfo::Class(),this); } else { R__b.WriteClassBuffer(PulseProfThInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_PulseProfThInfo(void *p) { return p ? new(p) ::PulseProfThInfo : new ::PulseProfThInfo; } static void *newArray_PulseProfThInfo(Long_t nElements, void *p) { return p ? new(p) ::PulseProfThInfo[nElements] : new ::PulseProfThInfo[nElements]; } // Wrapper around operator delete static void delete_PulseProfThInfo(void *p) { delete (static_cast<::PulseProfThInfo*>(p)); } static void deleteArray_PulseProfThInfo(void *p) { delete [] (static_cast<::PulseProfThInfo*>(p)); } static void destruct_PulseProfThInfo(void *p) { typedef ::PulseProfThInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::PulseProfThInfo //______________________________________________________________________________ void MuPulseInfo::Streamer(TBuffer &R__b) { // Stream an object of class MuPulseInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(MuPulseInfo::Class(),this); } else { R__b.WriteClassBuffer(MuPulseInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_MuPulseInfo(void *p) { return p ? new(p) ::MuPulseInfo : new ::MuPulseInfo; } static void *newArray_MuPulseInfo(Long_t nElements, void *p) { return p ? new(p) ::MuPulseInfo[nElements] : new ::MuPulseInfo[nElements]; } // Wrapper around operator delete static void delete_MuPulseInfo(void *p) { delete (static_cast<::MuPulseInfo*>(p)); } static void deleteArray_MuPulseInfo(void *p) { delete [] (static_cast<::MuPulseInfo*>(p)); } static void destruct_MuPulseInfo(void *p) { typedef ::MuPulseInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::MuPulseInfo //______________________________________________________________________________ void MuPulseThInfo::Streamer(TBuffer &R__b) { // Stream an object of class MuPulseThInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(MuPulseThInfo::Class(),this); } else { R__b.WriteClassBuffer(MuPulseThInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_MuPulseThInfo(void *p) { return p ? new(p) ::MuPulseThInfo : new ::MuPulseThInfo; } static void *newArray_MuPulseThInfo(Long_t nElements, void *p) { return p ? new(p) ::MuPulseThInfo[nElements] : new ::MuPulseThInfo[nElements]; } // Wrapper around operator delete static void delete_MuPulseThInfo(void *p) { delete (static_cast<::MuPulseThInfo*>(p)); } static void deleteArray_MuPulseThInfo(void *p) { delete [] (static_cast<::MuPulseThInfo*>(p)); } static void destruct_MuPulseThInfo(void *p) { typedef ::MuPulseThInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::MuPulseThInfo //______________________________________________________________________________ void MuPulseProfInfo::Streamer(TBuffer &R__b) { // Stream an object of class MuPulseProfInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(MuPulseProfInfo::Class(),this); } else { R__b.WriteClassBuffer(MuPulseProfInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_MuPulseProfInfo(void *p) { return p ? new(p) ::MuPulseProfInfo : new ::MuPulseProfInfo; } static void *newArray_MuPulseProfInfo(Long_t nElements, void *p) { return p ? new(p) ::MuPulseProfInfo[nElements] : new ::MuPulseProfInfo[nElements]; } // Wrapper around operator delete static void delete_MuPulseProfInfo(void *p) { delete (static_cast<::MuPulseProfInfo*>(p)); } static void deleteArray_MuPulseProfInfo(void *p) { delete [] (static_cast<::MuPulseProfInfo*>(p)); } static void destruct_MuPulseProfInfo(void *p) { typedef ::MuPulseProfInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::MuPulseProfInfo //______________________________________________________________________________ void MuPulseProfThInfo::Streamer(TBuffer &R__b) { // Stream an object of class MuPulseProfThInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(MuPulseProfThInfo::Class(),this); } else { R__b.WriteClassBuffer(MuPulseProfThInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_MuPulseProfThInfo(void *p) { return p ? new(p) ::MuPulseProfThInfo : new ::MuPulseProfThInfo; } static void *newArray_MuPulseProfThInfo(Long_t nElements, void *p) { return p ? new(p) ::MuPulseProfThInfo[nElements] : new ::MuPulseProfThInfo[nElements]; } // Wrapper around operator delete static void delete_MuPulseProfThInfo(void *p) { delete (static_cast<::MuPulseProfThInfo*>(p)); } static void deleteArray_MuPulseProfThInfo(void *p) { delete [] (static_cast<::MuPulseProfThInfo*>(p)); } static void destruct_MuPulseProfThInfo(void *p) { typedef ::MuPulseProfThInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::MuPulseProfThInfo //______________________________________________________________________________ void RecoVertexInfo::Streamer(TBuffer &R__b) { // Stream an object of class RecoVertexInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(RecoVertexInfo::Class(),this); } else { R__b.WriteClassBuffer(RecoVertexInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_RecoVertexInfo(void *p) { return p ? new(p) ::RecoVertexInfo : new ::RecoVertexInfo; } static void *newArray_RecoVertexInfo(Long_t nElements, void *p) { return p ? new(p) ::RecoVertexInfo[nElements] : new ::RecoVertexInfo[nElements]; } // Wrapper around operator delete static void delete_RecoVertexInfo(void *p) { delete (static_cast<::RecoVertexInfo*>(p)); } static void deleteArray_RecoVertexInfo(void *p) { delete [] (static_cast<::RecoVertexInfo*>(p)); } static void destruct_RecoVertexInfo(void *p) { typedef ::RecoVertexInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RecoVertexInfo //______________________________________________________________________________ void RecoTrackInfo::Streamer(TBuffer &R__b) { // Stream an object of class RecoTrackInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(RecoTrackInfo::Class(),this); } else { R__b.WriteClassBuffer(RecoTrackInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_RecoTrackInfo(void *p) { return p ? new(p) ::RecoTrackInfo : new ::RecoTrackInfo; } static void *newArray_RecoTrackInfo(Long_t nElements, void *p) { return p ? new(p) ::RecoTrackInfo[nElements] : new ::RecoTrackInfo[nElements]; } // Wrapper around operator delete static void delete_RecoTrackInfo(void *p) { delete (static_cast<::RecoTrackInfo*>(p)); } static void deleteArray_RecoTrackInfo(void *p) { delete [] (static_cast<::RecoTrackInfo*>(p)); } static void destruct_RecoTrackInfo(void *p) { typedef ::RecoTrackInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RecoTrackInfo //______________________________________________________________________________ void RecoMOSCOWInfo::Streamer(TBuffer &R__b) { // Stream an object of class RecoMOSCOWInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(RecoMOSCOWInfo::Class(),this); } else { R__b.WriteClassBuffer(RecoMOSCOWInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_RecoMOSCOWInfo(void *p) { return p ? new(p) ::RecoMOSCOWInfo : new ::RecoMOSCOWInfo; } static void *newArray_RecoMOSCOWInfo(Long_t nElements, void *p) { return p ? new(p) ::RecoMOSCOWInfo[nElements] : new ::RecoMOSCOWInfo[nElements]; } // Wrapper around operator delete static void delete_RecoMOSCOWInfo(void *p) { delete (static_cast<::RecoMOSCOWInfo*>(p)); } static void deleteArray_RecoMOSCOWInfo(void *p) { delete [] (static_cast<::RecoMOSCOWInfo*>(p)); } static void destruct_RecoMOSCOWInfo(void *p) { typedef ::RecoMOSCOWInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RecoMOSCOWInfo //______________________________________________________________________________ void RecoTOFInfo::Streamer(TBuffer &R__b) { // Stream an object of class RecoTOFInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(RecoTOFInfo::Class(),this); } else { R__b.WriteClassBuffer(RecoTOFInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_RecoTOFInfo(void *p) { return p ? new(p) ::RecoTOFInfo : new ::RecoTOFInfo; } static void *newArray_RecoTOFInfo(Long_t nElements, void *p) { return p ? new(p) ::RecoTOFInfo[nElements] : new ::RecoTOFInfo[nElements]; } // Wrapper around operator delete static void delete_RecoTOFInfo(void *p) { delete (static_cast<::RecoTOFInfo*>(p)); } static void deleteArray_RecoTOFInfo(void *p) { delete [] (static_cast<::RecoTOFInfo*>(p)); } static void destruct_RecoTOFInfo(void *p) { typedef ::RecoTOFInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RecoTOFInfo //______________________________________________________________________________ void RecoBAMAInfo::Streamer(TBuffer &R__b) { // Stream an object of class RecoBAMAInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(RecoBAMAInfo::Class(),this); } else { R__b.WriteClassBuffer(RecoBAMAInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_RecoBAMAInfo(void *p) { return p ? new(p) ::RecoBAMAInfo : new ::RecoBAMAInfo; } static void *newArray_RecoBAMAInfo(Long_t nElements, void *p) { return p ? new(p) ::RecoBAMAInfo[nElements] : new ::RecoBAMAInfo[nElements]; } // Wrapper around operator delete static void delete_RecoBAMAInfo(void *p) { delete (static_cast<::RecoBAMAInfo*>(p)); } static void deleteArray_RecoBAMAInfo(void *p) { delete [] (static_cast<::RecoBAMAInfo*>(p)); } static void destruct_RecoBAMAInfo(void *p) { typedef ::RecoBAMAInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RecoBAMAInfo //______________________________________________________________________________ void RecoNNIVInfo::Streamer(TBuffer &R__b) { // Stream an object of class RecoNNIVInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(RecoNNIVInfo::Class(),this); } else { R__b.WriteClassBuffer(RecoNNIVInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_RecoNNIVInfo(void *p) { return p ? new(p) ::RecoNNIVInfo : new ::RecoNNIVInfo; } static void *newArray_RecoNNIVInfo(Long_t nElements, void *p) { return p ? new(p) ::RecoNNIVInfo[nElements] : new ::RecoNNIVInfo[nElements]; } // Wrapper around operator delete static void delete_RecoNNIVInfo(void *p) { delete (static_cast<::RecoNNIVInfo*>(p)); } static void deleteArray_RecoNNIVInfo(void *p) { delete [] (static_cast<::RecoNNIVInfo*>(p)); } static void destruct_RecoNNIVInfo(void *p) { typedef ::RecoNNIVInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RecoNNIVInfo //______________________________________________________________________________ void CocoRecoInfo::Streamer(TBuffer &R__b) { // Stream an object of class CocoRecoInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(CocoRecoInfo::Class(),this); } else { R__b.WriteClassBuffer(CocoRecoInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_CocoRecoInfo(void *p) { return p ? new(p) ::CocoRecoInfo : new ::CocoRecoInfo; } static void *newArray_CocoRecoInfo(Long_t nElements, void *p) { return p ? new(p) ::CocoRecoInfo[nElements] : new ::CocoRecoInfo[nElements]; } // Wrapper around operator delete static void delete_CocoRecoInfo(void *p) { delete (static_cast<::CocoRecoInfo*>(p)); } static void deleteArray_CocoRecoInfo(void *p) { delete [] (static_cast<::CocoRecoInfo*>(p)); } static void destruct_CocoRecoInfo(void *p) { typedef ::CocoRecoInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::CocoRecoInfo //______________________________________________________________________________ void RecoEnergyInfo::Streamer(TBuffer &R__b) { // Stream an object of class RecoEnergyInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(RecoEnergyInfo::Class(),this); } else { R__b.WriteClassBuffer(RecoEnergyInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_RecoEnergyInfo(void *p) { return p ? new(p) ::RecoEnergyInfo : new ::RecoEnergyInfo; } static void *newArray_RecoEnergyInfo(Long_t nElements, void *p) { return p ? new(p) ::RecoEnergyInfo[nElements] : new ::RecoEnergyInfo[nElements]; } // Wrapper around operator delete static void delete_RecoEnergyInfo(void *p) { delete (static_cast<::RecoEnergyInfo*>(p)); } static void deleteArray_RecoEnergyInfo(void *p) { delete [] (static_cast<::RecoEnergyInfo*>(p)); } static void destruct_RecoEnergyInfo(void *p) { typedef ::RecoEnergyInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RecoEnergyInfo //______________________________________________________________________________ void ERecoHDInfo::Streamer(TBuffer &R__b) { // Stream an object of class ERecoHDInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(ERecoHDInfo::Class(),this); } else { R__b.WriteClassBuffer(ERecoHDInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_ERecoHDInfo(void *p) { return p ? new(p) ::ERecoHDInfo : new ::ERecoHDInfo; } static void *newArray_ERecoHDInfo(Long_t nElements, void *p) { return p ? new(p) ::ERecoHDInfo[nElements] : new ::ERecoHDInfo[nElements]; } // Wrapper around operator delete static void delete_ERecoHDInfo(void *p) { delete (static_cast<::ERecoHDInfo*>(p)); } static void deleteArray_ERecoHDInfo(void *p) { delete [] (static_cast<::ERecoHDInfo*>(p)); } static void destruct_ERecoHDInfo(void *p) { typedef ::ERecoHDInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::ERecoHDInfo //______________________________________________________________________________ void RecoThInfo::Streamer(TBuffer &R__b) { // Stream an object of class RecoThInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(RecoThInfo::Class(),this); } else { R__b.WriteClassBuffer(RecoThInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_RecoThInfo(void *p) { return p ? new(p) ::RecoThInfo : new ::RecoThInfo; } static void *newArray_RecoThInfo(Long_t nElements, void *p) { return p ? new(p) ::RecoThInfo[nElements] : new ::RecoThInfo[nElements]; } // Wrapper around operator delete static void delete_RecoThInfo(void *p) { delete (static_cast<::RecoThInfo*>(p)); } static void deleteArray_RecoThInfo(void *p) { delete [] (static_cast<::RecoThInfo*>(p)); } static void destruct_RecoThInfo(void *p) { typedef ::RecoThInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RecoThInfo //______________________________________________________________________________ void RecoMuonInfo::Streamer(TBuffer &R__b) { // Stream an object of class RecoMuonInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(RecoMuonInfo::Class(),this); } else { R__b.WriteClassBuffer(RecoMuonInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_RecoMuonInfo(void *p) { return p ? new(p) ::RecoMuonInfo : new ::RecoMuonInfo; } static void *newArray_RecoMuonInfo(Long_t nElements, void *p) { return p ? new(p) ::RecoMuonInfo[nElements] : new ::RecoMuonInfo[nElements]; } // Wrapper around operator delete static void delete_RecoMuonInfo(void *p) { delete (static_cast<::RecoMuonInfo*>(p)); } static void deleteArray_RecoMuonInfo(void *p) { delete [] (static_cast<::RecoMuonInfo*>(p)); } static void destruct_RecoMuonInfo(void *p) { typedef ::RecoMuonInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RecoMuonInfo //______________________________________________________________________________ void RecoMuonThInfo::Streamer(TBuffer &R__b) { // Stream an object of class RecoMuonThInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(RecoMuonThInfo::Class(),this); } else { R__b.WriteClassBuffer(RecoMuonThInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_RecoMuonThInfo(void *p) { return p ? new(p) ::RecoMuonThInfo : new ::RecoMuonThInfo; } static void *newArray_RecoMuonThInfo(Long_t nElements, void *p) { return p ? new(p) ::RecoMuonThInfo[nElements] : new ::RecoMuonThInfo[nElements]; } // Wrapper around operator delete static void delete_RecoMuonThInfo(void *p) { delete (static_cast<::RecoMuonThInfo*>(p)); } static void deleteArray_RecoMuonThInfo(void *p) { delete [] (static_cast<::RecoMuonThInfo*>(p)); } static void destruct_RecoMuonThInfo(void *p) { typedef ::RecoMuonThInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RecoMuonThInfo //______________________________________________________________________________ void RecoMuonAPCInfo::Streamer(TBuffer &R__b) { // Stream an object of class RecoMuonAPCInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(RecoMuonAPCInfo::Class(),this); } else { R__b.WriteClassBuffer(RecoMuonAPCInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_RecoMuonAPCInfo(void *p) { return p ? new(p) ::RecoMuonAPCInfo : new ::RecoMuonAPCInfo; } static void *newArray_RecoMuonAPCInfo(Long_t nElements, void *p) { return p ? new(p) ::RecoMuonAPCInfo[nElements] : new ::RecoMuonAPCInfo[nElements]; } // Wrapper around operator delete static void delete_RecoMuonAPCInfo(void *p) { delete (static_cast<::RecoMuonAPCInfo*>(p)); } static void deleteArray_RecoMuonAPCInfo(void *p) { delete [] (static_cast<::RecoMuonAPCInfo*>(p)); } static void destruct_RecoMuonAPCInfo(void *p) { typedef ::RecoMuonAPCInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RecoMuonAPCInfo //______________________________________________________________________________ void RecoMuonIVBCInfo::Streamer(TBuffer &R__b) { // Stream an object of class RecoMuonIVBCInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(RecoMuonIVBCInfo::Class(),this); } else { R__b.WriteClassBuffer(RecoMuonIVBCInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_RecoMuonIVBCInfo(void *p) { return p ? new(p) ::RecoMuonIVBCInfo : new ::RecoMuonIVBCInfo; } static void *newArray_RecoMuonIVBCInfo(Long_t nElements, void *p) { return p ? new(p) ::RecoMuonIVBCInfo[nElements] : new ::RecoMuonIVBCInfo[nElements]; } // Wrapper around operator delete static void delete_RecoMuonIVBCInfo(void *p) { delete (static_cast<::RecoMuonIVBCInfo*>(p)); } static void deleteArray_RecoMuonIVBCInfo(void *p) { delete [] (static_cast<::RecoMuonIVBCInfo*>(p)); } static void destruct_RecoMuonIVBCInfo(void *p) { typedef ::RecoMuonIVBCInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RecoMuonIVBCInfo //______________________________________________________________________________ void RecoMuonIVMLInfo::Streamer(TBuffer &R__b) { // Stream an object of class RecoMuonIVMLInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(RecoMuonIVMLInfo::Class(),this); } else { R__b.WriteClassBuffer(RecoMuonIVMLInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_RecoMuonIVMLInfo(void *p) { return p ? new(p) ::RecoMuonIVMLInfo : new ::RecoMuonIVMLInfo; } static void *newArray_RecoMuonIVMLInfo(Long_t nElements, void *p) { return p ? new(p) ::RecoMuonIVMLInfo[nElements] : new ::RecoMuonIVMLInfo[nElements]; } // Wrapper around operator delete static void delete_RecoMuonIVMLInfo(void *p) { delete (static_cast<::RecoMuonIVMLInfo*>(p)); } static void deleteArray_RecoMuonIVMLInfo(void *p) { delete [] (static_cast<::RecoMuonIVMLInfo*>(p)); } static void destruct_RecoMuonIVMLInfo(void *p) { typedef ::RecoMuonIVMLInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RecoMuonIVMLInfo //______________________________________________________________________________ void RecoMuHamIDInfo::Streamer(TBuffer &R__b) { // Stream an object of class RecoMuHamIDInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(RecoMuHamIDInfo::Class(),this); } else { R__b.WriteClassBuffer(RecoMuHamIDInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_RecoMuHamIDInfo(void *p) { return p ? new(p) ::RecoMuHamIDInfo : new ::RecoMuHamIDInfo; } static void *newArray_RecoMuHamIDInfo(Long_t nElements, void *p) { return p ? new(p) ::RecoMuHamIDInfo[nElements] : new ::RecoMuHamIDInfo[nElements]; } // Wrapper around operator delete static void delete_RecoMuHamIDInfo(void *p) { delete (static_cast<::RecoMuHamIDInfo*>(p)); } static void deleteArray_RecoMuHamIDInfo(void *p) { delete [] (static_cast<::RecoMuHamIDInfo*>(p)); } static void destruct_RecoMuHamIDInfo(void *p) { typedef ::RecoMuHamIDInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RecoMuHamIDInfo //______________________________________________________________________________ void RecoMuonFIDOInfo::Streamer(TBuffer &R__b) { // Stream an object of class RecoMuonFIDOInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(RecoMuonFIDOInfo::Class(),this); } else { R__b.WriteClassBuffer(RecoMuonFIDOInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_RecoMuonFIDOInfo(void *p) { return p ? new(p) ::RecoMuonFIDOInfo : new ::RecoMuonFIDOInfo; } static void *newArray_RecoMuonFIDOInfo(Long_t nElements, void *p) { return p ? new(p) ::RecoMuonFIDOInfo[nElements] : new ::RecoMuonFIDOInfo[nElements]; } // Wrapper around operator delete static void delete_RecoMuonFIDOInfo(void *p) { delete (static_cast<::RecoMuonFIDOInfo*>(p)); } static void deleteArray_RecoMuonFIDOInfo(void *p) { delete [] (static_cast<::RecoMuonFIDOInfo*>(p)); } static void destruct_RecoMuonFIDOInfo(void *p) { typedef ::RecoMuonFIDOInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RecoMuonFIDOInfo //______________________________________________________________________________ void RecoOVMergeInfo::Streamer(TBuffer &R__b) { // Stream an object of class RecoOVMergeInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(RecoOVMergeInfo::Class(),this); } else { R__b.WriteClassBuffer(RecoOVMergeInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_RecoOVMergeInfo(void *p) { return p ? new(p) ::RecoOVMergeInfo : new ::RecoOVMergeInfo; } static void *newArray_RecoOVMergeInfo(Long_t nElements, void *p) { return p ? new(p) ::RecoOVMergeInfo[nElements] : new ::RecoOVMergeInfo[nElements]; } // Wrapper around operator delete static void delete_RecoOVMergeInfo(void *p) { delete (static_cast<::RecoOVMergeInfo*>(p)); } static void deleteArray_RecoOVMergeInfo(void *p) { delete [] (static_cast<::RecoOVMergeInfo*>(p)); } static void destruct_RecoOVMergeInfo(void *p) { typedef ::RecoOVMergeInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RecoOVMergeInfo //______________________________________________________________________________ void OVXYInFile::Streamer(TBuffer &R__b) { // Stream an object of class OVXYInFile. if (R__b.IsReading()) { R__b.ReadClassBuffer(OVXYInFile::Class(),this); } else { R__b.WriteClassBuffer(OVXYInFile::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_OVXYInFile(void *p) { return p ? new(p) ::OVXYInFile : new ::OVXYInFile; } static void *newArray_OVXYInFile(Long_t nElements, void *p) { return p ? new(p) ::OVXYInFile[nElements] : new ::OVXYInFile[nElements]; } // Wrapper around operator delete static void delete_OVXYInFile(void *p) { delete (static_cast<::OVXYInFile*>(p)); } static void deleteArray_OVXYInFile(void *p) { delete [] (static_cast<::OVXYInFile*>(p)); } static void destruct_OVXYInFile(void *p) { typedef ::OVXYInFile current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::OVXYInFile //______________________________________________________________________________ void OVTrackInFile::Streamer(TBuffer &R__b) { // Stream an object of class OVTrackInFile. if (R__b.IsReading()) { R__b.ReadClassBuffer(OVTrackInFile::Class(),this); } else { R__b.WriteClassBuffer(OVTrackInFile::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_OVTrackInFile(void *p) { return p ? new(p) ::OVTrackInFile : new ::OVTrackInFile; } static void *newArray_OVTrackInFile(Long_t nElements, void *p) { return p ? new(p) ::OVTrackInFile[nElements] : new ::OVTrackInFile[nElements]; } // Wrapper around operator delete static void delete_OVTrackInFile(void *p) { delete (static_cast<::OVTrackInFile*>(p)); } static void deleteArray_OVTrackInFile(void *p) { delete [] (static_cast<::OVTrackInFile*>(p)); } static void destruct_OVTrackInFile(void *p) { typedef ::OVTrackInFile current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::OVTrackInFile //______________________________________________________________________________ void RecoDtInfo::Streamer(TBuffer &R__b) { // Stream an object of class RecoDtInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(RecoDtInfo::Class(),this); } else { R__b.WriteClassBuffer(RecoDtInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_RecoDtInfo(void *p) { return p ? new(p) ::RecoDtInfo : new ::RecoDtInfo; } static void *newArray_RecoDtInfo(Long_t nElements, void *p) { return p ? new(p) ::RecoDtInfo[nElements] : new ::RecoDtInfo[nElements]; } // Wrapper around operator delete static void delete_RecoDtInfo(void *p) { delete (static_cast<::RecoDtInfo*>(p)); } static void deleteArray_RecoDtInfo(void *p) { delete [] (static_cast<::RecoDtInfo*>(p)); } static void destruct_RecoDtInfo(void *p) { typedef ::RecoDtInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RecoDtInfo //______________________________________________________________________________ void CalibrationInfo::Streamer(TBuffer &R__b) { // Stream an object of class CalibrationInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(CalibrationInfo::Class(),this); } else { R__b.WriteClassBuffer(CalibrationInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_CalibrationInfo(void *p) { return p ? new(p) ::CalibrationInfo : new ::CalibrationInfo; } static void *newArray_CalibrationInfo(Long_t nElements, void *p) { return p ? new(p) ::CalibrationInfo[nElements] : new ::CalibrationInfo[nElements]; } // Wrapper around operator delete static void delete_CalibrationInfo(void *p) { delete (static_cast<::CalibrationInfo*>(p)); } static void deleteArray_CalibrationInfo(void *p) { delete [] (static_cast<::CalibrationInfo*>(p)); } static void destruct_CalibrationInfo(void *p) { typedef ::CalibrationInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::CalibrationInfo //______________________________________________________________________________ void IDLIInfo::Streamer(TBuffer &R__b) { // Stream an object of class IDLIInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(IDLIInfo::Class(),this); } else { R__b.WriteClassBuffer(IDLIInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_IDLIInfo(void *p) { return p ? new(p) ::IDLIInfo : new ::IDLIInfo; } static void *newArray_IDLIInfo(Long_t nElements, void *p) { return p ? new(p) ::IDLIInfo[nElements] : new ::IDLIInfo[nElements]; } // Wrapper around operator delete static void delete_IDLIInfo(void *p) { delete (static_cast<::IDLIInfo*>(p)); } static void deleteArray_IDLIInfo(void *p) { delete [] (static_cast<::IDLIInfo*>(p)); } static void destruct_IDLIInfo(void *p) { typedef ::IDLIInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::IDLIInfo //______________________________________________________________________________ void ParticleThInfo::Streamer(TBuffer &R__b) { // Stream an object of class ParticleThInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(ParticleThInfo::Class(),this); } else { R__b.WriteClassBuffer(ParticleThInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_ParticleThInfo(void *p) { return p ? new(p) ::ParticleThInfo : new ::ParticleThInfo; } static void *newArray_ParticleThInfo(Long_t nElements, void *p) { return p ? new(p) ::ParticleThInfo[nElements] : new ::ParticleThInfo[nElements]; } // Wrapper around operator delete static void delete_ParticleThInfo(void *p) { delete (static_cast<::ParticleThInfo*>(p)); } static void deleteArray_ParticleThInfo(void *p) { delete [] (static_cast<::ParticleThInfo*>(p)); } static void destruct_ParticleThInfo(void *p) { typedef ::ParticleThInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::ParticleThInfo //______________________________________________________________________________ void TrackThInfo::Streamer(TBuffer &R__b) { // Stream an object of class TrackThInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(TrackThInfo::Class(),this); } else { R__b.WriteClassBuffer(TrackThInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_TrackThInfo(void *p) { return p ? new(p) ::TrackThInfo : new ::TrackThInfo; } static void *newArray_TrackThInfo(Long_t nElements, void *p) { return p ? new(p) ::TrackThInfo[nElements] : new ::TrackThInfo[nElements]; } // Wrapper around operator delete static void delete_TrackThInfo(void *p) { delete (static_cast<::TrackThInfo*>(p)); } static void deleteArray_TrackThInfo(void *p) { delete [] (static_cast<::TrackThInfo*>(p)); } static void destruct_TrackThInfo(void *p) { typedef ::TrackThInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::TrackThInfo //______________________________________________________________________________ void MCInfo::Streamer(TBuffer &R__b) { // Stream an object of class MCInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(MCInfo::Class(),this); } else { R__b.WriteClassBuffer(MCInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_MCInfo(void *p) { return p ? new(p) ::MCInfo : new ::MCInfo; } static void *newArray_MCInfo(Long_t nElements, void *p) { return p ? new(p) ::MCInfo[nElements] : new ::MCInfo[nElements]; } // Wrapper around operator delete static void delete_MCInfo(void *p) { delete (static_cast<::MCInfo*>(p)); } static void deleteArray_MCInfo(void *p) { delete [] (static_cast<::MCInfo*>(p)); } static void destruct_MCInfo(void *p) { typedef ::MCInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::MCInfo //______________________________________________________________________________ void RunInfo::Streamer(TBuffer &R__b) { // Stream an object of class RunInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(RunInfo::Class(),this); } else { R__b.WriteClassBuffer(RunInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_RunInfo(void *p) { return p ? new(p) ::RunInfo : new ::RunInfo; } static void *newArray_RunInfo(Long_t nElements, void *p) { return p ? new(p) ::RunInfo[nElements] : new ::RunInfo[nElements]; } // Wrapper around operator delete static void delete_RunInfo(void *p) { delete (static_cast<::RunInfo*>(p)); } static void deleteArray_RunInfo(void *p) { delete [] (static_cast<::RunInfo*>(p)); } static void destruct_RunInfo(void *p) { typedef ::RunInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RunInfo //______________________________________________________________________________ void TMFileThInfo::Streamer(TBuffer &R__b) { // Stream an object of class TMFileThInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(TMFileThInfo::Class(),this); } else { R__b.WriteClassBuffer(TMFileThInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_TMFileThInfo(void *p) { return p ? new(p) ::TMFileThInfo : new ::TMFileThInfo; } static void *newArray_TMFileThInfo(Long_t nElements, void *p) { return p ? new(p) ::TMFileThInfo[nElements] : new ::TMFileThInfo[nElements]; } // Wrapper around operator delete static void delete_TMFileThInfo(void *p) { delete (static_cast<::TMFileThInfo*>(p)); } static void deleteArray_TMFileThInfo(void *p) { delete [] (static_cast<::TMFileThInfo*>(p)); } static void destruct_TMFileThInfo(void *p) { typedef ::TMFileThInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::TMFileThInfo //______________________________________________________________________________ void DynRunInfo::Streamer(TBuffer &R__b) { // Stream an object of class DynRunInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(DynRunInfo::Class(),this); } else { R__b.WriteClassBuffer(DynRunInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_DynRunInfo(void *p) { return p ? new(p) ::DynRunInfo : new ::DynRunInfo; } static void *newArray_DynRunInfo(Long_t nElements, void *p) { return p ? new(p) ::DynRunInfo[nElements] : new ::DynRunInfo[nElements]; } // Wrapper around operator delete static void delete_DynRunInfo(void *p) { delete (static_cast<::DynRunInfo*>(p)); } static void deleteArray_DynRunInfo(void *p) { delete [] (static_cast<::DynRunInfo*>(p)); } static void destruct_DynRunInfo(void *p) { typedef ::DynRunInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::DynRunInfo //______________________________________________________________________________ void DynEventInfo::Streamer(TBuffer &R__b) { // Stream an object of class DynEventInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(DynEventInfo::Class(),this); } else { R__b.WriteClassBuffer(DynEventInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_DynEventInfo(void *p) { return p ? new(p) ::DynEventInfo : new ::DynEventInfo; } static void *newArray_DynEventInfo(Long_t nElements, void *p) { return p ? new(p) ::DynEventInfo[nElements] : new ::DynEventInfo[nElements]; } // Wrapper around operator delete static void delete_DynEventInfo(void *p) { delete (static_cast<::DynEventInfo*>(p)); } static void deleteArray_DynEventInfo(void *p) { delete [] (static_cast<::DynEventInfo*>(p)); } static void destruct_DynEventInfo(void *p) { typedef ::DynEventInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::DynEventInfo //______________________________________________________________________________ void NuGenThInfo::Streamer(TBuffer &R__b) { // Stream an object of class NuGenThInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(NuGenThInfo::Class(),this); } else { R__b.WriteClassBuffer(NuGenThInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_NuGenThInfo(void *p) { return p ? new(p) ::NuGenThInfo : new ::NuGenThInfo; } static void *newArray_NuGenThInfo(Long_t nElements, void *p) { return p ? new(p) ::NuGenThInfo[nElements] : new ::NuGenThInfo[nElements]; } // Wrapper around operator delete static void delete_NuGenThInfo(void *p) { delete (static_cast<::NuGenThInfo*>(p)); } static void deleteArray_NuGenThInfo(void *p) { delete [] (static_cast<::NuGenThInfo*>(p)); } static void destruct_NuGenThInfo(void *p) { typedef ::NuGenThInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::NuGenThInfo //______________________________________________________________________________ void MCStep::Streamer(TBuffer &R__b) { // Stream an object of class MCStep. if (R__b.IsReading()) { R__b.ReadClassBuffer(MCStep::Class(),this); } else { R__b.WriteClassBuffer(MCStep::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_MCStep(void *p) { return p ? new(p) ::MCStep : new ::MCStep; } static void *newArray_MCStep(Long_t nElements, void *p) { return p ? new(p) ::MCStep[nElements] : new ::MCStep[nElements]; } // Wrapper around operator delete static void delete_MCStep(void *p) { delete (static_cast<::MCStep*>(p)); } static void deleteArray_MCStep(void *p) { delete [] (static_cast<::MCStep*>(p)); } static void destruct_MCStep(void *p) { typedef ::MCStep current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::MCStep //______________________________________________________________________________ void MCTrack::Streamer(TBuffer &R__b) { // Stream an object of class MCTrack. if (R__b.IsReading()) { R__b.ReadClassBuffer(MCTrack::Class(),this); } else { R__b.WriteClassBuffer(MCTrack::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_MCTrack(void *p) { return p ? new(p) ::MCTrack : new ::MCTrack; } static void *newArray_MCTrack(Long_t nElements, void *p) { return p ? new(p) ::MCTrack[nElements] : new ::MCTrack[nElements]; } // Wrapper around operator delete static void delete_MCTrack(void *p) { delete (static_cast<::MCTrack*>(p)); } static void deleteArray_MCTrack(void *p) { delete [] (static_cast<::MCTrack*>(p)); } static void destruct_MCTrack(void *p) { typedef ::MCTrack current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::MCTrack //______________________________________________________________________________ void OVHitInfo::Streamer(TBuffer &R__b) { // Stream an object of class OVHitInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(OVHitInfo::Class(),this); } else { R__b.WriteClassBuffer(OVHitInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_OVHitInfo(void *p) { return p ? new(p) ::OVHitInfo : new ::OVHitInfo; } static void *newArray_OVHitInfo(Long_t nElements, void *p) { return p ? new(p) ::OVHitInfo[nElements] : new ::OVHitInfo[nElements]; } // Wrapper around operator delete static void delete_OVHitInfo(void *p) { delete (static_cast<::OVHitInfo*>(p)); } static void deleteArray_OVHitInfo(void *p) { delete [] (static_cast<::OVHitInfo*>(p)); } static void destruct_OVHitInfo(void *p) { typedef ::OVHitInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::OVHitInfo //______________________________________________________________________________ void OVHitThInfo::Streamer(TBuffer &R__b) { // Stream an object of class OVHitThInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(OVHitThInfo::Class(),this); } else { R__b.WriteClassBuffer(OVHitThInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_OVHitThInfo(void *p) { return p ? new(p) ::OVHitThInfo : new ::OVHitThInfo; } static void *newArray_OVHitThInfo(Long_t nElements, void *p) { return p ? new(p) ::OVHitThInfo[nElements] : new ::OVHitThInfo[nElements]; } // Wrapper around operator delete static void delete_OVHitThInfo(void *p) { delete (static_cast<::OVHitThInfo*>(p)); } static void deleteArray_OVHitThInfo(void *p) { delete [] (static_cast<::OVHitThInfo*>(p)); } static void destruct_OVHitThInfo(void *p) { typedef ::OVHitThInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::OVHitThInfo //______________________________________________________________________________ void TriggerSummarizedInfo::Streamer(TBuffer &R__b) { // Stream an object of class TriggerSummarizedInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(TriggerSummarizedInfo::Class(),this); } else { R__b.WriteClassBuffer(TriggerSummarizedInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_TriggerSummarizedInfo(void *p) { return p ? new(p) ::TriggerSummarizedInfo : new ::TriggerSummarizedInfo; } static void *newArray_TriggerSummarizedInfo(Long_t nElements, void *p) { return p ? new(p) ::TriggerSummarizedInfo[nElements] : new ::TriggerSummarizedInfo[nElements]; } // Wrapper around operator delete static void delete_TriggerSummarizedInfo(void *p) { delete (static_cast<::TriggerSummarizedInfo*>(p)); } static void deleteArray_TriggerSummarizedInfo(void *p) { delete [] (static_cast<::TriggerSummarizedInfo*>(p)); } static void destruct_TriggerSummarizedInfo(void *p) { typedef ::TriggerSummarizedInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::TriggerSummarizedInfo //______________________________________________________________________________ void TriggerInfo::Streamer(TBuffer &R__b) { // Stream an object of class TriggerInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(TriggerInfo::Class(),this); } else { R__b.WriteClassBuffer(TriggerInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_TriggerInfo(void *p) { return p ? new(p) ::TriggerInfo : new ::TriggerInfo; } static void *newArray_TriggerInfo(Long_t nElements, void *p) { return p ? new(p) ::TriggerInfo[nElements] : new ::TriggerInfo[nElements]; } // Wrapper around operator delete static void delete_TriggerInfo(void *p) { delete (static_cast<::TriggerInfo*>(p)); } static void deleteArray_TriggerInfo(void *p) { delete [] (static_cast<::TriggerInfo*>(p)); } static void destruct_TriggerInfo(void *p) { typedef ::TriggerInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::TriggerInfo //______________________________________________________________________________ void TBInfo::Streamer(TBuffer &R__b) { // Stream an object of class TBInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(TBInfo::Class(),this); } else { R__b.WriteClassBuffer(TBInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_TBInfo(void *p) { return p ? new(p) ::TBInfo : new ::TBInfo; } static void *newArray_TBInfo(Long_t nElements, void *p) { return p ? new(p) ::TBInfo[nElements] : new ::TBInfo[nElements]; } // Wrapper around operator delete static void delete_TBInfo(void *p) { delete (static_cast<::TBInfo*>(p)); } static void deleteArray_TBInfo(void *p) { delete [] (static_cast<::TBInfo*>(p)); } static void destruct_TBInfo(void *p) { typedef ::TBInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::TBInfo //______________________________________________________________________________ void TMBInfo::Streamer(TBuffer &R__b) { // Stream an object of class TMBInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(TMBInfo::Class(),this); } else { R__b.WriteClassBuffer(TMBInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_TMBInfo(void *p) { return p ? new(p) ::TMBInfo : new ::TMBInfo; } static void *newArray_TMBInfo(Long_t nElements, void *p) { return p ? new(p) ::TMBInfo[nElements] : new ::TMBInfo[nElements]; } // Wrapper around operator delete static void delete_TMBInfo(void *p) { delete (static_cast<::TMBInfo*>(p)); } static void deleteArray_TMBInfo(void *p) { delete [] (static_cast<::TMBInfo*>(p)); } static void destruct_TMBInfo(void *p) { typedef ::TMBInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::TMBInfo //______________________________________________________________________________ void TriggerDiagnosisInfo::Streamer(TBuffer &R__b) { // Stream an object of class TriggerDiagnosisInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(TriggerDiagnosisInfo::Class(),this); } else { R__b.WriteClassBuffer(TriggerDiagnosisInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_TriggerDiagnosisInfo(void *p) { return p ? new(p) ::TriggerDiagnosisInfo : new ::TriggerDiagnosisInfo; } static void *newArray_TriggerDiagnosisInfo(Long_t nElements, void *p) { return p ? new(p) ::TriggerDiagnosisInfo[nElements] : new ::TriggerDiagnosisInfo[nElements]; } // Wrapper around operator delete static void delete_TriggerDiagnosisInfo(void *p) { delete (static_cast<::TriggerDiagnosisInfo*>(p)); } static void deleteArray_TriggerDiagnosisInfo(void *p) { delete [] (static_cast<::TriggerDiagnosisInfo*>(p)); } static void destruct_TriggerDiagnosisInfo(void *p) { typedef ::TriggerDiagnosisInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::TriggerDiagnosisInfo //______________________________________________________________________________ void LightInfo::Streamer(TBuffer &R__b) { // Stream an object of class LightInfo. UInt_t R__s, R__c; if (R__b.IsReading()) { Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { } InfoUnit::Streamer(R__b); R__b.CheckByteCount(R__s, R__c, LightInfo::IsA()); } else { R__c = R__b.WriteVersion(LightInfo::IsA(), kTRUE); InfoUnit::Streamer(R__b); R__b.SetByteCount(R__c, kTRUE); } } namespace ROOT { // Wrapper around operator delete static void delete_LightInfo(void *p) { delete (static_cast<::LightInfo*>(p)); } static void deleteArray_LightInfo(void *p) { delete [] (static_cast<::LightInfo*>(p)); } static void destruct_LightInfo(void *p) { typedef ::LightInfo current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_LightInfo(TBuffer &buf, void *obj) { ((::LightInfo*)obj)->::LightInfo::Streamer(buf); } } // end of namespace ROOT for class ::LightInfo //______________________________________________________________________________ void LightEUpp::Streamer(TBuffer &R__b) { // Stream an object of class LightEUpp. UInt_t R__s, R__c; if (R__b.IsReading()) { Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { } LightInfo::Streamer(R__b); { vector &R__stl = fSelectionFlags; 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); } } R__b >> fQtotalEUpp; R__b >> fPMTanomolousN; R__b >> fTriggerNum_LastMu; R__b >> fTime_LastMu; R__b >> fIDQ_LastMu; R__b >> fIVQ_LastMu; R__b >> fIDE_LastMu; R__b >> fIVE_LastMu; R__b.ReadStaticArray((double*)fOVEntry_LastMu); R__b.ReadStaticArray((double*)fOVExit_LastMu); R__b >> fOVRecoQualityValue_LastMu; R__b.ReadStaticArray((double*)fIVEntry_LastMu); R__b.ReadStaticArray((double*)fIVExit_LastMu); R__b >> fIVRecoQualityValue_LastMu; R__b.ReadStaticArray((double*)fIDEntry_LastMu); R__b.ReadStaticArray((double*)fIDExit_LastMu); R__b >> fIDRecoQualityValue_LastMu; R__b >> fTime_LastShowMu; R__b >> fIDQ_LastShowMu; { vector &R__stl = fTimes_LastShowMuons; 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); } } { vector &R__stl = fEvis_LastShowMuons; 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); } } { vector &R__stl = fXEntries_LastShowMuons; 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); } } { vector &R__stl = fXExits_LastShowMuons; 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); } } { vector &R__stl = fYEntries_LastShowMuons; 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); } } { vector &R__stl = fYExits_LastShowMuons; 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); } } { vector &R__stl = fZEntries_LastShowMuons; 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); } } { vector &R__stl = fZExits_LastShowMuons; 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 >> fPMTwithQmax; R__b >> fCoincTime; R__b >> fCoincOrder; R__b >> fCoincFutureN; R__b >> fCoincPastN; R__b >> fCoincDist; { vector &R__stl = fAccCoincTime; 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); } } { vector &R__stl = fAccCoincOrder; 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++) { int R__t; R__b >> R__t; R__stl.push_back(R__t); } } { vector &R__stl = fAccCoincDist; 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.ReadStaticArray((double*)fCharge_IDSegment); R__b.ReadStaticArray((double*)fCharge_IVSegment); R__b.ReadStaticArray((unsigned int*)fPMTMultPE_IDSegment); R__b.ReadStaticArray((unsigned int*)fPMTMultPE_IVSegment); R__b >> fmqtq_IV; R__b >> fEvisID; R__b >> fRMSQtot; R__b.CheckByteCount(R__s, R__c, LightEUpp::IsA()); } else { R__c = R__b.WriteVersion(LightEUpp::IsA(), kTRUE); LightInfo::Streamer(R__b); { vector &R__stl = fSelectionFlags; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } R__b << fQtotalEUpp; R__b << fPMTanomolousN; R__b << fTriggerNum_LastMu; R__b << fTime_LastMu; R__b << fIDQ_LastMu; R__b << fIVQ_LastMu; R__b << fIDE_LastMu; R__b << fIVE_LastMu; R__b.WriteArray(fOVEntry_LastMu, 3); R__b.WriteArray(fOVExit_LastMu, 3); R__b << fOVRecoQualityValue_LastMu; R__b.WriteArray(fIVEntry_LastMu, 3); R__b.WriteArray(fIVExit_LastMu, 3); R__b << fIVRecoQualityValue_LastMu; R__b.WriteArray(fIDEntry_LastMu, 3); R__b.WriteArray(fIDExit_LastMu, 3); R__b << fIDRecoQualityValue_LastMu; R__b << fTime_LastShowMu; R__b << fIDQ_LastShowMu; { vector &R__stl = fTimes_LastShowMuons; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = fEvis_LastShowMuons; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = fXEntries_LastShowMuons; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = fXExits_LastShowMuons; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = fYEntries_LastShowMuons; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = fYExits_LastShowMuons; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = fZEntries_LastShowMuons; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = fZExits_LastShowMuons; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } R__b << fPMTwithQmax; R__b << fCoincTime; R__b << fCoincOrder; R__b << fCoincFutureN; R__b << fCoincPastN; R__b << fCoincDist; { vector &R__stl = fAccCoincTime; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = fAccCoincOrder; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = fAccCoincDist; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } R__b.WriteArray(fCharge_IDSegment, 3); R__b.WriteArray(fCharge_IVSegment, 3); R__b.WriteArray(fPMTMultPE_IDSegment, 3); R__b.WriteArray(fPMTMultPE_IVSegment, 3); R__b << fmqtq_IV; R__b << fEvisID; R__b << fRMSQtot; R__b.SetByteCount(R__c, kTRUE); } } namespace ROOT { // Wrappers around operator new static void *new_LightEUpp(void *p) { return p ? new(p) ::LightEUpp : new ::LightEUpp; } static void *newArray_LightEUpp(Long_t nElements, void *p) { return p ? new(p) ::LightEUpp[nElements] : new ::LightEUpp[nElements]; } // Wrapper around operator delete static void delete_LightEUpp(void *p) { delete (static_cast<::LightEUpp*>(p)); } static void deleteArray_LightEUpp(void *p) { delete [] (static_cast<::LightEUpp*>(p)); } static void destruct_LightEUpp(void *p) { typedef ::LightEUpp current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_LightEUpp(TBuffer &buf, void *obj) { ((::LightEUpp*)obj)->::LightEUpp::Streamer(buf); } } // end of namespace ROOT for class ::LightEUpp //______________________________________________________________________________ void LightJP::Streamer(TBuffer &R__b) { // Stream an object of class LightJP. UInt_t R__s, R__c; if (R__b.IsReading()) { Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { } LightInfo::Streamer(R__b); R__b.CheckByteCount(R__s, R__c, LightJP::IsA()); } else { R__c = R__b.WriteVersion(LightJP::IsA(), kTRUE); LightInfo::Streamer(R__b); R__b.SetByteCount(R__c, kTRUE); } } namespace ROOT { // Wrappers around operator new static void *new_LightJP(void *p) { return p ? new(p) ::LightJP : new ::LightJP; } static void *newArray_LightJP(Long_t nElements, void *p) { return p ? new(p) ::LightJP[nElements] : new ::LightJP[nElements]; } // Wrapper around operator delete static void delete_LightJP(void *p) { delete (static_cast<::LightJP*>(p)); } static void deleteArray_LightJP(void *p) { delete [] (static_cast<::LightJP*>(p)); } static void destruct_LightJP(void *p) { typedef ::LightJP current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_LightJP(TBuffer &buf, void *obj) { ((::LightJP*)obj)->::LightJP::Streamer(buf); } } // end of namespace ROOT for class ::LightJP //______________________________________________________________________________ void LightUnited::Streamer(TBuffer &R__b) { // Stream an object of class LightUnited. UInt_t R__s, R__c; if (R__b.IsReading()) { Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { } LightInfo::Streamer(R__b); R__b.CheckByteCount(R__s, R__c, LightUnited::IsA()); } else { R__c = R__b.WriteVersion(LightUnited::IsA(), kTRUE); LightInfo::Streamer(R__b); R__b.SetByteCount(R__c, kTRUE); } } namespace ROOT { // Wrappers around operator new static void *new_LightUnited(void *p) { return p ? new(p) ::LightUnited : new ::LightUnited; } static void *newArray_LightUnited(Long_t nElements, void *p) { return p ? new(p) ::LightUnited[nElements] : new ::LightUnited[nElements]; } // Wrapper around operator delete static void delete_LightUnited(void *p) { delete (static_cast<::LightUnited*>(p)); } static void deleteArray_LightUnited(void *p) { delete [] (static_cast<::LightUnited*>(p)); } static void destruct_LightUnited(void *p) { typedef ::LightUnited current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_LightUnited(TBuffer &buf, void *obj) { ((::LightUnited*)obj)->::LightUnited::Streamer(buf); } } // end of namespace ROOT for class ::LightUnited //______________________________________________________________________________ void LightAPCMS::Streamer(TBuffer &R__b) { // Stream an object of class LightAPCMS. UInt_t R__s, R__c; if (R__b.IsReading()) { Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { } LightInfo::Streamer(R__b); R__b >> aIIa; R__b >> aIIc; R__b >> aIIn; R__b >> aIIIa; R__b >> aIIIcP; R__b >> aIIIcD; R__b >> aIIInS; R__b >> aIIInN; R__b >> aIIInR; R__b >> aIVa; R__b >> aIVcP; R__b >> aIVcD; R__b >> aIVnS; R__b >> aIVnN; R__b >> aIVnR; { vector &R__stl = aE_P; 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 &R__stl = aE_D; 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 &R__stl = aDt; 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 &R__stl = aDd; 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); } } R__b.ReadStaticArray((unsigned int*)aTrigN); R__b >> aDeltaTN; R__b.ReadStaticArray((double*)aTrigT); R__b >> aDeltaT; R__b.ReadStaticArray((unsigned int*)aRunN); R__b >> aDeltaRN; R__b.ReadStaticArray((double*)aEvID); R__b.ReadStaticArray((double*)aEvIV); R__b.ReadStaticArray((unsigned int*)aHitNID); R__b.ReadStaticArray((unsigned int*)aHitNIV); R__b >> aCoincT; R__b >> aCoincDB; R__b >> aCoincDJ; R__b.ReadStaticArray((bool*)aLNII); R__b.ReadStaticArray((bool*)aLNIII); R__b.ReadStaticArray((bool*)aGoodCh); R__b.ReadStaticArray((bool*)aPreSID); R__b.ReadStaticArray((bool*)aIV); R__b.ReadStaticArray((bool*)aIVc); R__b.ReadStaticArray((double*)aTdv); R__b.ReadStaticArray((double*)aDdv); R__b.ReadStaticArray((double*)aTID); R__b.ReadStaticArray((double*)aTIV); R__b.ReadStaticArray((double*)aXIV); R__b.ReadStaticArray((bool*)aOV); R__b.ReadStaticArray((bool*)aFVL); R__b.ReadStaticArray((bool*)aFVV); R__b.ReadStaticArray((bool*)aFVD); R__b.ReadStaticArray((double*)aFV); R__b.ReadStaticArray((float*)aLiHe); R__b.ReadStaticArray((bool*)aUV); R__b.ReadStaticArray((double*)aXB); R__b.ReadStaticArray((double*)aXJ); R__b.ReadStaticArray((bool*)aInNT); R__b.ReadStaticArray((bool*)aInGC); R__b.ReadStaticArray((bool*)aOut); R__b.ReadStaticArray((bool*)aCoincB); R__b >> aTmu; R__b >> aTmuS; R__b >> aCoincN; R__b >> aCoincNOT; R__b >> aRunT; void *ptr_aRunTyp = (void*)&aRunTyp; R__b >> *reinterpret_cast(ptr_aRunTyp); R__b >> aOFF; R__b.CheckByteCount(R__s, R__c, LightAPCMS::IsA()); } else { R__c = R__b.WriteVersion(LightAPCMS::IsA(), kTRUE); LightInfo::Streamer(R__b); R__b << aIIa; R__b << aIIc; R__b << aIIn; R__b << aIIIa; R__b << aIIIcP; R__b << aIIIcD; R__b << aIIInS; R__b << aIIInN; R__b << aIIInR; R__b << aIVa; R__b << aIVcP; R__b << aIVcD; R__b << aIVnS; R__b << aIVnN; R__b << aIVnR; { vector &R__stl = aE_P; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = aE_D; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = aDt; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = aDd; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } R__b.WriteArray(aTrigN, 2); R__b << aDeltaTN; R__b.WriteArray(aTrigT, 2); R__b << aDeltaT; R__b.WriteArray(aRunN, 2); R__b << aDeltaRN; R__b.WriteArray(aEvID, 2); R__b.WriteArray(aEvIV, 2); R__b.WriteArray(aHitNID, 2); R__b.WriteArray(aHitNIV, 2); R__b << aCoincT; R__b << aCoincDB; R__b << aCoincDJ; R__b.WriteArray(aLNII, 2); R__b.WriteArray(aLNIII, 2); R__b.WriteArray(aGoodCh, 2); R__b.WriteArray(aPreSID, 2); R__b.WriteArray(aIV, 2); R__b.WriteArray(aIVc, 2); R__b.WriteArray(aTdv, 2); R__b.WriteArray(aDdv, 2); R__b.WriteArray((double*)aTID, 6); R__b.WriteArray((double*)aTIV, 6); R__b.WriteArray((double*)aXIV, 8); R__b.WriteArray(aOV, 2); R__b.WriteArray(aFVL, 2); R__b.WriteArray(aFVV, 2); R__b.WriteArray(aFVD, 2); R__b.WriteArray(aFV, 2); R__b.WriteArray((float*)aLiHe, 6); R__b.WriteArray(aUV, 2); R__b.WriteArray((double*)aXB, 8); R__b.WriteArray((double*)aXJ, 8); R__b.WriteArray(aInNT, 2); R__b.WriteArray(aInGC, 2); R__b.WriteArray(aOut, 2); R__b.WriteArray(aCoincB, 2); R__b << aTmu; R__b << aTmuS; R__b << aCoincN; R__b << aCoincNOT; R__b << aRunT; R__b << (Int_t)aRunTyp; R__b << aOFF; R__b.SetByteCount(R__c, kTRUE); } } namespace ROOT { // Wrappers around operator new static void *new_LightAPCMS(void *p) { return p ? new(p) ::LightAPCMS : new ::LightAPCMS; } static void *newArray_LightAPCMS(Long_t nElements, void *p) { return p ? new(p) ::LightAPCMS[nElements] : new ::LightAPCMS[nElements]; } // Wrapper around operator delete static void delete_LightAPCMS(void *p) { delete (static_cast<::LightAPCMS*>(p)); } static void deleteArray_LightAPCMS(void *p) { delete [] (static_cast<::LightAPCMS*>(p)); } static void destruct_LightAPCMS(void *p) { typedef ::LightAPCMS current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_LightAPCMS(TBuffer &buf, void *obj) { ((::LightAPCMS*)obj)->::LightAPCMS::Streamer(buf); } } // end of namespace ROOT for class ::LightAPCMS //______________________________________________________________________________ void Accidental::Streamer(TBuffer &R__b) { // Stream an object of class Accidental. UInt_t R__s, R__c; if (R__b.IsReading()) { Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { } LightInfo::Streamer(R__b); R__b >> n_Presel_Delay_Normal; R__b >> n_Presel_Delay_Swap; R__b >> Vector_dimension; R__b >> Next_Trigger_DeltaT; R__b >> Previous_Trigger_DeltaT; { vector &R__stl = Normal_Event_Flag; 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 &R__stl = Trigger_ID; 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++) { int R__t; R__b >> R__t; R__stl.push_back(R__t); } } { vector &R__stl = E_vis; 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); } } { vector &R__stl = Trigger_Time; 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); } } { vector &R__stl = Time_Iso_Prev; 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); } } { vector &R__stl = Time_Iso_Next; 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); } } { vector &R__stl = x_BAMA; 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); } } { vector &R__stl = DeltaT_last_mu; 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); } } { vector &R__stl = y_BAMA; 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); } } { vector &R__stl = z_BAMA; 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); } } { vector &R__stl = DeltaR; 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); } } { vector &R__stl = DeltaT_without_Offset; 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); } } { vector &R__stl = DeltaT_with_Offset; 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); } } { vector &R__stl = FV_BAMA; 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); } } { vector &R__stl = Li_He_Like; 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); } } { vector &R__stl = IV_PMTs; 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++) { int R__t; R__b >> R__t; R__stl.push_back(R__t); } } { vector &R__stl = IV_Charge; 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); } } { vector &R__stl = IV_ID_DeltaT; 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); } } { vector &R__stl = IV_ID_DeltaR; 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); } } { vector &R__stl = OV_Flag; 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 &R__stl = Chimney_Pulse_Shape; 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); } } { vector &R__stl = Delta_BAMA_JAPAN; 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); } } { vector &R__stl = FV_tlk; 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); } } { vector &R__stl = QMQT; 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); } } { vector &R__stl = RMSQ; 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); } } { vector &R__stl = Qdiff; 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); } } { vector &R__stl = RMSTstart; 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); } } { vector &R__stl = PMTwithQmax; 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++) { int R__t; R__b >> R__t; R__stl.push_back(R__t); } } R__b.CheckByteCount(R__s, R__c, Accidental::IsA()); } else { R__c = R__b.WriteVersion(Accidental::IsA(), kTRUE); LightInfo::Streamer(R__b); R__b << n_Presel_Delay_Normal; R__b << n_Presel_Delay_Swap; R__b << Vector_dimension; R__b << Next_Trigger_DeltaT; R__b << Previous_Trigger_DeltaT; { vector &R__stl = Normal_Event_Flag; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = Trigger_ID; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = E_vis; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = Trigger_Time; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = Time_Iso_Prev; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = Time_Iso_Next; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = x_BAMA; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = DeltaT_last_mu; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = y_BAMA; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = z_BAMA; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = DeltaR; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = DeltaT_without_Offset; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = DeltaT_with_Offset; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = FV_BAMA; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = Li_He_Like; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = IV_PMTs; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = IV_Charge; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = IV_ID_DeltaT; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = IV_ID_DeltaR; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = OV_Flag; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = Chimney_Pulse_Shape; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = Delta_BAMA_JAPAN; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = FV_tlk; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = QMQT; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = RMSQ; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = Qdiff; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = RMSTstart; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::iterator R__k; for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) { R__b << (*R__k); } } } { vector &R__stl = PMTwithQmax; int R__n=int(R__stl.size()); R__b << R__n; if(R__n) { vector::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); } } namespace ROOT { // Wrappers around operator new static void *new_Accidental(void *p) { return p ? new(p) ::Accidental : new ::Accidental; } static void *newArray_Accidental(Long_t nElements, void *p) { return p ? new(p) ::Accidental[nElements] : new ::Accidental[nElements]; } // Wrapper around operator delete static void delete_Accidental(void *p) { delete (static_cast<::Accidental*>(p)); } static void deleteArray_Accidental(void *p) { delete [] (static_cast<::Accidental*>(p)); } static void destruct_Accidental(void *p) { typedef ::Accidental current_t; (static_cast(p))->~current_t(); } // Wrapper around a custom streamer member function. static void streamer_Accidental(TBuffer &buf, void *obj) { ((::Accidental*)obj)->::Accidental::Streamer(buf); } } // end of namespace ROOT for class ::Accidental //______________________________________________________________________________ void RecoJPInfo::Streamer(TBuffer &R__b) { // Stream an object of class RecoJPInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(RecoJPInfo::Class(),this); } else { R__b.WriteClassBuffer(RecoJPInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_RecoJPInfo(void *p) { return p ? new(p) ::RecoJPInfo : new ::RecoJPInfo; } static void *newArray_RecoJPInfo(Long_t nElements, void *p) { return p ? new(p) ::RecoJPInfo[nElements] : new ::RecoJPInfo[nElements]; } // Wrapper around operator delete static void delete_RecoJPInfo(void *p) { delete (static_cast<::RecoJPInfo*>(p)); } static void deleteArray_RecoJPInfo(void *p) { delete [] (static_cast<::RecoJPInfo*>(p)); } static void destruct_RecoJPInfo(void *p) { typedef ::RecoJPInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::RecoJPInfo //______________________________________________________________________________ void MiniPulseInfo::Streamer(TBuffer &R__b) { // Stream an object of class MiniPulseInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(MiniPulseInfo::Class(),this); } else { R__b.WriteClassBuffer(MiniPulseInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_MiniPulseInfo(void *p) { return p ? new(p) ::MiniPulseInfo : new ::MiniPulseInfo; } static void *newArray_MiniPulseInfo(Long_t nElements, void *p) { return p ? new(p) ::MiniPulseInfo[nElements] : new ::MiniPulseInfo[nElements]; } // Wrapper around operator delete static void delete_MiniPulseInfo(void *p) { delete (static_cast<::MiniPulseInfo*>(p)); } static void deleteArray_MiniPulseInfo(void *p) { delete [] (static_cast<::MiniPulseInfo*>(p)); } static void destruct_MiniPulseInfo(void *p) { typedef ::MiniPulseInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::MiniPulseInfo //______________________________________________________________________________ void MuonTDCInfo::Streamer(TBuffer &R__b) { // Stream an object of class MuonTDCInfo. if (R__b.IsReading()) { R__b.ReadClassBuffer(MuonTDCInfo::Class(),this); } else { R__b.WriteClassBuffer(MuonTDCInfo::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_MuonTDCInfo(void *p) { return p ? new(p) ::MuonTDCInfo : new ::MuonTDCInfo; } static void *newArray_MuonTDCInfo(Long_t nElements, void *p) { return p ? new(p) ::MuonTDCInfo[nElements] : new ::MuonTDCInfo[nElements]; } // Wrapper around operator delete static void delete_MuonTDCInfo(void *p) { delete (static_cast<::MuonTDCInfo*>(p)); } static void deleteArray_MuonTDCInfo(void *p) { delete [] (static_cast<::MuonTDCInfo*>(p)); } static void destruct_MuonTDCInfo(void *p) { typedef ::MuonTDCInfo current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::MuonTDCInfo namespace ROOT { } // end of namespace ROOT for class ::RunVLD //______________________________________________________________________________ void EnDep::Streamer(TBuffer &R__b) { // Stream an object of class EnDep. if (R__b.IsReading()) { R__b.ReadClassBuffer(EnDep::Class(),this); } else { R__b.WriteClassBuffer(EnDep::Class(),this); } } namespace ROOT { // Wrappers around operator new static void *new_EnDep(void *p) { return p ? new(p) ::EnDep : new ::EnDep; } static void *newArray_EnDep(Long_t nElements, void *p) { return p ? new(p) ::EnDep[nElements] : new ::EnDep[nElements]; } // Wrapper around operator delete static void delete_EnDep(void *p) { delete (static_cast<::EnDep*>(p)); } static void deleteArray_EnDep(void *p) { delete [] (static_cast<::EnDep*>(p)); } static void destruct_EnDep(void *p) { typedef ::EnDep current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::EnDep namespace ROOT { // Wrappers around operator new static void *new_Event(void *p) { return p ? new(p) ::Event : new ::Event; } static void *newArray_Event(Long_t nElements, void *p) { return p ? new(p) ::Event[nElements] : new ::Event[nElements]; } // Wrapper around operator delete static void delete_Event(void *p) { delete (static_cast<::Event*>(p)); } static void deleteArray_Event(void *p) { delete [] (static_cast<::Event*>(p)); } static void destruct_Event(void *p) { typedef ::Event current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class ::Event namespace ROOT { static TClass *vectorlEunsignedsPshortgR_Dictionary(); static void vectorlEunsignedsPshortgR_TClassManip(TClass*); static void *new_vectorlEunsignedsPshortgR(void *p = nullptr); static void *newArray_vectorlEunsignedsPshortgR(Long_t size, void *p); static void delete_vectorlEunsignedsPshortgR(void *p); static void deleteArray_vectorlEunsignedsPshortgR(void *p); static void destruct_vectorlEunsignedsPshortgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEunsignedsPshortgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEunsignedsPshortgR); instance.SetNewArray(&newArray_vectorlEunsignedsPshortgR); instance.SetDelete(&delete_vectorlEunsignedsPshortgR); instance.SetDeleteArray(&deleteArray_vectorlEunsignedsPshortgR); instance.SetDestructor(&destruct_vectorlEunsignedsPshortgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); ::ROOT::AddClassAlternate("vector","std::vector >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEunsignedsPshortgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlEunsignedsPshortgR_TClassManip(theClass); return theClass; } static void vectorlEunsignedsPshortgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEunsignedsPshortgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEunsignedsPshortgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEunsignedsPshortgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlEunsignedsPshortgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlEunsignedsPshortgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEunsignedsPlonggR_Dictionary(); static void vectorlEunsignedsPlonggR_TClassManip(TClass*); static void *new_vectorlEunsignedsPlonggR(void *p = nullptr); static void *newArray_vectorlEunsignedsPlonggR(Long_t size, void *p); static void delete_vectorlEunsignedsPlonggR(void *p); static void deleteArray_vectorlEunsignedsPlonggR(void *p); static void destruct_vectorlEunsignedsPlonggR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEunsignedsPlonggR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEunsignedsPlonggR); instance.SetNewArray(&newArray_vectorlEunsignedsPlonggR); instance.SetDelete(&delete_vectorlEunsignedsPlonggR); instance.SetDeleteArray(&deleteArray_vectorlEunsignedsPlonggR); instance.SetDestructor(&destruct_vectorlEunsignedsPlonggR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); ::ROOT::AddClassAlternate("vector","std::vector >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEunsignedsPlonggR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlEunsignedsPlonggR_TClassManip(theClass); return theClass; } static void vectorlEunsignedsPlonggR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEunsignedsPlonggR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEunsignedsPlonggR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEunsignedsPlonggR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlEunsignedsPlonggR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlEunsignedsPlonggR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEstringgR_Dictionary(); static void vectorlEstringgR_TClassManip(TClass*); static void *new_vectorlEstringgR(void *p = nullptr); 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*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEstringgR_Dictionary, isa_proxy, 0, sizeof(vector) ); 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 >())); ::ROOT::AddClassAlternate("vector","std::vector, std::allocator >, std::allocator, std::allocator > > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEstringgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlEstringgR_TClassManip(theClass); return theClass; } static void vectorlEstringgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEstringgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEstringgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEstringgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlEstringgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlEstringgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEshortgR_Dictionary(); static void vectorlEshortgR_TClassManip(TClass*); static void *new_vectorlEshortgR(void *p = nullptr); static void *newArray_vectorlEshortgR(Long_t size, void *p); static void delete_vectorlEshortgR(void *p); static void deleteArray_vectorlEshortgR(void *p); static void destruct_vectorlEshortgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEshortgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEshortgR); instance.SetNewArray(&newArray_vectorlEshortgR); instance.SetDelete(&delete_vectorlEshortgR); instance.SetDeleteArray(&deleteArray_vectorlEshortgR); instance.SetDestructor(&destruct_vectorlEshortgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); ::ROOT::AddClassAlternate("vector","std::vector >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEshortgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlEshortgR_TClassManip(theClass); return theClass; } static void vectorlEshortgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEshortgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEshortgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEshortgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlEshortgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlEshortgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEintgR_Dictionary(); static void vectorlEintgR_TClassManip(TClass*); static void *new_vectorlEintgR(void *p = nullptr); static void *newArray_vectorlEintgR(Long_t size, void *p); static void delete_vectorlEintgR(void *p); static void deleteArray_vectorlEintgR(void *p); static void destruct_vectorlEintgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEintgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEintgR); instance.SetNewArray(&newArray_vectorlEintgR); instance.SetDelete(&delete_vectorlEintgR); instance.SetDeleteArray(&deleteArray_vectorlEintgR); instance.SetDestructor(&destruct_vectorlEintgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); ::ROOT::AddClassAlternate("vector","std::vector >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEintgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlEintgR_TClassManip(theClass); return theClass; } static void vectorlEintgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEintgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEintgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEintgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlEintgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlEintgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEfloatgR_Dictionary(); static void vectorlEfloatgR_TClassManip(TClass*); static void *new_vectorlEfloatgR(void *p = nullptr); static void *newArray_vectorlEfloatgR(Long_t size, void *p); static void delete_vectorlEfloatgR(void *p); static void deleteArray_vectorlEfloatgR(void *p); static void destruct_vectorlEfloatgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEfloatgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEfloatgR); instance.SetNewArray(&newArray_vectorlEfloatgR); instance.SetDelete(&delete_vectorlEfloatgR); instance.SetDeleteArray(&deleteArray_vectorlEfloatgR); instance.SetDestructor(&destruct_vectorlEfloatgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); ::ROOT::AddClassAlternate("vector","std::vector >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEfloatgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlEfloatgR_TClassManip(theClass); return theClass; } static void vectorlEfloatgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEfloatgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEfloatgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEfloatgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlEfloatgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlEfloatgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEdoublegR_Dictionary(); static void vectorlEdoublegR_TClassManip(TClass*); static void *new_vectorlEdoublegR(void *p = nullptr); 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*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEdoublegR_Dictionary, isa_proxy, 0, sizeof(vector) ); 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 >())); ::ROOT::AddClassAlternate("vector","std::vector >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEdoublegR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlEdoublegR_TClassManip(theClass); return theClass; } static void vectorlEdoublegR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEdoublegR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEdoublegR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEdoublegR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlEdoublegR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlEdoublegR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEboolgR_Dictionary(); static void vectorlEboolgR_TClassManip(TClass*); static void *new_vectorlEboolgR(void *p = nullptr); 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*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 690, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEboolgR_Dictionary, isa_proxy, 0, sizeof(vector) ); 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 >())); ::ROOT::AddClassAlternate("vector","std::vector >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEboolgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlEboolgR_TClassManip(theClass); return theClass; } static void vectorlEboolgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEboolgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEboolgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEboolgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlEboolgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlEboolgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlETObjectmUgR_Dictionary(); static void vectorlETObjectmUgR_TClassManip(TClass*); static void *new_vectorlETObjectmUgR(void *p = nullptr); static void *newArray_vectorlETObjectmUgR(Long_t size, void *p); static void delete_vectorlETObjectmUgR(void *p); static void deleteArray_vectorlETObjectmUgR(void *p); static void destruct_vectorlETObjectmUgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlETObjectmUgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlETObjectmUgR); instance.SetNewArray(&newArray_vectorlETObjectmUgR); instance.SetDelete(&delete_vectorlETObjectmUgR); instance.SetDeleteArray(&deleteArray_vectorlETObjectmUgR); instance.SetDestructor(&destruct_vectorlETObjectmUgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); ::ROOT::AddClassAlternate("vector","std::vector >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlETObjectmUgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlETObjectmUgR_TClassManip(theClass); return theClass; } static void vectorlETObjectmUgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlETObjectmUgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlETObjectmUgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlETObjectmUgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlETObjectmUgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlETObjectmUgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEPulseProfInfomUgR_Dictionary(); static void vectorlEPulseProfInfomUgR_TClassManip(TClass*); static void *new_vectorlEPulseProfInfomUgR(void *p = nullptr); static void *newArray_vectorlEPulseProfInfomUgR(Long_t size, void *p); static void delete_vectorlEPulseProfInfomUgR(void *p); static void deleteArray_vectorlEPulseProfInfomUgR(void *p); static void destruct_vectorlEPulseProfInfomUgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEPulseProfInfomUgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEPulseProfInfomUgR); instance.SetNewArray(&newArray_vectorlEPulseProfInfomUgR); instance.SetDelete(&delete_vectorlEPulseProfInfomUgR); instance.SetDeleteArray(&deleteArray_vectorlEPulseProfInfomUgR); instance.SetDestructor(&destruct_vectorlEPulseProfInfomUgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); ::ROOT::AddClassAlternate("vector","std::vector >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEPulseProfInfomUgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlEPulseProfInfomUgR_TClassManip(theClass); return theClass; } static void vectorlEPulseProfInfomUgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEPulseProfInfomUgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEPulseProfInfomUgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEPulseProfInfomUgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlEPulseProfInfomUgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlEPulseProfInfomUgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEPulseInfomUgR_Dictionary(); static void vectorlEPulseInfomUgR_TClassManip(TClass*); static void *new_vectorlEPulseInfomUgR(void *p = nullptr); static void *newArray_vectorlEPulseInfomUgR(Long_t size, void *p); static void delete_vectorlEPulseInfomUgR(void *p); static void deleteArray_vectorlEPulseInfomUgR(void *p); static void destruct_vectorlEPulseInfomUgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEPulseInfomUgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEPulseInfomUgR); instance.SetNewArray(&newArray_vectorlEPulseInfomUgR); instance.SetDelete(&delete_vectorlEPulseInfomUgR); instance.SetDeleteArray(&deleteArray_vectorlEPulseInfomUgR); instance.SetDestructor(&destruct_vectorlEPulseInfomUgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); ::ROOT::AddClassAlternate("vector","std::vector >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEPulseInfomUgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlEPulseInfomUgR_TClassManip(theClass); return theClass; } static void vectorlEPulseInfomUgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEPulseInfomUgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEPulseInfomUgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEPulseInfomUgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlEPulseInfomUgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlEPulseInfomUgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEPMTHitgR_Dictionary(); static void vectorlEPMTHitgR_TClassManip(TClass*); static void *new_vectorlEPMTHitgR(void *p = nullptr); static void *newArray_vectorlEPMTHitgR(Long_t size, void *p); static void delete_vectorlEPMTHitgR(void *p); static void deleteArray_vectorlEPMTHitgR(void *p); static void destruct_vectorlEPMTHitgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEPMTHitgR_Dictionary, isa_proxy, 4, sizeof(vector) ); instance.SetNew(&new_vectorlEPMTHitgR); instance.SetNewArray(&newArray_vectorlEPMTHitgR); instance.SetDelete(&delete_vectorlEPMTHitgR); instance.SetDeleteArray(&deleteArray_vectorlEPMTHitgR); instance.SetDestructor(&destruct_vectorlEPMTHitgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); ::ROOT::AddClassAlternate("vector","std::vector >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEPMTHitgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlEPMTHitgR_TClassManip(theClass); return theClass; } static void vectorlEPMTHitgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEPMTHitgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEPMTHitgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEPMTHitgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlEPMTHitgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlEPMTHitgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEOVHitgR_Dictionary(); static void vectorlEOVHitgR_TClassManip(TClass*); static void *new_vectorlEOVHitgR(void *p = nullptr); static void *newArray_vectorlEOVHitgR(Long_t size, void *p); static void delete_vectorlEOVHitgR(void *p); static void deleteArray_vectorlEOVHitgR(void *p); static void destruct_vectorlEOVHitgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEOVHitgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEOVHitgR); instance.SetNewArray(&newArray_vectorlEOVHitgR); instance.SetDelete(&delete_vectorlEOVHitgR); instance.SetDeleteArray(&deleteArray_vectorlEOVHitgR); instance.SetDestructor(&destruct_vectorlEOVHitgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); ::ROOT::AddClassAlternate("vector","std::vector >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEOVHitgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlEOVHitgR_TClassManip(theClass); return theClass; } static void vectorlEOVHitgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEOVHitgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEOVHitgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEOVHitgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlEOVHitgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlEOVHitgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEIProcessmUgR_Dictionary(); static void vectorlEIProcessmUgR_TClassManip(TClass*); static void *new_vectorlEIProcessmUgR(void *p = nullptr); static void *newArray_vectorlEIProcessmUgR(Long_t size, void *p); static void delete_vectorlEIProcessmUgR(void *p); static void deleteArray_vectorlEIProcessmUgR(void *p); static void destruct_vectorlEIProcessmUgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEIProcessmUgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEIProcessmUgR); instance.SetNewArray(&newArray_vectorlEIProcessmUgR); instance.SetDelete(&delete_vectorlEIProcessmUgR); instance.SetDeleteArray(&deleteArray_vectorlEIProcessmUgR); instance.SetDestructor(&destruct_vectorlEIProcessmUgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); ::ROOT::AddClassAlternate("vector","std::vector >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEIProcessmUgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlEIProcessmUgR_TClassManip(theClass); return theClass; } static void vectorlEIProcessmUgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEIProcessmUgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEIProcessmUgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEIProcessmUgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlEIProcessmUgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlEIProcessmUgR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEGlobalThInfogR_Dictionary(); static void vectorlEGlobalThInfogR_TClassManip(TClass*); static void *new_vectorlEGlobalThInfogR(void *p = nullptr); static void *newArray_vectorlEGlobalThInfogR(Long_t size, void *p); static void delete_vectorlEGlobalThInfogR(void *p); static void deleteArray_vectorlEGlobalThInfogR(void *p); static void destruct_vectorlEGlobalThInfogR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 423, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEGlobalThInfogR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEGlobalThInfogR); instance.SetNewArray(&newArray_vectorlEGlobalThInfogR); instance.SetDelete(&delete_vectorlEGlobalThInfogR); instance.SetDeleteArray(&deleteArray_vectorlEGlobalThInfogR); instance.SetDestructor(&destruct_vectorlEGlobalThInfogR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); ::ROOT::AddClassAlternate("vector","std::vector >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEGlobalThInfogR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); vectorlEGlobalThInfogR_TClassManip(theClass); return theClass; } static void vectorlEGlobalThInfogR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEGlobalThInfogR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEGlobalThInfogR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEGlobalThInfogR(void *p) { delete (static_cast*>(p)); } static void deleteArray_vectorlEGlobalThInfogR(void *p) { delete [] (static_cast*>(p)); } static void destruct_vectorlEGlobalThInfogR(void *p) { typedef vector current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *maplEunsignedsPshortcOunsignedsPintgR_Dictionary(); static void maplEunsignedsPshortcOunsignedsPintgR_TClassManip(TClass*); static void *new_maplEunsignedsPshortcOunsignedsPintgR(void *p = nullptr); static void *newArray_maplEunsignedsPshortcOunsignedsPintgR(Long_t size, void *p); static void delete_maplEunsignedsPshortcOunsignedsPintgR(void *p); static void deleteArray_maplEunsignedsPshortcOunsignedsPintgR(void *p); static void destruct_maplEunsignedsPshortcOunsignedsPintgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map*) { map *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map)); static ::ROOT::TGenericClassInfo instance("map", -2, "map", 100, typeid(map), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEunsignedsPshortcOunsignedsPintgR_Dictionary, isa_proxy, 0, sizeof(map) ); instance.SetNew(&new_maplEunsignedsPshortcOunsignedsPintgR); instance.SetNewArray(&newArray_maplEunsignedsPshortcOunsignedsPintgR); instance.SetDelete(&delete_maplEunsignedsPshortcOunsignedsPintgR); instance.SetDeleteArray(&deleteArray_maplEunsignedsPshortcOunsignedsPintgR); instance.SetDestructor(&destruct_maplEunsignedsPshortcOunsignedsPintgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map >())); ::ROOT::AddClassAlternate("map","std::map, std::allocator > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEunsignedsPshortcOunsignedsPintgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); maplEunsignedsPshortcOunsignedsPintgR_TClassManip(theClass); return theClass; } static void maplEunsignedsPshortcOunsignedsPintgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEunsignedsPshortcOunsignedsPintgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map : new map; } static void *newArray_maplEunsignedsPshortcOunsignedsPintgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEunsignedsPshortcOunsignedsPintgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_maplEunsignedsPshortcOunsignedsPintgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_maplEunsignedsPshortcOunsignedsPintgR(void *p) { typedef map current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map namespace ROOT { static TClass *maplEunsignedsPshortcOboolgR_Dictionary(); static void maplEunsignedsPshortcOboolgR_TClassManip(TClass*); static void *new_maplEunsignedsPshortcOboolgR(void *p = nullptr); static void *newArray_maplEunsignedsPshortcOboolgR(Long_t size, void *p); static void delete_maplEunsignedsPshortcOboolgR(void *p); static void deleteArray_maplEunsignedsPshortcOboolgR(void *p); static void destruct_maplEunsignedsPshortcOboolgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map*) { map *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map)); static ::ROOT::TGenericClassInfo instance("map", -2, "map", 100, typeid(map), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEunsignedsPshortcOboolgR_Dictionary, isa_proxy, 0, sizeof(map) ); instance.SetNew(&new_maplEunsignedsPshortcOboolgR); instance.SetNewArray(&newArray_maplEunsignedsPshortcOboolgR); instance.SetDelete(&delete_maplEunsignedsPshortcOboolgR); instance.SetDeleteArray(&deleteArray_maplEunsignedsPshortcOboolgR); instance.SetDestructor(&destruct_maplEunsignedsPshortcOboolgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map >())); ::ROOT::AddClassAlternate("map","std::map, std::allocator > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEunsignedsPshortcOboolgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); maplEunsignedsPshortcOboolgR_TClassManip(theClass); return theClass; } static void maplEunsignedsPshortcOboolgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEunsignedsPshortcOboolgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map : new map; } static void *newArray_maplEunsignedsPshortcOboolgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEunsignedsPshortcOboolgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_maplEunsignedsPshortcOboolgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_maplEunsignedsPshortcOboolgR(void *p) { typedef map current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map namespace ROOT { static TClass *maplEstringcOvectorlEstringgRsPgR_Dictionary(); static void maplEstringcOvectorlEstringgRsPgR_TClassManip(TClass*); static void *new_maplEstringcOvectorlEstringgRsPgR(void *p = nullptr); static void *newArray_maplEstringcOvectorlEstringgRsPgR(Long_t size, void *p); static void delete_maplEstringcOvectorlEstringgRsPgR(void *p); static void deleteArray_maplEstringcOvectorlEstringgRsPgR(void *p); static void destruct_maplEstringcOvectorlEstringgRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map >*) { map > *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map >)); static ::ROOT::TGenericClassInfo instance("map >", -2, "map", 100, typeid(map >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEstringcOvectorlEstringgRsPgR_Dictionary, isa_proxy, 0, sizeof(map >) ); instance.SetNew(&new_maplEstringcOvectorlEstringgRsPgR); instance.SetNewArray(&newArray_maplEstringcOvectorlEstringgRsPgR); instance.SetDelete(&delete_maplEstringcOvectorlEstringgRsPgR); instance.SetDeleteArray(&deleteArray_maplEstringcOvectorlEstringgRsPgR); instance.SetDestructor(&destruct_maplEstringcOvectorlEstringgRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map > >())); ::ROOT::AddClassAlternate("map >","std::map, std::allocator >, std::vector, std::allocator >, std::allocator, std::allocator > > >, std::less, std::allocator > >, std::allocator, std::allocator > const, std::vector, std::allocator >, std::allocator, std::allocator > > > > > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEstringcOvectorlEstringgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast >*>(nullptr))->GetClass(); maplEstringcOvectorlEstringgRsPgR_TClassManip(theClass); return theClass; } static void maplEstringcOvectorlEstringgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEstringcOvectorlEstringgRsPgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map > : new map >; } static void *newArray_maplEstringcOvectorlEstringgRsPgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map >[nElements] : new map >[nElements]; } // Wrapper around operator delete static void delete_maplEstringcOvectorlEstringgRsPgR(void *p) { delete (static_cast >*>(p)); } static void deleteArray_maplEstringcOvectorlEstringgRsPgR(void *p) { delete [] (static_cast >*>(p)); } static void destruct_maplEstringcOvectorlEstringgRsPgR(void *p) { typedef map > current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map > namespace ROOT { static TClass *maplEstringcOvectorlEintgRsPgR_Dictionary(); static void maplEstringcOvectorlEintgRsPgR_TClassManip(TClass*); static void *new_maplEstringcOvectorlEintgRsPgR(void *p = nullptr); static void *newArray_maplEstringcOvectorlEintgRsPgR(Long_t size, void *p); static void delete_maplEstringcOvectorlEintgRsPgR(void *p); static void deleteArray_maplEstringcOvectorlEintgRsPgR(void *p); static void destruct_maplEstringcOvectorlEintgRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map >*) { map > *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map >)); static ::ROOT::TGenericClassInfo instance("map >", -2, "map", 100, typeid(map >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEstringcOvectorlEintgRsPgR_Dictionary, isa_proxy, 0, sizeof(map >) ); instance.SetNew(&new_maplEstringcOvectorlEintgRsPgR); instance.SetNewArray(&newArray_maplEstringcOvectorlEintgRsPgR); instance.SetDelete(&delete_maplEstringcOvectorlEintgRsPgR); instance.SetDeleteArray(&deleteArray_maplEstringcOvectorlEintgRsPgR); instance.SetDestructor(&destruct_maplEstringcOvectorlEintgRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map > >())); ::ROOT::AddClassAlternate("map >","std::map, std::allocator >, std::vector >, std::less, std::allocator > >, std::allocator, std::allocator > const, std::vector > > > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEstringcOvectorlEintgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast >*>(nullptr))->GetClass(); maplEstringcOvectorlEintgRsPgR_TClassManip(theClass); return theClass; } static void maplEstringcOvectorlEintgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEstringcOvectorlEintgRsPgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map > : new map >; } static void *newArray_maplEstringcOvectorlEintgRsPgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map >[nElements] : new map >[nElements]; } // Wrapper around operator delete static void delete_maplEstringcOvectorlEintgRsPgR(void *p) { delete (static_cast >*>(p)); } static void deleteArray_maplEstringcOvectorlEintgRsPgR(void *p) { delete [] (static_cast >*>(p)); } static void destruct_maplEstringcOvectorlEintgRsPgR(void *p) { typedef map > current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map > namespace ROOT { static TClass *maplEstringcOvectorlEdoublegRsPgR_Dictionary(); static void maplEstringcOvectorlEdoublegRsPgR_TClassManip(TClass*); static void *new_maplEstringcOvectorlEdoublegRsPgR(void *p = nullptr); static void *newArray_maplEstringcOvectorlEdoublegRsPgR(Long_t size, void *p); static void delete_maplEstringcOvectorlEdoublegRsPgR(void *p); static void deleteArray_maplEstringcOvectorlEdoublegRsPgR(void *p); static void destruct_maplEstringcOvectorlEdoublegRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map >*) { map > *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map >)); static ::ROOT::TGenericClassInfo instance("map >", -2, "map", 100, typeid(map >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEstringcOvectorlEdoublegRsPgR_Dictionary, isa_proxy, 0, sizeof(map >) ); instance.SetNew(&new_maplEstringcOvectorlEdoublegRsPgR); instance.SetNewArray(&newArray_maplEstringcOvectorlEdoublegRsPgR); instance.SetDelete(&delete_maplEstringcOvectorlEdoublegRsPgR); instance.SetDeleteArray(&deleteArray_maplEstringcOvectorlEdoublegRsPgR); instance.SetDestructor(&destruct_maplEstringcOvectorlEdoublegRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map > >())); ::ROOT::AddClassAlternate("map >","std::map, std::allocator >, std::vector >, std::less, std::allocator > >, std::allocator, std::allocator > const, std::vector > > > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEstringcOvectorlEdoublegRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast >*>(nullptr))->GetClass(); maplEstringcOvectorlEdoublegRsPgR_TClassManip(theClass); return theClass; } static void maplEstringcOvectorlEdoublegRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEstringcOvectorlEdoublegRsPgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map > : new map >; } static void *newArray_maplEstringcOvectorlEdoublegRsPgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map >[nElements] : new map >[nElements]; } // Wrapper around operator delete static void delete_maplEstringcOvectorlEdoublegRsPgR(void *p) { delete (static_cast >*>(p)); } static void deleteArray_maplEstringcOvectorlEdoublegRsPgR(void *p) { delete [] (static_cast >*>(p)); } static void destruct_maplEstringcOvectorlEdoublegRsPgR(void *p) { typedef map > current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map > namespace ROOT { static TClass *maplEstringcOvectorlETObjectmUgRsPgR_Dictionary(); static void maplEstringcOvectorlETObjectmUgRsPgR_TClassManip(TClass*); static void *new_maplEstringcOvectorlETObjectmUgRsPgR(void *p = nullptr); static void *newArray_maplEstringcOvectorlETObjectmUgRsPgR(Long_t size, void *p); static void delete_maplEstringcOvectorlETObjectmUgRsPgR(void *p); static void deleteArray_maplEstringcOvectorlETObjectmUgRsPgR(void *p); static void destruct_maplEstringcOvectorlETObjectmUgRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map >*) { map > *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map >)); static ::ROOT::TGenericClassInfo instance("map >", -2, "map", 100, typeid(map >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEstringcOvectorlETObjectmUgRsPgR_Dictionary, isa_proxy, 0, sizeof(map >) ); instance.SetNew(&new_maplEstringcOvectorlETObjectmUgRsPgR); instance.SetNewArray(&newArray_maplEstringcOvectorlETObjectmUgRsPgR); instance.SetDelete(&delete_maplEstringcOvectorlETObjectmUgRsPgR); instance.SetDeleteArray(&deleteArray_maplEstringcOvectorlETObjectmUgRsPgR); instance.SetDestructor(&destruct_maplEstringcOvectorlETObjectmUgRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map > >())); ::ROOT::AddClassAlternate("map >","std::map, std::allocator >, std::vector >, std::less, std::allocator > >, std::allocator, std::allocator > const, std::vector > > > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEstringcOvectorlETObjectmUgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast >*>(nullptr))->GetClass(); maplEstringcOvectorlETObjectmUgRsPgR_TClassManip(theClass); return theClass; } static void maplEstringcOvectorlETObjectmUgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEstringcOvectorlETObjectmUgRsPgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map > : new map >; } static void *newArray_maplEstringcOvectorlETObjectmUgRsPgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map >[nElements] : new map >[nElements]; } // Wrapper around operator delete static void delete_maplEstringcOvectorlETObjectmUgRsPgR(void *p) { delete (static_cast >*>(p)); } static void deleteArray_maplEstringcOvectorlETObjectmUgRsPgR(void *p) { delete [] (static_cast >*>(p)); } static void destruct_maplEstringcOvectorlETObjectmUgRsPgR(void *p) { typedef map > current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map > namespace ROOT { static TClass *maplEstringcOstringgR_Dictionary(); static void maplEstringcOstringgR_TClassManip(TClass*); static void *new_maplEstringcOstringgR(void *p = nullptr); static void *newArray_maplEstringcOstringgR(Long_t size, void *p); static void delete_maplEstringcOstringgR(void *p); static void deleteArray_maplEstringcOstringgR(void *p); static void destruct_maplEstringcOstringgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map*) { map *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map)); static ::ROOT::TGenericClassInfo instance("map", -2, "map", 100, typeid(map), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEstringcOstringgR_Dictionary, isa_proxy, 0, sizeof(map) ); instance.SetNew(&new_maplEstringcOstringgR); instance.SetNewArray(&newArray_maplEstringcOstringgR); instance.SetDelete(&delete_maplEstringcOstringgR); instance.SetDeleteArray(&deleteArray_maplEstringcOstringgR); instance.SetDestructor(&destruct_maplEstringcOstringgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map >())); ::ROOT::AddClassAlternate("map","std::map, std::allocator >, std::__cxx11::basic_string, std::allocator >, std::less, std::allocator > >, std::allocator, std::allocator > const, std::__cxx11::basic_string, std::allocator > > > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEstringcOstringgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); maplEstringcOstringgR_TClassManip(theClass); return theClass; } static void maplEstringcOstringgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEstringcOstringgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map : new map; } static void *newArray_maplEstringcOstringgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEstringcOstringgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_maplEstringcOstringgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_maplEstringcOstringgR(void *p) { typedef map current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map namespace ROOT { static TClass *maplEstringcOintgR_Dictionary(); static void maplEstringcOintgR_TClassManip(TClass*); static void *new_maplEstringcOintgR(void *p = nullptr); static void *newArray_maplEstringcOintgR(Long_t size, void *p); static void delete_maplEstringcOintgR(void *p); static void deleteArray_maplEstringcOintgR(void *p); static void destruct_maplEstringcOintgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map*) { map *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map)); static ::ROOT::TGenericClassInfo instance("map", -2, "map", 100, typeid(map), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEstringcOintgR_Dictionary, isa_proxy, 0, sizeof(map) ); instance.SetNew(&new_maplEstringcOintgR); instance.SetNewArray(&newArray_maplEstringcOintgR); instance.SetDelete(&delete_maplEstringcOintgR); instance.SetDeleteArray(&deleteArray_maplEstringcOintgR); instance.SetDestructor(&destruct_maplEstringcOintgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map >())); ::ROOT::AddClassAlternate("map","std::map, std::allocator >, int, std::less, std::allocator > >, std::allocator, std::allocator > const, int> > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEstringcOintgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); maplEstringcOintgR_TClassManip(theClass); return theClass; } static void maplEstringcOintgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEstringcOintgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map : new map; } static void *newArray_maplEstringcOintgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEstringcOintgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_maplEstringcOintgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_maplEstringcOintgR(void *p) { typedef map current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map namespace ROOT { static TClass *maplEstringcOdoublegR_Dictionary(); static void maplEstringcOdoublegR_TClassManip(TClass*); static void *new_maplEstringcOdoublegR(void *p = nullptr); static void *newArray_maplEstringcOdoublegR(Long_t size, void *p); static void delete_maplEstringcOdoublegR(void *p); static void deleteArray_maplEstringcOdoublegR(void *p); static void destruct_maplEstringcOdoublegR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map*) { map *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map)); static ::ROOT::TGenericClassInfo instance("map", -2, "map", 100, typeid(map), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEstringcOdoublegR_Dictionary, isa_proxy, 0, sizeof(map) ); instance.SetNew(&new_maplEstringcOdoublegR); instance.SetNewArray(&newArray_maplEstringcOdoublegR); instance.SetDelete(&delete_maplEstringcOdoublegR); instance.SetDeleteArray(&deleteArray_maplEstringcOdoublegR); instance.SetDestructor(&destruct_maplEstringcOdoublegR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map >())); ::ROOT::AddClassAlternate("map","std::map, std::allocator >, double, std::less, std::allocator > >, std::allocator, std::allocator > const, double> > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEstringcOdoublegR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); maplEstringcOdoublegR_TClassManip(theClass); return theClass; } static void maplEstringcOdoublegR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEstringcOdoublegR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map : new map; } static void *newArray_maplEstringcOdoublegR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEstringcOdoublegR(void *p) { delete (static_cast*>(p)); } static void deleteArray_maplEstringcOdoublegR(void *p) { delete [] (static_cast*>(p)); } static void destruct_maplEstringcOdoublegR(void *p) { typedef map current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map namespace ROOT { static TClass *maplEstringcOTObjectmUgR_Dictionary(); static void maplEstringcOTObjectmUgR_TClassManip(TClass*); static void *new_maplEstringcOTObjectmUgR(void *p = nullptr); static void *newArray_maplEstringcOTObjectmUgR(Long_t size, void *p); static void delete_maplEstringcOTObjectmUgR(void *p); static void deleteArray_maplEstringcOTObjectmUgR(void *p); static void destruct_maplEstringcOTObjectmUgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map*) { map *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map)); static ::ROOT::TGenericClassInfo instance("map", -2, "map", 100, typeid(map), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEstringcOTObjectmUgR_Dictionary, isa_proxy, 0, sizeof(map) ); instance.SetNew(&new_maplEstringcOTObjectmUgR); instance.SetNewArray(&newArray_maplEstringcOTObjectmUgR); instance.SetDelete(&delete_maplEstringcOTObjectmUgR); instance.SetDeleteArray(&deleteArray_maplEstringcOTObjectmUgR); instance.SetDestructor(&destruct_maplEstringcOTObjectmUgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map >())); ::ROOT::AddClassAlternate("map","std::map, std::allocator >, TObject*, std::less, std::allocator > >, std::allocator, std::allocator > const, TObject*> > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEstringcOTObjectmUgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); maplEstringcOTObjectmUgR_TClassManip(theClass); return theClass; } static void maplEstringcOTObjectmUgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEstringcOTObjectmUgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map : new map; } static void *newArray_maplEstringcOTObjectmUgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEstringcOTObjectmUgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_maplEstringcOTObjectmUgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_maplEstringcOTObjectmUgR(void *p) { typedef map current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map namespace ROOT { static TClass *maplEstringcOParamStoremUgR_Dictionary(); static void maplEstringcOParamStoremUgR_TClassManip(TClass*); static void *new_maplEstringcOParamStoremUgR(void *p = nullptr); static void *newArray_maplEstringcOParamStoremUgR(Long_t size, void *p); static void delete_maplEstringcOParamStoremUgR(void *p); static void deleteArray_maplEstringcOParamStoremUgR(void *p); static void destruct_maplEstringcOParamStoremUgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map*) { map *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map)); static ::ROOT::TGenericClassInfo instance("map", -2, "map", 100, typeid(map), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEstringcOParamStoremUgR_Dictionary, isa_proxy, 0, sizeof(map) ); instance.SetNew(&new_maplEstringcOParamStoremUgR); instance.SetNewArray(&newArray_maplEstringcOParamStoremUgR); instance.SetDelete(&delete_maplEstringcOParamStoremUgR); instance.SetDeleteArray(&deleteArray_maplEstringcOParamStoremUgR); instance.SetDestructor(&destruct_maplEstringcOParamStoremUgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map >())); ::ROOT::AddClassAlternate("map","std::map, std::allocator >, ParamStore*, std::less, std::allocator > >, std::allocator, std::allocator > const, ParamStore*> > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEstringcOParamStoremUgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); maplEstringcOParamStoremUgR_TClassManip(theClass); return theClass; } static void maplEstringcOParamStoremUgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEstringcOParamStoremUgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map : new map; } static void *newArray_maplEstringcOParamStoremUgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEstringcOParamStoremUgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_maplEstringcOParamStoremUgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_maplEstringcOParamStoremUgR(void *p) { typedef map current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map namespace ROOT { static TClass *maplEstringcOIProcessmUgR_Dictionary(); static void maplEstringcOIProcessmUgR_TClassManip(TClass*); static void *new_maplEstringcOIProcessmUgR(void *p = nullptr); static void *newArray_maplEstringcOIProcessmUgR(Long_t size, void *p); static void delete_maplEstringcOIProcessmUgR(void *p); static void deleteArray_maplEstringcOIProcessmUgR(void *p); static void destruct_maplEstringcOIProcessmUgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map*) { map *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map)); static ::ROOT::TGenericClassInfo instance("map", -2, "map", 100, typeid(map), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEstringcOIProcessmUgR_Dictionary, isa_proxy, 0, sizeof(map) ); instance.SetNew(&new_maplEstringcOIProcessmUgR); instance.SetNewArray(&newArray_maplEstringcOIProcessmUgR); instance.SetDelete(&delete_maplEstringcOIProcessmUgR); instance.SetDeleteArray(&deleteArray_maplEstringcOIProcessmUgR); instance.SetDestructor(&destruct_maplEstringcOIProcessmUgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map >())); ::ROOT::AddClassAlternate("map","std::map, std::allocator >, IProcess*, std::less, std::allocator > >, std::allocator, std::allocator > const, IProcess*> > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEstringcOIProcessmUgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); maplEstringcOIProcessmUgR_TClassManip(theClass); return theClass; } static void maplEstringcOIProcessmUgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEstringcOIProcessmUgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map : new map; } static void *newArray_maplEstringcOIProcessmUgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEstringcOIProcessmUgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_maplEstringcOIProcessmUgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_maplEstringcOIProcessmUgR(void *p) { typedef map current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map namespace ROOT { static TClass *maplEintcOboolgR_Dictionary(); static void maplEintcOboolgR_TClassManip(TClass*); static void *new_maplEintcOboolgR(void *p = nullptr); static void *newArray_maplEintcOboolgR(Long_t size, void *p); static void delete_maplEintcOboolgR(void *p); static void deleteArray_maplEintcOboolgR(void *p); static void destruct_maplEintcOboolgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map*) { map *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map)); static ::ROOT::TGenericClassInfo instance("map", -2, "map", 100, typeid(map), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEintcOboolgR_Dictionary, isa_proxy, 0, sizeof(map) ); instance.SetNew(&new_maplEintcOboolgR); instance.SetNewArray(&newArray_maplEintcOboolgR); instance.SetDelete(&delete_maplEintcOboolgR); instance.SetDeleteArray(&deleteArray_maplEintcOboolgR); instance.SetDestructor(&destruct_maplEintcOboolgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map >())); ::ROOT::AddClassAlternate("map","std::map, std::allocator > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEintcOboolgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); maplEintcOboolgR_TClassManip(theClass); return theClass; } static void maplEintcOboolgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEintcOboolgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map : new map; } static void *newArray_maplEintcOboolgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEintcOboolgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_maplEintcOboolgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_maplEintcOboolgR(void *p) { typedef map current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map namespace ROOT { static TClass *maplEintcODCcLcLType_IT_INFOMODEgR_Dictionary(); static void maplEintcODCcLcLType_IT_INFOMODEgR_TClassManip(TClass*); static void *new_maplEintcODCcLcLType_IT_INFOMODEgR(void *p = nullptr); static void *newArray_maplEintcODCcLcLType_IT_INFOMODEgR(Long_t size, void *p); static void delete_maplEintcODCcLcLType_IT_INFOMODEgR(void *p); static void deleteArray_maplEintcODCcLcLType_IT_INFOMODEgR(void *p); static void destruct_maplEintcODCcLcLType_IT_INFOMODEgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map*) { map *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map)); static ::ROOT::TGenericClassInfo instance("map", -2, "map", 100, typeid(map), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEintcODCcLcLType_IT_INFOMODEgR_Dictionary, isa_proxy, 0, sizeof(map) ); instance.SetNew(&new_maplEintcODCcLcLType_IT_INFOMODEgR); instance.SetNewArray(&newArray_maplEintcODCcLcLType_IT_INFOMODEgR); instance.SetDelete(&delete_maplEintcODCcLcLType_IT_INFOMODEgR); instance.SetDeleteArray(&deleteArray_maplEintcODCcLcLType_IT_INFOMODEgR); instance.SetDestructor(&destruct_maplEintcODCcLcLType_IT_INFOMODEgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map >())); ::ROOT::AddClassAlternate("map","std::map, std::allocator > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEintcODCcLcLType_IT_INFOMODEgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); maplEintcODCcLcLType_IT_INFOMODEgR_TClassManip(theClass); return theClass; } static void maplEintcODCcLcLType_IT_INFOMODEgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEintcODCcLcLType_IT_INFOMODEgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map : new map; } static void *newArray_maplEintcODCcLcLType_IT_INFOMODEgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEintcODCcLcLType_IT_INFOMODEgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_maplEintcODCcLcLType_IT_INFOMODEgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_maplEintcODCcLcLType_IT_INFOMODEgR(void *p) { typedef map current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map namespace ROOT { static TClass *maplETStringcOlistlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgRsPgR_Dictionary(); static void maplETStringcOlistlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgRsPgR_TClassManip(TClass*); static void *new_maplETStringcOlistlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgRsPgR(void *p = nullptr); static void *newArray_maplETStringcOlistlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgRsPgR(Long_t size, void *p); static void delete_maplETStringcOlistlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgRsPgR(void *p); static void deleteArray_maplETStringcOlistlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgRsPgR(void *p); static void destruct_maplETStringcOlistlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map,list > > > >*) { map,list > > > > *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map,list > > > >)); static ::ROOT::TGenericClassInfo instance("map,list > > > >", -2, "map", 100, typeid(map,list > > > >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplETStringcOlistlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgRsPgR_Dictionary, isa_proxy, 0, sizeof(map,list > > > >) ); instance.SetNew(&new_maplETStringcOlistlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgRsPgR); instance.SetNewArray(&newArray_maplETStringcOlistlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgRsPgR); instance.SetDelete(&delete_maplETStringcOlistlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgRsPgR); instance.SetDeleteArray(&deleteArray_maplETStringcOlistlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgRsPgR); instance.SetDestructor(&destruct_maplETStringcOlistlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map,list > > > > >())); ::ROOT::AddClassAlternate("map,list > > > >","std::map, std::__cxx11::list, std::allocator > > >, std::allocator, std::__cxx11::list, std::allocator > > > > >, std::less, std::allocator, std::__cxx11::list, std::allocator > > >, std::allocator, std::__cxx11::list, std::allocator > > > > > > > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast,list > > > >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplETStringcOlistlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast,list > > > >*>(nullptr))->GetClass(); maplETStringcOlistlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgRsPgR_TClassManip(theClass); return theClass; } static void maplETStringcOlistlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplETStringcOlistlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgRsPgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map,list > > > > : new map,list > > > >; } static void *newArray_maplETStringcOlistlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgRsPgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map,list > > > >[nElements] : new map,list > > > >[nElements]; } // Wrapper around operator delete static void delete_maplETStringcOlistlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgRsPgR(void *p) { delete (static_cast,list > > > >*>(p)); } static void deleteArray_maplETStringcOlistlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgRsPgR(void *p) { delete [] (static_cast,list > > > >*>(p)); } static void destruct_maplETStringcOlistlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgRsPgR(void *p) { typedef map,list > > > > current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map,list > > > > namespace ROOT { static TClass *maplEIProcessmUcOstringgR_Dictionary(); static void maplEIProcessmUcOstringgR_TClassManip(TClass*); static void *new_maplEIProcessmUcOstringgR(void *p = nullptr); static void *newArray_maplEIProcessmUcOstringgR(Long_t size, void *p); static void delete_maplEIProcessmUcOstringgR(void *p); static void deleteArray_maplEIProcessmUcOstringgR(void *p); static void destruct_maplEIProcessmUcOstringgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map*) { map *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map)); static ::ROOT::TGenericClassInfo instance("map", -2, "map", 100, typeid(map), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEIProcessmUcOstringgR_Dictionary, isa_proxy, 0, sizeof(map) ); instance.SetNew(&new_maplEIProcessmUcOstringgR); instance.SetNewArray(&newArray_maplEIProcessmUcOstringgR); instance.SetDelete(&delete_maplEIProcessmUcOstringgR); instance.SetDeleteArray(&deleteArray_maplEIProcessmUcOstringgR); instance.SetDestructor(&destruct_maplEIProcessmUcOstringgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map >())); ::ROOT::AddClassAlternate("map","std::map, std::allocator >, std::less, std::allocator, std::allocator > > > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEIProcessmUcOstringgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); maplEIProcessmUcOstringgR_TClassManip(theClass); return theClass; } static void maplEIProcessmUcOstringgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEIProcessmUcOstringgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map : new map; } static void *newArray_maplEIProcessmUcOstringgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEIProcessmUcOstringgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_maplEIProcessmUcOstringgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_maplEIProcessmUcOstringgR(void *p) { typedef map current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map namespace ROOT { static TClass *maplEDCcLcLTypeTMB_CAM_CHcOunsignedsPshortgR_Dictionary(); static void maplEDCcLcLTypeTMB_CAM_CHcOunsignedsPshortgR_TClassManip(TClass*); static void *new_maplEDCcLcLTypeTMB_CAM_CHcOunsignedsPshortgR(void *p = nullptr); static void *newArray_maplEDCcLcLTypeTMB_CAM_CHcOunsignedsPshortgR(Long_t size, void *p); static void delete_maplEDCcLcLTypeTMB_CAM_CHcOunsignedsPshortgR(void *p); static void deleteArray_maplEDCcLcLTypeTMB_CAM_CHcOunsignedsPshortgR(void *p); static void destruct_maplEDCcLcLTypeTMB_CAM_CHcOunsignedsPshortgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const map*) { map *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map)); static ::ROOT::TGenericClassInfo instance("map", -2, "map", 100, typeid(map), ::ROOT::Internal::DefineBehavior(ptr, ptr), &maplEDCcLcLTypeTMB_CAM_CHcOunsignedsPshortgR_Dictionary, isa_proxy, 0, sizeof(map) ); instance.SetNew(&new_maplEDCcLcLTypeTMB_CAM_CHcOunsignedsPshortgR); instance.SetNewArray(&newArray_maplEDCcLcLTypeTMB_CAM_CHcOunsignedsPshortgR); instance.SetDelete(&delete_maplEDCcLcLTypeTMB_CAM_CHcOunsignedsPshortgR); instance.SetDeleteArray(&deleteArray_maplEDCcLcLTypeTMB_CAM_CHcOunsignedsPshortgR); instance.SetDestructor(&destruct_maplEDCcLcLTypeTMB_CAM_CHcOunsignedsPshortgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map >())); ::ROOT::AddClassAlternate("map","std::map, std::allocator > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *maplEDCcLcLTypeTMB_CAM_CHcOunsignedsPshortgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); maplEDCcLcLTypeTMB_CAM_CHcOunsignedsPshortgR_TClassManip(theClass); return theClass; } static void maplEDCcLcLTypeTMB_CAM_CHcOunsignedsPshortgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_maplEDCcLcLTypeTMB_CAM_CHcOunsignedsPshortgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map : new map; } static void *newArray_maplEDCcLcLTypeTMB_CAM_CHcOunsignedsPshortgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map[nElements] : new map[nElements]; } // Wrapper around operator delete static void delete_maplEDCcLcLTypeTMB_CAM_CHcOunsignedsPshortgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_maplEDCcLcLTypeTMB_CAM_CHcOunsignedsPshortgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_maplEDCcLcLTypeTMB_CAM_CHcOunsignedsPshortgR(void *p) { typedef map current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class map namespace ROOT { static TClass *listlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgR_Dictionary(); static void listlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgR_TClassManip(TClass*); static void *new_listlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgR(void *p = nullptr); static void *newArray_listlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgR(Long_t size, void *p); static void delete_listlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgR(void *p); static void deleteArray_listlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgR(void *p); static void destruct_listlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const list,list > > >*) { list,list > > > *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(list,list > > >)); static ::ROOT::TGenericClassInfo instance("list,list > > >", -2, "list", 632, typeid(list,list > > >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &listlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgR_Dictionary, isa_proxy, 0, sizeof(list,list > > >) ); instance.SetNew(&new_listlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgR); instance.SetNewArray(&newArray_listlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgR); instance.SetDelete(&delete_listlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgR); instance.SetDeleteArray(&deleteArray_listlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgR); instance.SetDestructor(&destruct_listlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< list,list > > > >())); ::ROOT::AddClassAlternate("list,list > > >","std::__cxx11::list, std::__cxx11::list, std::allocator > > >, std::allocator, std::__cxx11::list, std::allocator > > > > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast,list > > >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *listlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast,list > > >*>(nullptr))->GetClass(); listlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgR_TClassManip(theClass); return theClass; } static void listlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_listlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) list,list > > > : new list,list > > >; } static void *newArray_listlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) list,list > > >[nElements] : new list,list > > >[nElements]; } // Wrapper around operator delete static void delete_listlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgR(void *p) { delete (static_cast,list > > >*>(p)); } static void deleteArray_listlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgR(void *p) { delete [] (static_cast,list > > >*>(p)); } static void destruct_listlEpairlEpairlEunsignedsPintcOunsignedsPintgRcOlistlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRsPgR(void *p) { typedef list,list > > > current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class list,list > > > namespace ROOT { static TClass *listlETStringgR_Dictionary(); static void listlETStringgR_TClassManip(TClass*); static void *new_listlETStringgR(void *p = nullptr); static void *newArray_listlETStringgR(Long_t size, void *p); static void delete_listlETStringgR(void *p); static void deleteArray_listlETStringgR(void *p); static void destruct_listlETStringgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const list*) { list *ptr = nullptr; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(list)); static ::ROOT::TGenericClassInfo instance("list", -2, "list", 632, typeid(list), ::ROOT::Internal::DefineBehavior(ptr, ptr), &listlETStringgR_Dictionary, isa_proxy, 0, sizeof(list) ); instance.SetNew(&new_listlETStringgR); instance.SetNewArray(&newArray_listlETStringgR); instance.SetDelete(&delete_listlETStringgR); instance.SetDeleteArray(&deleteArray_listlETStringgR); instance.SetDestructor(&destruct_listlETStringgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< list >())); ::ROOT::AddClassAlternate("list","std::__cxx11::list >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *listlETStringgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast*>(nullptr))->GetClass(); listlETStringgR_TClassManip(theClass); return theClass; } static void listlETStringgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_listlETStringgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) list : new list; } static void *newArray_listlETStringgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) list[nElements] : new list[nElements]; } // Wrapper around operator delete static void delete_listlETStringgR(void *p) { delete (static_cast*>(p)); } static void deleteArray_listlETStringgR(void *p) { delete [] (static_cast*>(p)); } static void destruct_listlETStringgR(void *p) { typedef list current_t; (static_cast(p))->~current_t(); } } // end of namespace ROOT for class list namespace { void TriggerDictionaryInitialization_DCEEvent_dict_Impl() { static const char* headers[] = { "DCEEvent.hh", nullptr }; static const char* includePaths[] = { "/opt/root/install/include/", "/home/yaroslav/work/double_chooz/programs/dogs_source/Prod-10-02-p16/DCEvent/", nullptr }; static const char* fwdDeclCode = R"DICTFWDDCLS( #line 1 "DCEEvent_dict dictionary forward declarations' payload" #pragma clang diagnostic ignored "-Wkeyword-compat" #pragma clang diagnostic ignored "-Wignored-attributes" #pragma clang diagnostic ignored "-Wreturn-type-c-linkage" extern int __Cling_AutoLoading_Map; class __attribute__((annotate("$clingAutoload$DCEPMTHit.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) PMTHit; namespace std{template class __attribute__((annotate("$clingAutoload$bits/allocator.h"))) __attribute__((annotate("$clingAutoload$string"))) allocator; } class __attribute__((annotate("$clingAutoload$DCEParamStore.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) ParamStore; class __attribute__((annotate("$clingAutoload$DCEIProcess.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) IProcess; class __attribute__((annotate("$clingAutoload$DCEInfoUnit.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) InfoUnit; class __attribute__((annotate("$clingAutoload$DCEProcessor.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) Processor; class __attribute__((annotate("$clingAutoload$DCELoopProcessor.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) LoopProcessor; class __attribute__((annotate("$clingAutoload$DCEParameterInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) ParameterInfo; class __attribute__((annotate("$clingAutoload$DCEOVHit.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) OVHit; class __attribute__((annotate("$clingAutoload$DCEOVInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) OVInfo; class __attribute__((annotate("$clingAutoload$DCEOVInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) OVCell; class __attribute__((annotate("$clingAutoload$DCEFileDB.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) FileDB; class __attribute__((annotate("$clingAutoload$DCEInfoIO.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) InfoIO; class __attribute__((annotate("$clingAutoload$DCEGlobalInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) GlobalInfo; class __attribute__((annotate("$clingAutoload$DCEGlobalThInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) GlobalThInfo; class __attribute__((annotate("$clingAutoload$DCEPulseInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) PulseInfo; class __attribute__((annotate("$clingAutoload$DCEPulsePeakWinInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) PulsePeakWinInfo; class __attribute__((annotate("$clingAutoload$DCEPulseSlideWinInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) PulseSlideWinInfo; class __attribute__((annotate("$clingAutoload$DCEPulseThInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) PulseThInfo; class __attribute__((annotate("$clingAutoload$DCEPulseProfInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) PulseProfInfo; class __attribute__((annotate("$clingAutoload$DCEPulseProfThInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) PulseProfThInfo; class __attribute__((annotate("$clingAutoload$DCEMuPulseInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) MuPulseInfo; class __attribute__((annotate("$clingAutoload$DCEMuPulseThInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) MuPulseThInfo; class __attribute__((annotate("$clingAutoload$DCEMuPulseProfInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) MuPulseProfInfo; class __attribute__((annotate("$clingAutoload$DCEMuPulseProfThInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) MuPulseProfThInfo; class __attribute__((annotate("$clingAutoload$DCERecoVertexInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) RecoVertexInfo; class __attribute__((annotate("$clingAutoload$DCERecoTrackInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) RecoTrackInfo; class __attribute__((annotate("$clingAutoload$DCERecoMOSCOWInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) RecoMOSCOWInfo; class __attribute__((annotate("$clingAutoload$DCERecoTOFInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) RecoTOFInfo; class __attribute__((annotate("$clingAutoload$DCERecoBAMAInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) RecoBAMAInfo; class __attribute__((annotate("$clingAutoload$DCERecoNNIVInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) RecoNNIVInfo; class __attribute__((annotate("$clingAutoload$DCECocoRecoInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) CocoRecoInfo; class __attribute__((annotate("$clingAutoload$DCERecoEnergyInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) RecoEnergyInfo; class __attribute__((annotate("$clingAutoload$DCEERecoHDInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) ERecoHDInfo; class __attribute__((annotate("$clingAutoload$DCERecoThInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) RecoThInfo; class __attribute__((annotate("$clingAutoload$DCERecoMuonInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) RecoMuonInfo; class __attribute__((annotate("$clingAutoload$DCERecoMuonThInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) RecoMuonThInfo; class __attribute__((annotate("$clingAutoload$DCERecoMuonAPCInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) RecoMuonAPCInfo; class __attribute__((annotate("$clingAutoload$DCERecoMuonIVBCInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) RecoMuonIVBCInfo; class __attribute__((annotate("$clingAutoload$DCERecoMuonIVMLInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) RecoMuonIVMLInfo; class __attribute__((annotate("$clingAutoload$DCERecoMuHamIDInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) RecoMuHamIDInfo; class __attribute__((annotate("$clingAutoload$DCERecoMuonFIDOInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) RecoMuonFIDOInfo; class __attribute__((annotate("$clingAutoload$DCERecoOVMergeInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) RecoOVMergeInfo; class __attribute__((annotate("$clingAutoload$OVXYInFile.h"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) OVXYInFile; class __attribute__((annotate("$clingAutoload$OVTrackInFile.h"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) OVTrackInFile; class __attribute__((annotate("$clingAutoload$DCERecoDtInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) RecoDtInfo; class __attribute__((annotate("$clingAutoload$DCECalibrationInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) CalibrationInfo; class __attribute__((annotate("$clingAutoload$DCEIDLIInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) IDLIInfo; class __attribute__((annotate("$clingAutoload$DCEParticleThInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) ParticleThInfo; class __attribute__((annotate("$clingAutoload$DCETrackThInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) TrackThInfo; class __attribute__((annotate("$clingAutoload$DCEMCInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) MCInfo; class __attribute__((annotate("$clingAutoload$DCERunInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) RunInfo; class __attribute__((annotate("$clingAutoload$DCETMFileThInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) TMFileThInfo; class __attribute__((annotate("$clingAutoload$DCEDynRunInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) DynRunInfo; class __attribute__((annotate("$clingAutoload$DCEDynEventInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) DynEventInfo; class __attribute__((annotate("$clingAutoload$DCENuGenThInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) NuGenThInfo; class __attribute__((annotate("$clingAutoload$DCEMCStep.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) MCStep; class __attribute__((annotate("$clingAutoload$DCEMCTrack.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) MCTrack; class __attribute__((annotate("$clingAutoload$DCEOVHitInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) OVHitInfo; class __attribute__((annotate("$clingAutoload$DCEOVHitThInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) OVHitThInfo; class __attribute__((annotate("$clingAutoload$DCETriggerSummarizedInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) TriggerSummarizedInfo; class __attribute__((annotate("$clingAutoload$DCETriggerInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) TriggerInfo; class __attribute__((annotate("$clingAutoload$DCETriggerDiagnosisInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) TBInfo; class __attribute__((annotate("$clingAutoload$DCETriggerDiagnosisInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) TMBInfo; class __attribute__((annotate("$clingAutoload$DCETriggerDiagnosisInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) TriggerDiagnosisInfo; class __attribute__((annotate("$clingAutoload$DCELightInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) LightInfo; class __attribute__((annotate("$clingAutoload$DCELightEUpp.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) LightEUpp; class __attribute__((annotate("$clingAutoload$DCELightJP.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) LightJP; class __attribute__((annotate("$clingAutoload$DCELightUnited.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) LightUnited; class __attribute__((annotate("$clingAutoload$DCELightAPCMultiS.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) LightAPCMS; class __attribute__((annotate("$clingAutoload$DCEAccidental.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) Accidental; class __attribute__((annotate("$clingAutoload$DCERecoJPInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) RecoJPInfo; class __attribute__((annotate("$clingAutoload$DCEMiniPulseInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) MiniPulseInfo; class __attribute__((annotate("$clingAutoload$DCEMuonTDCInfo.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) MuonTDCInfo; class __attribute__((annotate("$clingAutoload$DCERunVLD.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) RunVLD; class __attribute__((annotate("$clingAutoload$DCEEnDep.hh"))) __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) EnDep; class __attribute__((annotate("$clingAutoload$DCEEvent.hh"))) Event; )DICTFWDDCLS"; static const char* payloadCode = R"DICTPAYLOAD( #line 1 "DCEEvent_dict dictionary payload" #define _BACKWARD_BACKWARD_WARNING_H // Inline headers #include "DCEEvent.hh" #undef _BACKWARD_BACKWARD_WARNING_H )DICTPAYLOAD"; static const char* classesHeaders[] = { "Accidental", payloadCode, "@", "CalibrationInfo", payloadCode, "@", "CocoRecoInfo", payloadCode, "@", "DynEventInfo", payloadCode, "@", "DynRunInfo", payloadCode, "@", "ERecoHDInfo", payloadCode, "@", "EnDep", payloadCode, "@", "Event", payloadCode, "@", "FileDB", payloadCode, "@", "GlobalInfo", payloadCode, "@", "GlobalThInfo", payloadCode, "@", "IDLIInfo", payloadCode, "@", "IProcess", payloadCode, "@", "InfoIO", payloadCode, "@", "InfoUnit", payloadCode, "@", "LightAPCMS", payloadCode, "@", "LightEUpp", payloadCode, "@", "LightInfo", payloadCode, "@", "LightJP", payloadCode, "@", "LightUnited", payloadCode, "@", "LoopProcessor", payloadCode, "@", "MCInfo", payloadCode, "@", "MCStep", payloadCode, "@", "MCTrack", payloadCode, "@", "MiniPulseInfo", payloadCode, "@", "MuPulseInfo", payloadCode, "@", "MuPulseProfInfo", payloadCode, "@", "MuPulseProfThInfo", payloadCode, "@", "MuPulseThInfo", payloadCode, "@", "MuonTDCInfo", payloadCode, "@", "NuGenThInfo", payloadCode, "@", "OVCell", payloadCode, "@", "OVHit", payloadCode, "@", "OVHitInfo", payloadCode, "@", "OVHitThInfo", payloadCode, "@", "OVInfo", payloadCode, "@", "OVTrackInFile", payloadCode, "@", "OVXYInFile", payloadCode, "@", "PMTHit", payloadCode, "@", "ParamStore", payloadCode, "@", "ParameterInfo", payloadCode, "@", "ParticleThInfo", payloadCode, "@", "Processor", payloadCode, "@", "PulseInfo", payloadCode, "@", "PulsePeakWinInfo", payloadCode, "@", "PulseProfInfo", payloadCode, "@", "PulseProfThInfo", payloadCode, "@", "PulseSlideWinInfo", payloadCode, "@", "PulseThInfo", payloadCode, "@", "RecoBAMAInfo", payloadCode, "@", "RecoDtInfo", payloadCode, "@", "RecoEnergyInfo", payloadCode, "@", "RecoJPInfo", payloadCode, "@", "RecoMOSCOWInfo", payloadCode, "@", "RecoMuHamIDInfo", payloadCode, "@", "RecoMuonAPCInfo", payloadCode, "@", "RecoMuonFIDOInfo", payloadCode, "@", "RecoMuonIVBCInfo", payloadCode, "@", "RecoMuonIVMLInfo", payloadCode, "@", "RecoMuonInfo", payloadCode, "@", "RecoMuonThInfo", payloadCode, "@", "RecoNNIVInfo", payloadCode, "@", "RecoOVMergeInfo", payloadCode, "@", "RecoTOFInfo", payloadCode, "@", "RecoThInfo", payloadCode, "@", "RecoTrackInfo", payloadCode, "@", "RecoVertexInfo", payloadCode, "@", "RunInfo", payloadCode, "@", "RunVLD", payloadCode, "@", "TBInfo", payloadCode, "@", "TMBInfo", payloadCode, "@", "TMFileThInfo", payloadCode, "@", "TrackThInfo", payloadCode, "@", "TriggerDiagnosisInfo", payloadCode, "@", "TriggerInfo", payloadCode, "@", "TriggerSummarizedInfo", payloadCode, "@", nullptr }; static bool isInitialized = false; if (!isInitialized) { TROOT::RegisterModule("DCEEvent_dict", headers, includePaths, payloadCode, fwdDeclCode, TriggerDictionaryInitialization_DCEEvent_dict_Impl, {}, classesHeaders, /*hasCxxModule*/false); isInitialized = true; } } static struct DictInit { DictInit() { TriggerDictionaryInitialization_DCEEvent_dict_Impl(); } } __TheDictionaryInitializer; } void TriggerDictionaryInitialization_DCEEvent_dict() { TriggerDictionaryInitialization_DCEEvent_dict_Impl(); }