x86_64-el9-gcc13-dbg/Event/RootEventData/RootEventDataDict.cxx

Go to the documentation of this file.

// Do NOT change. Changes will be lost next time file is generated
 
#define R__DICTIONARY_FILENAME RootEventDataDict
#define R__NO_DEPRECATION
 
/*******************************************************************/
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#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 <algorithm>
#include "TCollectionProxyInfo.h"
/*******************************************************************/
 
#include "TDataMember.h"
 
// Header files passed as explicit arguments
#include "include/RootEventData/TBossFullEvent.h"
#include "include/RootEventData/TDigiEvent.h"
#include "include/RootEventData/TDisTrack.h"
#include "include/RootEventData/TDstEvent.h"
#include "include/RootEventData/TDstHltInf.h"
#include "include/RootEventData/TEmcDigi.h"
#include "include/RootEventData/TEmcMc.h"
#include "include/RootEventData/TEmcTrack.h"
#include "include/RootEventData/TEvtHeader.h"
#include "include/RootEventData/TEvtNavigator.h"
#include "include/RootEventData/TEvtRecDTag.h"
#include "include/RootEventData/TEvtRecEtaToGG.h"
#include "include/RootEventData/TEvtRecEvent.h"
#include "include/RootEventData/TEvtRecObject.h"
#include "include/RootEventData/TEvtRecPi0.h"
#include "include/RootEventData/TEvtRecPrimaryVertex.h"
#include "include/RootEventData/TEvtRecTrack.h"
#include "include/RootEventData/TEvtRecVeeVertex.h"
#include "include/RootEventData/TExtTrack.h"
#include "include/RootEventData/THltEvent.h"
#include "include/RootEventData/THltInf.h"
#include "include/RootEventData/THltRaw.h"
#include "include/RootEventData/TJobInfo.h"
#include "include/RootEventData/TLumiDigi.h"
#include "include/RootEventData/TMcDigiEmc.h"
#include "include/RootEventData/TMcEvent.h"
#include "include/RootEventData/TMcHitEvent.h"
#include "include/RootEventData/TMcHitMdc.h"
#include "include/RootEventData/TMcHitTof.h"
#include "include/RootEventData/TMcParticle.h"
#include "include/RootEventData/TMdcDedx.h"
#include "include/RootEventData/TMdcDigi.h"
#include "include/RootEventData/TMdcKalTrack.h"
#include "include/RootEventData/TMdcMc.h"
#include "include/RootEventData/TMdcTrack.h"
#include "include/RootEventData/TMucDigi.h"
#include "include/RootEventData/TMucMc.h"
#include "include/RootEventData/TMucTrack.h"
#include "include/RootEventData/TRawData.h"
#include "include/RootEventData/TRecEmcCluster.h"
#include "include/RootEventData/TRecEmcHit.h"
#include "include/RootEventData/TRecEmcShower.h"
#include "include/RootEventData/TRecEvTime.h"
#include "include/RootEventData/TRecExtTrack.h"
#include "include/RootEventData/TRecMdcDedx.h"
#include "include/RootEventData/TRecMdcDedxHit.h"
#include "include/RootEventData/TRecMdcHit.h"
#include "include/RootEventData/TRecMdcKalHelixSeg.h"
#include "include/RootEventData/TRecMdcKalTrack.h"
#include "include/RootEventData/TRecMdcTrack.h"
#include "include/RootEventData/TRecMucTrack.h"
#include "include/RootEventData/TRecTofTrack.h"
#include "include/RootEventData/TRecTrackEvent.h"
#include "include/RootEventData/TRecZddChannel.h"
#include "include/RootEventData/TTofDigi.h"
#include "include/RootEventData/TTofMc.h"
#include "include/RootEventData/TTofTrack.h"
#include "include/RootEventData/TTrigData.h"
#include "include/RootEventData/TTrigEvent.h"
 
// Header files passed via #pragma extra_include
 
// The generated code does not explicitly qualify STL entities
namespace std {} using namespace std;
 
namespace ROOT {
   static void *new_TRawData(void *p = nullptr);
   static void *newArray_TRawData(Long_t size, void *p);
   static void delete_TRawData(void *p);
   static void deleteArray_TRawData(void *p);
   static void destruct_TRawData(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRawData*)
   {
      ::TRawData *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRawData >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TRawData", ::TRawData::Class_Version(), "RootEventData/TRawData.h", 6,
                  typeid(::TRawData), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TRawData::Dictionary, isa_proxy, 4,
                  sizeof(::TRawData) );
      instance.SetNew(&new_TRawData);
      instance.SetNewArray(&newArray_TRawData);
      instance.SetDelete(&delete_TRawData);
      instance.SetDeleteArray(&deleteArray_TRawData);
      instance.SetDestructor(&destruct_TRawData);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRawData*)
   {
      return GenerateInitInstanceLocal(static_cast<::TRawData*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TRawData*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TEmcDigi(void *p = nullptr);
   static void *newArray_TEmcDigi(Long_t size, void *p);
   static void delete_TEmcDigi(void *p);
   static void deleteArray_TEmcDigi(void *p);
   static void destruct_TEmcDigi(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEmcDigi*)
   {
      ::TEmcDigi *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEmcDigi >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TEmcDigi", ::TEmcDigi::Class_Version(), "RootEventData/TEmcDigi.h", 6,
                  typeid(::TEmcDigi), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TEmcDigi::Dictionary, isa_proxy, 4,
                  sizeof(::TEmcDigi) );
      instance.SetNew(&new_TEmcDigi);
      instance.SetNewArray(&newArray_TEmcDigi);
      instance.SetDelete(&delete_TEmcDigi);
      instance.SetDeleteArray(&deleteArray_TEmcDigi);
      instance.SetDestructor(&destruct_TEmcDigi);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEmcDigi*)
   {
      return GenerateInitInstanceLocal(static_cast<::TEmcDigi*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TEmcDigi*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TLumiDigi(void *p = nullptr);
   static void *newArray_TLumiDigi(Long_t size, void *p);
   static void delete_TLumiDigi(void *p);
   static void deleteArray_TLumiDigi(void *p);
   static void destruct_TLumiDigi(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TLumiDigi*)
   {
      ::TLumiDigi *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TLumiDigi >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TLumiDigi", ::TLumiDigi::Class_Version(), "RootEventData/TLumiDigi.h", 6,
                  typeid(::TLumiDigi), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TLumiDigi::Dictionary, isa_proxy, 4,
                  sizeof(::TLumiDigi) );
      instance.SetNew(&new_TLumiDigi);
      instance.SetNewArray(&newArray_TLumiDigi);
      instance.SetDelete(&delete_TLumiDigi);
      instance.SetDeleteArray(&deleteArray_TLumiDigi);
      instance.SetDestructor(&destruct_TLumiDigi);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TLumiDigi*)
   {
      return GenerateInitInstanceLocal(static_cast<::TLumiDigi*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TLumiDigi*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TMdcDigi(void *p = nullptr);
   static void *newArray_TMdcDigi(Long_t size, void *p);
   static void delete_TMdcDigi(void *p);
   static void deleteArray_TMdcDigi(void *p);
   static void destruct_TMdcDigi(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMdcDigi*)
   {
      ::TMdcDigi *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMdcDigi >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TMdcDigi", ::TMdcDigi::Class_Version(), "RootEventData/TMdcDigi.h", 6,
                  typeid(::TMdcDigi), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TMdcDigi::Dictionary, isa_proxy, 4,
                  sizeof(::TMdcDigi) );
      instance.SetNew(&new_TMdcDigi);
      instance.SetNewArray(&newArray_TMdcDigi);
      instance.SetDelete(&delete_TMdcDigi);
      instance.SetDeleteArray(&deleteArray_TMdcDigi);
      instance.SetDestructor(&destruct_TMdcDigi);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMdcDigi*)
   {
      return GenerateInitInstanceLocal(static_cast<::TMdcDigi*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TMdcDigi*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TMucDigi(void *p = nullptr);
   static void *newArray_TMucDigi(Long_t size, void *p);
   static void delete_TMucDigi(void *p);
   static void deleteArray_TMucDigi(void *p);
   static void destruct_TMucDigi(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMucDigi*)
   {
      ::TMucDigi *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMucDigi >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TMucDigi", ::TMucDigi::Class_Version(), "RootEventData/TMucDigi.h", 6,
                  typeid(::TMucDigi), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TMucDigi::Dictionary, isa_proxy, 4,
                  sizeof(::TMucDigi) );
      instance.SetNew(&new_TMucDigi);
      instance.SetNewArray(&newArray_TMucDigi);
      instance.SetDelete(&delete_TMucDigi);
      instance.SetDeleteArray(&deleteArray_TMucDigi);
      instance.SetDestructor(&destruct_TMucDigi);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMucDigi*)
   {
      return GenerateInitInstanceLocal(static_cast<::TMucDigi*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TMucDigi*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TTofDigi(void *p = nullptr);
   static void *newArray_TTofDigi(Long_t size, void *p);
   static void delete_TTofDigi(void *p);
   static void deleteArray_TTofDigi(void *p);
   static void destruct_TTofDigi(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTofDigi*)
   {
      ::TTofDigi *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTofDigi >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TTofDigi", ::TTofDigi::Class_Version(), "RootEventData/TTofDigi.h", 6,
                  typeid(::TTofDigi), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TTofDigi::Dictionary, isa_proxy, 4,
                  sizeof(::TTofDigi) );
      instance.SetNew(&new_TTofDigi);
      instance.SetNewArray(&newArray_TTofDigi);
      instance.SetDelete(&delete_TTofDigi);
      instance.SetDeleteArray(&deleteArray_TTofDigi);
      instance.SetDestructor(&destruct_TTofDigi);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TTofDigi*)
   {
      return GenerateInitInstanceLocal(static_cast<::TTofDigi*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TTofDigi*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TDigiEvent(void *p = nullptr);
   static void *newArray_TDigiEvent(Long_t size, void *p);
   static void delete_TDigiEvent(void *p);
   static void deleteArray_TDigiEvent(void *p);
   static void destruct_TDigiEvent(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDigiEvent*)
   {
      ::TDigiEvent *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDigiEvent >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TDigiEvent", ::TDigiEvent::Class_Version(), "RootEventData/TDigiEvent.h", 14,
                  typeid(::TDigiEvent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TDigiEvent::Dictionary, isa_proxy, 4,
                  sizeof(::TDigiEvent) );
      instance.SetNew(&new_TDigiEvent);
      instance.SetNewArray(&newArray_TDigiEvent);
      instance.SetDelete(&delete_TDigiEvent);
      instance.SetDeleteArray(&deleteArray_TDigiEvent);
      instance.SetDestructor(&destruct_TDigiEvent);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TDigiEvent*)
   {
      return GenerateInitInstanceLocal(static_cast<::TDigiEvent*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TDigiEvent*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TEmcTrack(void *p = nullptr);
   static void *newArray_TEmcTrack(Long_t size, void *p);
   static void delete_TEmcTrack(void *p);
   static void deleteArray_TEmcTrack(void *p);
   static void destruct_TEmcTrack(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEmcTrack*)
   {
      ::TEmcTrack *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEmcTrack >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TEmcTrack", ::TEmcTrack::Class_Version(), "RootEventData/TEmcTrack.h", 7,
                  typeid(::TEmcTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TEmcTrack::Dictionary, isa_proxy, 4,
                  sizeof(::TEmcTrack) );
      instance.SetNew(&new_TEmcTrack);
      instance.SetNewArray(&newArray_TEmcTrack);
      instance.SetDelete(&delete_TEmcTrack);
      instance.SetDeleteArray(&deleteArray_TEmcTrack);
      instance.SetDestructor(&destruct_TEmcTrack);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEmcTrack*)
   {
      return GenerateInitInstanceLocal(static_cast<::TEmcTrack*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TEmcTrack*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TExtTrack(void *p = nullptr);
   static void *newArray_TExtTrack(Long_t size, void *p);
   static void delete_TExtTrack(void *p);
   static void deleteArray_TExtTrack(void *p);
   static void destruct_TExtTrack(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TExtTrack*)
   {
      ::TExtTrack *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TExtTrack >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TExtTrack", ::TExtTrack::Class_Version(), "RootEventData/TExtTrack.h", 9,
                  typeid(::TExtTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TExtTrack::Dictionary, isa_proxy, 4,
                  sizeof(::TExtTrack) );
      instance.SetNew(&new_TExtTrack);
      instance.SetNewArray(&newArray_TExtTrack);
      instance.SetDelete(&delete_TExtTrack);
      instance.SetDeleteArray(&deleteArray_TExtTrack);
      instance.SetDestructor(&destruct_TExtTrack);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TExtTrack*)
   {
      return GenerateInitInstanceLocal(static_cast<::TExtTrack*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TExtTrack*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TMdcDedx(void *p = nullptr);
   static void *newArray_TMdcDedx(Long_t size, void *p);
   static void delete_TMdcDedx(void *p);
   static void deleteArray_TMdcDedx(void *p);
   static void destruct_TMdcDedx(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMdcDedx*)
   {
      ::TMdcDedx *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMdcDedx >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TMdcDedx", ::TMdcDedx::Class_Version(), "RootEventData/TMdcDedx.h", 6,
                  typeid(::TMdcDedx), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TMdcDedx::Dictionary, isa_proxy, 4,
                  sizeof(::TMdcDedx) );
      instance.SetNew(&new_TMdcDedx);
      instance.SetNewArray(&newArray_TMdcDedx);
      instance.SetDelete(&delete_TMdcDedx);
      instance.SetDeleteArray(&deleteArray_TMdcDedx);
      instance.SetDestructor(&destruct_TMdcDedx);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMdcDedx*)
   {
      return GenerateInitInstanceLocal(static_cast<::TMdcDedx*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TMdcDedx*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TMdcKalTrack(void *p = nullptr);
   static void *newArray_TMdcKalTrack(Long_t size, void *p);
   static void delete_TMdcKalTrack(void *p);
   static void deleteArray_TMdcKalTrack(void *p);
   static void destruct_TMdcKalTrack(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMdcKalTrack*)
   {
      ::TMdcKalTrack *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMdcKalTrack >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TMdcKalTrack", ::TMdcKalTrack::Class_Version(), "RootEventData/TMdcKalTrack.h", 8,
                  typeid(::TMdcKalTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TMdcKalTrack::Dictionary, isa_proxy, 4,
                  sizeof(::TMdcKalTrack) );
      instance.SetNew(&new_TMdcKalTrack);
      instance.SetNewArray(&newArray_TMdcKalTrack);
      instance.SetDelete(&delete_TMdcKalTrack);
      instance.SetDeleteArray(&deleteArray_TMdcKalTrack);
      instance.SetDestructor(&destruct_TMdcKalTrack);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMdcKalTrack*)
   {
      return GenerateInitInstanceLocal(static_cast<::TMdcKalTrack*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TMdcKalTrack*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TMdcTrack(void *p = nullptr);
   static void *newArray_TMdcTrack(Long_t size, void *p);
   static void delete_TMdcTrack(void *p);
   static void deleteArray_TMdcTrack(void *p);
   static void destruct_TMdcTrack(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMdcTrack*)
   {
      ::TMdcTrack *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMdcTrack >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TMdcTrack", ::TMdcTrack::Class_Version(), "RootEventData/TMdcTrack.h", 6,
                  typeid(::TMdcTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TMdcTrack::Dictionary, isa_proxy, 4,
                  sizeof(::TMdcTrack) );
      instance.SetNew(&new_TMdcTrack);
      instance.SetNewArray(&newArray_TMdcTrack);
      instance.SetDelete(&delete_TMdcTrack);
      instance.SetDeleteArray(&deleteArray_TMdcTrack);
      instance.SetDestructor(&destruct_TMdcTrack);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMdcTrack*)
   {
      return GenerateInitInstanceLocal(static_cast<::TMdcTrack*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TMdcTrack*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TMucTrack(void *p = nullptr);
   static void *newArray_TMucTrack(Long_t size, void *p);
   static void delete_TMucTrack(void *p);
   static void deleteArray_TMucTrack(void *p);
   static void destruct_TMucTrack(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMucTrack*)
   {
      ::TMucTrack *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMucTrack >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TMucTrack", ::TMucTrack::Class_Version(), "RootEventData/TMucTrack.h", 9,
                  typeid(::TMucTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TMucTrack::Dictionary, isa_proxy, 4,
                  sizeof(::TMucTrack) );
      instance.SetNew(&new_TMucTrack);
      instance.SetNewArray(&newArray_TMucTrack);
      instance.SetDelete(&delete_TMucTrack);
      instance.SetDeleteArray(&deleteArray_TMucTrack);
      instance.SetDestructor(&destruct_TMucTrack);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMucTrack*)
   {
      return GenerateInitInstanceLocal(static_cast<::TMucTrack*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TMucTrack*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TTofTrack(void *p = nullptr);
   static void *newArray_TTofTrack(Long_t size, void *p);
   static void delete_TTofTrack(void *p);
   static void deleteArray_TTofTrack(void *p);
   static void destruct_TTofTrack(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTofTrack*)
   {
      ::TTofTrack *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTofTrack >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TTofTrack", ::TTofTrack::Class_Version(), "RootEventData/TTofTrack.h", 9,
                  typeid(::TTofTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TTofTrack::Dictionary, isa_proxy, 4,
                  sizeof(::TTofTrack) );
      instance.SetNew(&new_TTofTrack);
      instance.SetNewArray(&newArray_TTofTrack);
      instance.SetDelete(&delete_TTofTrack);
      instance.SetDeleteArray(&deleteArray_TTofTrack);
      instance.SetDestructor(&destruct_TTofTrack);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TTofTrack*)
   {
      return GenerateInitInstanceLocal(static_cast<::TTofTrack*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TTofTrack*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TDstEvent(void *p = nullptr);
   static void *newArray_TDstEvent(Long_t size, void *p);
   static void delete_TDstEvent(void *p);
   static void deleteArray_TDstEvent(void *p);
   static void destruct_TDstEvent(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDstEvent*)
   {
      ::TDstEvent *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDstEvent >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TDstEvent", ::TDstEvent::Class_Version(), "RootEventData/TDstEvent.h", 16,
                  typeid(::TDstEvent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TDstEvent::Dictionary, isa_proxy, 4,
                  sizeof(::TDstEvent) );
      instance.SetNew(&new_TDstEvent);
      instance.SetNewArray(&newArray_TDstEvent);
      instance.SetDelete(&delete_TDstEvent);
      instance.SetDeleteArray(&deleteArray_TDstEvent);
      instance.SetDestructor(&destruct_TDstEvent);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TDstEvent*)
   {
      return GenerateInitInstanceLocal(static_cast<::TDstEvent*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TDstEvent*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TEvtHeader(void *p = nullptr);
   static void *newArray_TEvtHeader(Long_t size, void *p);
   static void delete_TEvtHeader(void *p);
   static void deleteArray_TEvtHeader(void *p);
   static void destruct_TEvtHeader(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtHeader*)
   {
      ::TEvtHeader *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtHeader >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TEvtHeader", ::TEvtHeader::Class_Version(), "RootEventData/TEvtHeader.h", 7,
                  typeid(::TEvtHeader), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TEvtHeader::Dictionary, isa_proxy, 4,
                  sizeof(::TEvtHeader) );
      instance.SetNew(&new_TEvtHeader);
      instance.SetNewArray(&newArray_TEvtHeader);
      instance.SetDelete(&delete_TEvtHeader);
      instance.SetDeleteArray(&deleteArray_TEvtHeader);
      instance.SetDestructor(&destruct_TEvtHeader);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEvtHeader*)
   {
      return GenerateInitInstanceLocal(static_cast<::TEvtHeader*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TEvtHeader*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TEvtRecDTag(void *p = nullptr);
   static void *newArray_TEvtRecDTag(Long_t size, void *p);
   static void delete_TEvtRecDTag(void *p);
   static void deleteArray_TEvtRecDTag(void *p);
   static void destruct_TEvtRecDTag(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecDTag*)
   {
      ::TEvtRecDTag *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecDTag >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TEvtRecDTag", ::TEvtRecDTag::Class_Version(), "RootEventData/TEvtRecDTag.h", 7,
                  typeid(::TEvtRecDTag), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TEvtRecDTag::Dictionary, isa_proxy, 4,
                  sizeof(::TEvtRecDTag) );
      instance.SetNew(&new_TEvtRecDTag);
      instance.SetNewArray(&newArray_TEvtRecDTag);
      instance.SetDelete(&delete_TEvtRecDTag);
      instance.SetDeleteArray(&deleteArray_TEvtRecDTag);
      instance.SetDestructor(&destruct_TEvtRecDTag);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEvtRecDTag*)
   {
      return GenerateInitInstanceLocal(static_cast<::TEvtRecDTag*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TEvtRecDTag*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TEvtRecEtaToGG(void *p = nullptr);
   static void *newArray_TEvtRecEtaToGG(Long_t size, void *p);
   static void delete_TEvtRecEtaToGG(void *p);
   static void deleteArray_TEvtRecEtaToGG(void *p);
   static void destruct_TEvtRecEtaToGG(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecEtaToGG*)
   {
      ::TEvtRecEtaToGG *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecEtaToGG >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TEvtRecEtaToGG", ::TEvtRecEtaToGG::Class_Version(), "RootEventData/TEvtRecEtaToGG.h", 7,
                  typeid(::TEvtRecEtaToGG), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TEvtRecEtaToGG::Dictionary, isa_proxy, 4,
                  sizeof(::TEvtRecEtaToGG) );
      instance.SetNew(&new_TEvtRecEtaToGG);
      instance.SetNewArray(&newArray_TEvtRecEtaToGG);
      instance.SetDelete(&delete_TEvtRecEtaToGG);
      instance.SetDeleteArray(&deleteArray_TEvtRecEtaToGG);
      instance.SetDestructor(&destruct_TEvtRecEtaToGG);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEvtRecEtaToGG*)
   {
      return GenerateInitInstanceLocal(static_cast<::TEvtRecEtaToGG*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TEvtRecEtaToGG*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TEvtRecEvent(void *p = nullptr);
   static void *newArray_TEvtRecEvent(Long_t size, void *p);
   static void delete_TEvtRecEvent(void *p);
   static void deleteArray_TEvtRecEvent(void *p);
   static void destruct_TEvtRecEvent(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecEvent*)
   {
      ::TEvtRecEvent *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecEvent >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TEvtRecEvent", ::TEvtRecEvent::Class_Version(), "RootEventData/TEvtRecEvent.h", 7,
                  typeid(::TEvtRecEvent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TEvtRecEvent::Dictionary, isa_proxy, 4,
                  sizeof(::TEvtRecEvent) );
      instance.SetNew(&new_TEvtRecEvent);
      instance.SetNewArray(&newArray_TEvtRecEvent);
      instance.SetDelete(&delete_TEvtRecEvent);
      instance.SetDeleteArray(&deleteArray_TEvtRecEvent);
      instance.SetDestructor(&destruct_TEvtRecEvent);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEvtRecEvent*)
   {
      return GenerateInitInstanceLocal(static_cast<::TEvtRecEvent*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TEvtRecEvent*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TEvtRecPi0(void *p = nullptr);
   static void *newArray_TEvtRecPi0(Long_t size, void *p);
   static void delete_TEvtRecPi0(void *p);
   static void deleteArray_TEvtRecPi0(void *p);
   static void destruct_TEvtRecPi0(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecPi0*)
   {
      ::TEvtRecPi0 *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecPi0 >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TEvtRecPi0", ::TEvtRecPi0::Class_Version(), "RootEventData/TEvtRecPi0.h", 7,
                  typeid(::TEvtRecPi0), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TEvtRecPi0::Dictionary, isa_proxy, 4,
                  sizeof(::TEvtRecPi0) );
      instance.SetNew(&new_TEvtRecPi0);
      instance.SetNewArray(&newArray_TEvtRecPi0);
      instance.SetDelete(&delete_TEvtRecPi0);
      instance.SetDeleteArray(&deleteArray_TEvtRecPi0);
      instance.SetDestructor(&destruct_TEvtRecPi0);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEvtRecPi0*)
   {
      return GenerateInitInstanceLocal(static_cast<::TEvtRecPi0*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TEvtRecPi0*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TEvtRecPrimaryVertex(void *p = nullptr);
   static void *newArray_TEvtRecPrimaryVertex(Long_t size, void *p);
   static void delete_TEvtRecPrimaryVertex(void *p);
   static void deleteArray_TEvtRecPrimaryVertex(void *p);
   static void destruct_TEvtRecPrimaryVertex(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecPrimaryVertex*)
   {
      ::TEvtRecPrimaryVertex *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecPrimaryVertex >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TEvtRecPrimaryVertex", ::TEvtRecPrimaryVertex::Class_Version(), "RootEventData/TEvtRecPrimaryVertex.h", 7,
                  typeid(::TEvtRecPrimaryVertex), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TEvtRecPrimaryVertex::Dictionary, isa_proxy, 4,
                  sizeof(::TEvtRecPrimaryVertex) );
      instance.SetNew(&new_TEvtRecPrimaryVertex);
      instance.SetNewArray(&newArray_TEvtRecPrimaryVertex);
      instance.SetDelete(&delete_TEvtRecPrimaryVertex);
      instance.SetDeleteArray(&deleteArray_TEvtRecPrimaryVertex);
      instance.SetDestructor(&destruct_TEvtRecPrimaryVertex);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEvtRecPrimaryVertex*)
   {
      return GenerateInitInstanceLocal(static_cast<::TEvtRecPrimaryVertex*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TEvtRecPrimaryVertex*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TEvtRecTrack(void *p = nullptr);
   static void *newArray_TEvtRecTrack(Long_t size, void *p);
   static void delete_TEvtRecTrack(void *p);
   static void deleteArray_TEvtRecTrack(void *p);
   static void destruct_TEvtRecTrack(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecTrack*)
   {
      ::TEvtRecTrack *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecTrack >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TEvtRecTrack", ::TEvtRecTrack::Class_Version(), "RootEventData/TEvtRecTrack.h", 7,
                  typeid(::TEvtRecTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TEvtRecTrack::Dictionary, isa_proxy, 4,
                  sizeof(::TEvtRecTrack) );
      instance.SetNew(&new_TEvtRecTrack);
      instance.SetNewArray(&newArray_TEvtRecTrack);
      instance.SetDelete(&delete_TEvtRecTrack);
      instance.SetDeleteArray(&deleteArray_TEvtRecTrack);
      instance.SetDestructor(&destruct_TEvtRecTrack);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEvtRecTrack*)
   {
      return GenerateInitInstanceLocal(static_cast<::TEvtRecTrack*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TEvtRecTrack*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TEvtRecVeeVertex(void *p = nullptr);
   static void *newArray_TEvtRecVeeVertex(Long_t size, void *p);
   static void delete_TEvtRecVeeVertex(void *p);
   static void deleteArray_TEvtRecVeeVertex(void *p);
   static void destruct_TEvtRecVeeVertex(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecVeeVertex*)
   {
      ::TEvtRecVeeVertex *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecVeeVertex >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TEvtRecVeeVertex", ::TEvtRecVeeVertex::Class_Version(), "RootEventData/TEvtRecVeeVertex.h", 6,
                  typeid(::TEvtRecVeeVertex), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TEvtRecVeeVertex::Dictionary, isa_proxy, 4,
                  sizeof(::TEvtRecVeeVertex) );
      instance.SetNew(&new_TEvtRecVeeVertex);
      instance.SetNewArray(&newArray_TEvtRecVeeVertex);
      instance.SetDelete(&delete_TEvtRecVeeVertex);
      instance.SetDeleteArray(&deleteArray_TEvtRecVeeVertex);
      instance.SetDestructor(&destruct_TEvtRecVeeVertex);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEvtRecVeeVertex*)
   {
      return GenerateInitInstanceLocal(static_cast<::TEvtRecVeeVertex*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TEvtRecVeeVertex*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TEvtRecObject(void *p = nullptr);
   static void *newArray_TEvtRecObject(Long_t size, void *p);
   static void delete_TEvtRecObject(void *p);
   static void deleteArray_TEvtRecObject(void *p);
   static void destruct_TEvtRecObject(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtRecObject*)
   {
      ::TEvtRecObject *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecObject >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TEvtRecObject", ::TEvtRecObject::Class_Version(), "RootEventData/TEvtRecObject.h", 15,
                  typeid(::TEvtRecObject), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TEvtRecObject::Dictionary, isa_proxy, 4,
                  sizeof(::TEvtRecObject) );
      instance.SetNew(&new_TEvtRecObject);
      instance.SetNewArray(&newArray_TEvtRecObject);
      instance.SetDelete(&delete_TEvtRecObject);
      instance.SetDeleteArray(&deleteArray_TEvtRecObject);
      instance.SetDestructor(&destruct_TEvtRecObject);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEvtRecObject*)
   {
      return GenerateInitInstanceLocal(static_cast<::TEvtRecObject*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TEvtRecObject*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TDstHltInf(void *p = nullptr);
   static void *newArray_TDstHltInf(Long_t size, void *p);
   static void delete_TDstHltInf(void *p);
   static void deleteArray_TDstHltInf(void *p);
   static void destruct_TDstHltInf(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDstHltInf*)
   {
      ::TDstHltInf *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDstHltInf >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TDstHltInf", ::TDstHltInf::Class_Version(), "RootEventData/TDstHltInf.h", 9,
                  typeid(::TDstHltInf), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TDstHltInf::Dictionary, isa_proxy, 4,
                  sizeof(::TDstHltInf) );
      instance.SetNew(&new_TDstHltInf);
      instance.SetNewArray(&newArray_TDstHltInf);
      instance.SetDelete(&delete_TDstHltInf);
      instance.SetDeleteArray(&deleteArray_TDstHltInf);
      instance.SetDestructor(&destruct_TDstHltInf);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TDstHltInf*)
   {
      return GenerateInitInstanceLocal(static_cast<::TDstHltInf*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TDstHltInf*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_THltInf(void *p = nullptr);
   static void *newArray_THltInf(Long_t size, void *p);
   static void delete_THltInf(void *p);
   static void deleteArray_THltInf(void *p);
   static void destruct_THltInf(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THltInf*)
   {
      ::THltInf *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THltInf >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("THltInf", ::THltInf::Class_Version(), "RootEventData/THltInf.h", 9,
                  typeid(::THltInf), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::THltInf::Dictionary, isa_proxy, 4,
                  sizeof(::THltInf) );
      instance.SetNew(&new_THltInf);
      instance.SetNewArray(&newArray_THltInf);
      instance.SetDelete(&delete_THltInf);
      instance.SetDeleteArray(&deleteArray_THltInf);
      instance.SetDestructor(&destruct_THltInf);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THltInf*)
   {
      return GenerateInitInstanceLocal(static_cast<::THltInf*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::THltInf*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_THltRaw(void *p = nullptr);
   static void *newArray_THltRaw(Long_t size, void *p);
   static void delete_THltRaw(void *p);
   static void deleteArray_THltRaw(void *p);
   static void destruct_THltRaw(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THltRaw*)
   {
      ::THltRaw *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THltRaw >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("THltRaw", ::THltRaw::Class_Version(), "RootEventData/THltRaw.h", 6,
                  typeid(::THltRaw), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::THltRaw::Dictionary, isa_proxy, 4,
                  sizeof(::THltRaw) );
      instance.SetNew(&new_THltRaw);
      instance.SetNewArray(&newArray_THltRaw);
      instance.SetDelete(&delete_THltRaw);
      instance.SetDeleteArray(&deleteArray_THltRaw);
      instance.SetDestructor(&destruct_THltRaw);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THltRaw*)
   {
      return GenerateInitInstanceLocal(static_cast<::THltRaw*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::THltRaw*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_THltEvent(void *p = nullptr);
   static void *newArray_THltEvent(Long_t size, void *p);
   static void delete_THltEvent(void *p);
   static void deleteArray_THltEvent(void *p);
   static void destruct_THltEvent(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THltEvent*)
   {
      ::THltEvent *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THltEvent >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("THltEvent", ::THltEvent::Class_Version(), "RootEventData/THltEvent.h", 12,
                  typeid(::THltEvent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::THltEvent::Dictionary, isa_proxy, 4,
                  sizeof(::THltEvent) );
      instance.SetNew(&new_THltEvent);
      instance.SetNewArray(&newArray_THltEvent);
      instance.SetDelete(&delete_THltEvent);
      instance.SetDeleteArray(&deleteArray_THltEvent);
      instance.SetDestructor(&destruct_THltEvent);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THltEvent*)
   {
      return GenerateInitInstanceLocal(static_cast<::THltEvent*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::THltEvent*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TEmcMc(void *p = nullptr);
   static void *newArray_TEmcMc(Long_t size, void *p);
   static void delete_TEmcMc(void *p);
   static void deleteArray_TEmcMc(void *p);
   static void destruct_TEmcMc(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEmcMc*)
   {
      ::TEmcMc *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEmcMc >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TEmcMc", ::TEmcMc::Class_Version(), "RootEventData/TEmcMc.h", 10,
                  typeid(::TEmcMc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TEmcMc::Dictionary, isa_proxy, 4,
                  sizeof(::TEmcMc) );
      instance.SetNew(&new_TEmcMc);
      instance.SetNewArray(&newArray_TEmcMc);
      instance.SetDelete(&delete_TEmcMc);
      instance.SetDeleteArray(&deleteArray_TEmcMc);
      instance.SetDestructor(&destruct_TEmcMc);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEmcMc*)
   {
      return GenerateInitInstanceLocal(static_cast<::TEmcMc*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TEmcMc*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TMcParticle(void *p = nullptr);
   static void *newArray_TMcParticle(Long_t size, void *p);
   static void delete_TMcParticle(void *p);
   static void deleteArray_TMcParticle(void *p);
   static void destruct_TMcParticle(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMcParticle*)
   {
      ::TMcParticle *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcParticle >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TMcParticle", ::TMcParticle::Class_Version(), "RootEventData/TMcParticle.h", 9,
                  typeid(::TMcParticle), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TMcParticle::Dictionary, isa_proxy, 4,
                  sizeof(::TMcParticle) );
      instance.SetNew(&new_TMcParticle);
      instance.SetNewArray(&newArray_TMcParticle);
      instance.SetDelete(&delete_TMcParticle);
      instance.SetDeleteArray(&deleteArray_TMcParticle);
      instance.SetDestructor(&destruct_TMcParticle);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMcParticle*)
   {
      return GenerateInitInstanceLocal(static_cast<::TMcParticle*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TMcParticle*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TMdcMc(void *p = nullptr);
   static void *newArray_TMdcMc(Long_t size, void *p);
   static void delete_TMdcMc(void *p);
   static void deleteArray_TMdcMc(void *p);
   static void destruct_TMdcMc(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMdcMc*)
   {
      ::TMdcMc *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMdcMc >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TMdcMc", ::TMdcMc::Class_Version(), "RootEventData/TMdcMc.h", 9,
                  typeid(::TMdcMc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TMdcMc::Dictionary, isa_proxy, 4,
                  sizeof(::TMdcMc) );
      instance.SetNew(&new_TMdcMc);
      instance.SetNewArray(&newArray_TMdcMc);
      instance.SetDelete(&delete_TMdcMc);
      instance.SetDeleteArray(&deleteArray_TMdcMc);
      instance.SetDestructor(&destruct_TMdcMc);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMdcMc*)
   {
      return GenerateInitInstanceLocal(static_cast<::TMdcMc*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TMdcMc*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TMucMc(void *p = nullptr);
   static void *newArray_TMucMc(Long_t size, void *p);
   static void delete_TMucMc(void *p);
   static void deleteArray_TMucMc(void *p);
   static void destruct_TMucMc(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMucMc*)
   {
      ::TMucMc *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMucMc >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TMucMc", ::TMucMc::Class_Version(), "RootEventData/TMucMc.h", 8,
                  typeid(::TMucMc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TMucMc::Dictionary, isa_proxy, 4,
                  sizeof(::TMucMc) );
      instance.SetNew(&new_TMucMc);
      instance.SetNewArray(&newArray_TMucMc);
      instance.SetDelete(&delete_TMucMc);
      instance.SetDeleteArray(&deleteArray_TMucMc);
      instance.SetDestructor(&destruct_TMucMc);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMucMc*)
   {
      return GenerateInitInstanceLocal(static_cast<::TMucMc*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TMucMc*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TTofMc(void *p = nullptr);
   static void *newArray_TTofMc(Long_t size, void *p);
   static void delete_TTofMc(void *p);
   static void deleteArray_TTofMc(void *p);
   static void destruct_TTofMc(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTofMc*)
   {
      ::TTofMc *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTofMc >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TTofMc", ::TTofMc::Class_Version(), "RootEventData/TTofMc.h", 8,
                  typeid(::TTofMc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TTofMc::Dictionary, isa_proxy, 4,
                  sizeof(::TTofMc) );
      instance.SetNew(&new_TTofMc);
      instance.SetNewArray(&newArray_TTofMc);
      instance.SetDelete(&delete_TTofMc);
      instance.SetDeleteArray(&deleteArray_TTofMc);
      instance.SetDestructor(&destruct_TTofMc);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TTofMc*)
   {
      return GenerateInitInstanceLocal(static_cast<::TTofMc*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TTofMc*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TMcEvent(void *p = nullptr);
   static void *newArray_TMcEvent(Long_t size, void *p);
   static void delete_TMcEvent(void *p);
   static void deleteArray_TMcEvent(void *p);
   static void destruct_TMcEvent(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMcEvent*)
   {
      ::TMcEvent *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcEvent >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TMcEvent", ::TMcEvent::Class_Version(), "RootEventData/TMcEvent.h", 16,
                  typeid(::TMcEvent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TMcEvent::Dictionary, isa_proxy, 4,
                  sizeof(::TMcEvent) );
      instance.SetNew(&new_TMcEvent);
      instance.SetNewArray(&newArray_TMcEvent);
      instance.SetDelete(&delete_TMcEvent);
      instance.SetDeleteArray(&deleteArray_TMcEvent);
      instance.SetDestructor(&destruct_TMcEvent);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMcEvent*)
   {
      return GenerateInitInstanceLocal(static_cast<::TMcEvent*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TMcEvent*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TRecEmcCluster(void *p = nullptr);
   static void *newArray_TRecEmcCluster(Long_t size, void *p);
   static void delete_TRecEmcCluster(void *p);
   static void deleteArray_TRecEmcCluster(void *p);
   static void destruct_TRecEmcCluster(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecEmcCluster*)
   {
      ::TRecEmcCluster *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecEmcCluster >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TRecEmcCluster", ::TRecEmcCluster::Class_Version(), "RootEventData/TRecEmcCluster.h", 9,
                  typeid(::TRecEmcCluster), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TRecEmcCluster::Dictionary, isa_proxy, 4,
                  sizeof(::TRecEmcCluster) );
      instance.SetNew(&new_TRecEmcCluster);
      instance.SetNewArray(&newArray_TRecEmcCluster);
      instance.SetDelete(&delete_TRecEmcCluster);
      instance.SetDeleteArray(&deleteArray_TRecEmcCluster);
      instance.SetDestructor(&destruct_TRecEmcCluster);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRecEmcCluster*)
   {
      return GenerateInitInstanceLocal(static_cast<::TRecEmcCluster*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TRecEmcCluster*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TRecEmcHit(void *p = nullptr);
   static void *newArray_TRecEmcHit(Long_t size, void *p);
   static void delete_TRecEmcHit(void *p);
   static void deleteArray_TRecEmcHit(void *p);
   static void destruct_TRecEmcHit(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecEmcHit*)
   {
      ::TRecEmcHit *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecEmcHit >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TRecEmcHit", ::TRecEmcHit::Class_Version(), "RootEventData/TRecEmcHit.h", 9,
                  typeid(::TRecEmcHit), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TRecEmcHit::Dictionary, isa_proxy, 4,
                  sizeof(::TRecEmcHit) );
      instance.SetNew(&new_TRecEmcHit);
      instance.SetNewArray(&newArray_TRecEmcHit);
      instance.SetDelete(&delete_TRecEmcHit);
      instance.SetDeleteArray(&deleteArray_TRecEmcHit);
      instance.SetDestructor(&destruct_TRecEmcHit);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRecEmcHit*)
   {
      return GenerateInitInstanceLocal(static_cast<::TRecEmcHit*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TRecEmcHit*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TRecEmcShower(void *p = nullptr);
   static void *newArray_TRecEmcShower(Long_t size, void *p);
   static void delete_TRecEmcShower(void *p);
   static void deleteArray_TRecEmcShower(void *p);
   static void destruct_TRecEmcShower(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecEmcShower*)
   {
      ::TRecEmcShower *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecEmcShower >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TRecEmcShower", ::TRecEmcShower::Class_Version(), "RootEventData/TRecEmcShower.h", 11,
                  typeid(::TRecEmcShower), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TRecEmcShower::Dictionary, isa_proxy, 4,
                  sizeof(::TRecEmcShower) );
      instance.SetNew(&new_TRecEmcShower);
      instance.SetNewArray(&newArray_TRecEmcShower);
      instance.SetDelete(&delete_TRecEmcShower);
      instance.SetDeleteArray(&deleteArray_TRecEmcShower);
      instance.SetDestructor(&destruct_TRecEmcShower);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRecEmcShower*)
   {
      return GenerateInitInstanceLocal(static_cast<::TRecEmcShower*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TRecEmcShower*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TRecEvTime(void *p = nullptr);
   static void *newArray_TRecEvTime(Long_t size, void *p);
   static void delete_TRecEvTime(void *p);
   static void deleteArray_TRecEvTime(void *p);
   static void destruct_TRecEvTime(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecEvTime*)
   {
      ::TRecEvTime *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecEvTime >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TRecEvTime", ::TRecEvTime::Class_Version(), "RootEventData/TRecEvTime.h", 9,
                  typeid(::TRecEvTime), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TRecEvTime::Dictionary, isa_proxy, 4,
                  sizeof(::TRecEvTime) );
      instance.SetNew(&new_TRecEvTime);
      instance.SetNewArray(&newArray_TRecEvTime);
      instance.SetDelete(&delete_TRecEvTime);
      instance.SetDeleteArray(&deleteArray_TRecEvTime);
      instance.SetDestructor(&destruct_TRecEvTime);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRecEvTime*)
   {
      return GenerateInitInstanceLocal(static_cast<::TRecEvTime*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TRecEvTime*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TRecExtTrack(void *p = nullptr);
   static void *newArray_TRecExtTrack(Long_t size, void *p);
   static void delete_TRecExtTrack(void *p);
   static void deleteArray_TRecExtTrack(void *p);
   static void destruct_TRecExtTrack(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecExtTrack*)
   {
      ::TRecExtTrack *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecExtTrack >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TRecExtTrack", ::TRecExtTrack::Class_Version(), "RootEventData/TRecExtTrack.h", 8,
                  typeid(::TRecExtTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TRecExtTrack::Dictionary, isa_proxy, 4,
                  sizeof(::TRecExtTrack) );
      instance.SetNew(&new_TRecExtTrack);
      instance.SetNewArray(&newArray_TRecExtTrack);
      instance.SetDelete(&delete_TRecExtTrack);
      instance.SetDeleteArray(&deleteArray_TRecExtTrack);
      instance.SetDestructor(&destruct_TRecExtTrack);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRecExtTrack*)
   {
      return GenerateInitInstanceLocal(static_cast<::TRecExtTrack*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TRecExtTrack*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TRecMdcDedx(void *p = nullptr);
   static void *newArray_TRecMdcDedx(Long_t size, void *p);
   static void delete_TRecMdcDedx(void *p);
   static void deleteArray_TRecMdcDedx(void *p);
   static void destruct_TRecMdcDedx(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecMdcDedx*)
   {
      ::TRecMdcDedx *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcDedx >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TRecMdcDedx", ::TRecMdcDedx::Class_Version(), "RootEventData/TRecMdcDedx.h", 6,
                  typeid(::TRecMdcDedx), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TRecMdcDedx::Dictionary, isa_proxy, 4,
                  sizeof(::TRecMdcDedx) );
      instance.SetNew(&new_TRecMdcDedx);
      instance.SetNewArray(&newArray_TRecMdcDedx);
      instance.SetDelete(&delete_TRecMdcDedx);
      instance.SetDeleteArray(&deleteArray_TRecMdcDedx);
      instance.SetDestructor(&destruct_TRecMdcDedx);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRecMdcDedx*)
   {
      return GenerateInitInstanceLocal(static_cast<::TRecMdcDedx*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TRecMdcDedx*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TRecMdcDedxHit(void *p = nullptr);
   static void *newArray_TRecMdcDedxHit(Long_t size, void *p);
   static void delete_TRecMdcDedxHit(void *p);
   static void deleteArray_TRecMdcDedxHit(void *p);
   static void destruct_TRecMdcDedxHit(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecMdcDedxHit*)
   {
      ::TRecMdcDedxHit *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcDedxHit >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TRecMdcDedxHit", ::TRecMdcDedxHit::Class_Version(), "RootEventData/TRecMdcDedxHit.h", 7,
                  typeid(::TRecMdcDedxHit), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TRecMdcDedxHit::Dictionary, isa_proxy, 4,
                  sizeof(::TRecMdcDedxHit) );
      instance.SetNew(&new_TRecMdcDedxHit);
      instance.SetNewArray(&newArray_TRecMdcDedxHit);
      instance.SetDelete(&delete_TRecMdcDedxHit);
      instance.SetDeleteArray(&deleteArray_TRecMdcDedxHit);
      instance.SetDestructor(&destruct_TRecMdcDedxHit);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRecMdcDedxHit*)
   {
      return GenerateInitInstanceLocal(static_cast<::TRecMdcDedxHit*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TRecMdcDedxHit*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TRecMdcHit(void *p = nullptr);
   static void *newArray_TRecMdcHit(Long_t size, void *p);
   static void delete_TRecMdcHit(void *p);
   static void deleteArray_TRecMdcHit(void *p);
   static void destruct_TRecMdcHit(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecMdcHit*)
   {
      ::TRecMdcHit *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcHit >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TRecMdcHit", ::TRecMdcHit::Class_Version(), "RootEventData/TRecMdcHit.h", 9,
                  typeid(::TRecMdcHit), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TRecMdcHit::Dictionary, isa_proxy, 4,
                  sizeof(::TRecMdcHit) );
      instance.SetNew(&new_TRecMdcHit);
      instance.SetNewArray(&newArray_TRecMdcHit);
      instance.SetDelete(&delete_TRecMdcHit);
      instance.SetDeleteArray(&deleteArray_TRecMdcHit);
      instance.SetDestructor(&destruct_TRecMdcHit);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRecMdcHit*)
   {
      return GenerateInitInstanceLocal(static_cast<::TRecMdcHit*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TRecMdcHit*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TRecMdcKalHelixSeg(void *p = nullptr);
   static void *newArray_TRecMdcKalHelixSeg(Long_t size, void *p);
   static void delete_TRecMdcKalHelixSeg(void *p);
   static void deleteArray_TRecMdcKalHelixSeg(void *p);
   static void destruct_TRecMdcKalHelixSeg(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecMdcKalHelixSeg*)
   {
      ::TRecMdcKalHelixSeg *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcKalHelixSeg >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TRecMdcKalHelixSeg", ::TRecMdcKalHelixSeg::Class_Version(), "RootEventData/TRecMdcKalHelixSeg.h", 9,
                  typeid(::TRecMdcKalHelixSeg), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TRecMdcKalHelixSeg::Dictionary, isa_proxy, 4,
                  sizeof(::TRecMdcKalHelixSeg) );
      instance.SetNew(&new_TRecMdcKalHelixSeg);
      instance.SetNewArray(&newArray_TRecMdcKalHelixSeg);
      instance.SetDelete(&delete_TRecMdcKalHelixSeg);
      instance.SetDeleteArray(&deleteArray_TRecMdcKalHelixSeg);
      instance.SetDestructor(&destruct_TRecMdcKalHelixSeg);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRecMdcKalHelixSeg*)
   {
      return GenerateInitInstanceLocal(static_cast<::TRecMdcKalHelixSeg*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TRecMdcKalHelixSeg*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TRecMdcKalTrack(void *p = nullptr);
   static void *newArray_TRecMdcKalTrack(Long_t size, void *p);
   static void delete_TRecMdcKalTrack(void *p);
   static void deleteArray_TRecMdcKalTrack(void *p);
   static void destruct_TRecMdcKalTrack(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecMdcKalTrack*)
   {
      ::TRecMdcKalTrack *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcKalTrack >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TRecMdcKalTrack", ::TRecMdcKalTrack::Class_Version(), "RootEventData/TRecMdcKalTrack.h", 7,
                  typeid(::TRecMdcKalTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TRecMdcKalTrack::Dictionary, isa_proxy, 4,
                  sizeof(::TRecMdcKalTrack) );
      instance.SetNew(&new_TRecMdcKalTrack);
      instance.SetNewArray(&newArray_TRecMdcKalTrack);
      instance.SetDelete(&delete_TRecMdcKalTrack);
      instance.SetDeleteArray(&deleteArray_TRecMdcKalTrack);
      instance.SetDestructor(&destruct_TRecMdcKalTrack);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRecMdcKalTrack*)
   {
      return GenerateInitInstanceLocal(static_cast<::TRecMdcKalTrack*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TRecMdcKalTrack*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TRecMdcTrack(void *p = nullptr);
   static void *newArray_TRecMdcTrack(Long_t size, void *p);
   static void delete_TRecMdcTrack(void *p);
   static void deleteArray_TRecMdcTrack(void *p);
   static void destruct_TRecMdcTrack(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecMdcTrack*)
   {
      ::TRecMdcTrack *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcTrack >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TRecMdcTrack", ::TRecMdcTrack::Class_Version(), "RootEventData/TRecMdcTrack.h", 9,
                  typeid(::TRecMdcTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TRecMdcTrack::Dictionary, isa_proxy, 4,
                  sizeof(::TRecMdcTrack) );
      instance.SetNew(&new_TRecMdcTrack);
      instance.SetNewArray(&newArray_TRecMdcTrack);
      instance.SetDelete(&delete_TRecMdcTrack);
      instance.SetDeleteArray(&deleteArray_TRecMdcTrack);
      instance.SetDestructor(&destruct_TRecMdcTrack);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRecMdcTrack*)
   {
      return GenerateInitInstanceLocal(static_cast<::TRecMdcTrack*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TRecMdcTrack*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TRecMucTrack(void *p = nullptr);
   static void *newArray_TRecMucTrack(Long_t size, void *p);
   static void delete_TRecMucTrack(void *p);
   static void deleteArray_TRecMucTrack(void *p);
   static void destruct_TRecMucTrack(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecMucTrack*)
   {
      ::TRecMucTrack *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMucTrack >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TRecMucTrack", ::TRecMucTrack::Class_Version(), "RootEventData/TRecMucTrack.h", 9,
                  typeid(::TRecMucTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TRecMucTrack::Dictionary, isa_proxy, 4,
                  sizeof(::TRecMucTrack) );
      instance.SetNew(&new_TRecMucTrack);
      instance.SetNewArray(&newArray_TRecMucTrack);
      instance.SetDelete(&delete_TRecMucTrack);
      instance.SetDeleteArray(&deleteArray_TRecMucTrack);
      instance.SetDestructor(&destruct_TRecMucTrack);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRecMucTrack*)
   {
      return GenerateInitInstanceLocal(static_cast<::TRecMucTrack*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TRecMucTrack*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TRecTofTrack(void *p = nullptr);
   static void *newArray_TRecTofTrack(Long_t size, void *p);
   static void delete_TRecTofTrack(void *p);
   static void deleteArray_TRecTofTrack(void *p);
   static void destruct_TRecTofTrack(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecTofTrack*)
   {
      ::TRecTofTrack *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecTofTrack >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TRecTofTrack", ::TRecTofTrack::Class_Version(), "RootEventData/TRecTofTrack.h", 9,
                  typeid(::TRecTofTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TRecTofTrack::Dictionary, isa_proxy, 4,
                  sizeof(::TRecTofTrack) );
      instance.SetNew(&new_TRecTofTrack);
      instance.SetNewArray(&newArray_TRecTofTrack);
      instance.SetDelete(&delete_TRecTofTrack);
      instance.SetDeleteArray(&deleteArray_TRecTofTrack);
      instance.SetDestructor(&destruct_TRecTofTrack);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRecTofTrack*)
   {
      return GenerateInitInstanceLocal(static_cast<::TRecTofTrack*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TRecTofTrack*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TRecZddChannel(void *p = nullptr);
   static void *newArray_TRecZddChannel(Long_t size, void *p);
   static void delete_TRecZddChannel(void *p);
   static void deleteArray_TRecZddChannel(void *p);
   static void destruct_TRecZddChannel(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecZddChannel*)
   {
      ::TRecZddChannel *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecZddChannel >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TRecZddChannel", ::TRecZddChannel::Class_Version(), "RootEventData/TRecZddChannel.h", 8,
                  typeid(::TRecZddChannel), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TRecZddChannel::Dictionary, isa_proxy, 4,
                  sizeof(::TRecZddChannel) );
      instance.SetNew(&new_TRecZddChannel);
      instance.SetNewArray(&newArray_TRecZddChannel);
      instance.SetDelete(&delete_TRecZddChannel);
      instance.SetDeleteArray(&deleteArray_TRecZddChannel);
      instance.SetDestructor(&destruct_TRecZddChannel);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRecZddChannel*)
   {
      return GenerateInitInstanceLocal(static_cast<::TRecZddChannel*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TRecZddChannel*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TRecTrackEvent(void *p = nullptr);
   static void *newArray_TRecTrackEvent(Long_t size, void *p);
   static void delete_TRecTrackEvent(void *p);
   static void deleteArray_TRecTrackEvent(void *p);
   static void destruct_TRecTrackEvent(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRecTrackEvent*)
   {
      ::TRecTrackEvent *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecTrackEvent >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TRecTrackEvent", ::TRecTrackEvent::Class_Version(), "RootEventData/TRecTrackEvent.h", 24,
                  typeid(::TRecTrackEvent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TRecTrackEvent::Dictionary, isa_proxy, 4,
                  sizeof(::TRecTrackEvent) );
      instance.SetNew(&new_TRecTrackEvent);
      instance.SetNewArray(&newArray_TRecTrackEvent);
      instance.SetDelete(&delete_TRecTrackEvent);
      instance.SetDeleteArray(&deleteArray_TRecTrackEvent);
      instance.SetDestructor(&destruct_TRecTrackEvent);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRecTrackEvent*)
   {
      return GenerateInitInstanceLocal(static_cast<::TRecTrackEvent*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TRecTrackEvent*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TTrigData(void *p = nullptr);
   static void *newArray_TTrigData(Long_t size, void *p);
   static void delete_TTrigData(void *p);
   static void deleteArray_TTrigData(void *p);
   static void destruct_TTrigData(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTrigData*)
   {
      ::TTrigData *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTrigData >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TTrigData", ::TTrigData::Class_Version(), "RootEventData/TTrigData.h", 8,
                  typeid(::TTrigData), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TTrigData::Dictionary, isa_proxy, 4,
                  sizeof(::TTrigData) );
      instance.SetNew(&new_TTrigData);
      instance.SetNewArray(&newArray_TTrigData);
      instance.SetDelete(&delete_TTrigData);
      instance.SetDeleteArray(&deleteArray_TTrigData);
      instance.SetDestructor(&destruct_TTrigData);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TTrigData*)
   {
      return GenerateInitInstanceLocal(static_cast<::TTrigData*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TTrigData*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TTrigEvent(void *p = nullptr);
   static void *newArray_TTrigEvent(Long_t size, void *p);
   static void delete_TTrigEvent(void *p);
   static void deleteArray_TTrigEvent(void *p);
   static void destruct_TTrigEvent(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTrigEvent*)
   {
      ::TTrigEvent *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTrigEvent >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TTrigEvent", ::TTrigEvent::Class_Version(), "RootEventData/TTrigEvent.h", 10,
                  typeid(::TTrigEvent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TTrigEvent::Dictionary, isa_proxy, 4,
                  sizeof(::TTrigEvent) );
      instance.SetNew(&new_TTrigEvent);
      instance.SetNewArray(&newArray_TTrigEvent);
      instance.SetDelete(&delete_TTrigEvent);
      instance.SetDeleteArray(&deleteArray_TTrigEvent);
      instance.SetDestructor(&destruct_TTrigEvent);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TTrigEvent*)
   {
      return GenerateInitInstanceLocal(static_cast<::TTrigEvent*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TTrigEvent*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TBossFullEvent(void *p = nullptr);
   static void *newArray_TBossFullEvent(Long_t size, void *p);
   static void delete_TBossFullEvent(void *p);
   static void deleteArray_TBossFullEvent(void *p);
   static void destruct_TBossFullEvent(void *p);
   static void streamer_TBossFullEvent(TBuffer &buf, void *obj);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TBossFullEvent*)
   {
      ::TBossFullEvent *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TBossFullEvent >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TBossFullEvent", ::TBossFullEvent::Class_Version(), "RootEventData/TBossFullEvent.h", 14,
                  typeid(::TBossFullEvent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TBossFullEvent::Dictionary, isa_proxy, 17,
                  sizeof(::TBossFullEvent) );
      instance.SetNew(&new_TBossFullEvent);
      instance.SetNewArray(&newArray_TBossFullEvent);
      instance.SetDelete(&delete_TBossFullEvent);
      instance.SetDeleteArray(&deleteArray_TBossFullEvent);
      instance.SetDestructor(&destruct_TBossFullEvent);
      instance.SetStreamerFunc(&streamer_TBossFullEvent);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TBossFullEvent*)
   {
      return GenerateInitInstanceLocal(static_cast<::TBossFullEvent*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TBossFullEvent*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TDisTrack(void *p = nullptr);
   static void *newArray_TDisTrack(Long_t size, void *p);
   static void delete_TDisTrack(void *p);
   static void deleteArray_TDisTrack(void *p);
   static void destruct_TDisTrack(void *p);
   static void streamer_TDisTrack(TBuffer &buf, void *obj);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDisTrack*)
   {
      ::TDisTrack *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDisTrack >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TDisTrack", ::TDisTrack::Class_Version(), "RootEventData/TDisTrack.h", 12,
                  typeid(::TDisTrack), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TDisTrack::Dictionary, isa_proxy, 16,
                  sizeof(::TDisTrack) );
      instance.SetNew(&new_TDisTrack);
      instance.SetNewArray(&newArray_TDisTrack);
      instance.SetDelete(&delete_TDisTrack);
      instance.SetDeleteArray(&deleteArray_TDisTrack);
      instance.SetDestructor(&destruct_TDisTrack);
      instance.SetStreamerFunc(&streamer_TDisTrack);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TDisTrack*)
   {
      return GenerateInitInstanceLocal(static_cast<::TDisTrack*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TDisTrack*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TEvtNavigator(void *p = nullptr);
   static void *newArray_TEvtNavigator(Long_t size, void *p);
   static void delete_TEvtNavigator(void *p);
   static void deleteArray_TEvtNavigator(void *p);
   static void destruct_TEvtNavigator(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvtNavigator*)
   {
      ::TEvtNavigator *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtNavigator >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TEvtNavigator", ::TEvtNavigator::Class_Version(), "RootEventData/TEvtNavigator.h", 11,
                  typeid(::TEvtNavigator), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TEvtNavigator::Dictionary, isa_proxy, 4,
                  sizeof(::TEvtNavigator) );
      instance.SetNew(&new_TEvtNavigator);
      instance.SetNewArray(&newArray_TEvtNavigator);
      instance.SetDelete(&delete_TEvtNavigator);
      instance.SetDeleteArray(&deleteArray_TEvtNavigator);
      instance.SetDestructor(&destruct_TEvtNavigator);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEvtNavigator*)
   {
      return GenerateInitInstanceLocal(static_cast<::TEvtNavigator*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TEvtNavigator*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TJobInfo(void *p = nullptr);
   static void *newArray_TJobInfo(Long_t size, void *p);
   static void delete_TJobInfo(void *p);
   static void deleteArray_TJobInfo(void *p);
   static void destruct_TJobInfo(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TJobInfo*)
   {
      ::TJobInfo *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TJobInfo >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TJobInfo", ::TJobInfo::Class_Version(), "RootEventData/TJobInfo.h", 9,
                  typeid(::TJobInfo), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TJobInfo::Dictionary, isa_proxy, 4,
                  sizeof(::TJobInfo) );
      instance.SetNew(&new_TJobInfo);
      instance.SetNewArray(&newArray_TJobInfo);
      instance.SetDelete(&delete_TJobInfo);
      instance.SetDeleteArray(&deleteArray_TJobInfo);
      instance.SetDestructor(&destruct_TJobInfo);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TJobInfo*)
   {
      return GenerateInitInstanceLocal(static_cast<::TJobInfo*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TJobInfo*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TMcDigiEmc(void *p = nullptr);
   static void *newArray_TMcDigiEmc(Long_t size, void *p);
   static void delete_TMcDigiEmc(void *p);
   static void deleteArray_TMcDigiEmc(void *p);
   static void destruct_TMcDigiEmc(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMcDigiEmc*)
   {
      ::TMcDigiEmc *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcDigiEmc >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TMcDigiEmc", ::TMcDigiEmc::Class_Version(), "RootEventData/TMcDigiEmc.h", 8,
                  typeid(::TMcDigiEmc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TMcDigiEmc::Dictionary, isa_proxy, 4,
                  sizeof(::TMcDigiEmc) );
      instance.SetNew(&new_TMcDigiEmc);
      instance.SetNewArray(&newArray_TMcDigiEmc);
      instance.SetDelete(&delete_TMcDigiEmc);
      instance.SetDeleteArray(&deleteArray_TMcDigiEmc);
      instance.SetDestructor(&destruct_TMcDigiEmc);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMcDigiEmc*)
   {
      return GenerateInitInstanceLocal(static_cast<::TMcDigiEmc*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TMcDigiEmc*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TMcHitMdc(void *p = nullptr);
   static void *newArray_TMcHitMdc(Long_t size, void *p);
   static void delete_TMcHitMdc(void *p);
   static void deleteArray_TMcHitMdc(void *p);
   static void destruct_TMcHitMdc(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMcHitMdc*)
   {
      ::TMcHitMdc *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcHitMdc >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TMcHitMdc", ::TMcHitMdc::Class_Version(), "RootEventData/TMcHitMdc.h", 8,
                  typeid(::TMcHitMdc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TMcHitMdc::Dictionary, isa_proxy, 4,
                  sizeof(::TMcHitMdc) );
      instance.SetNew(&new_TMcHitMdc);
      instance.SetNewArray(&newArray_TMcHitMdc);
      instance.SetDelete(&delete_TMcHitMdc);
      instance.SetDeleteArray(&deleteArray_TMcHitMdc);
      instance.SetDestructor(&destruct_TMcHitMdc);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMcHitMdc*)
   {
      return GenerateInitInstanceLocal(static_cast<::TMcHitMdc*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TMcHitMdc*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TMcHitTof(void *p = nullptr);
   static void *newArray_TMcHitTof(Long_t size, void *p);
   static void delete_TMcHitTof(void *p);
   static void deleteArray_TMcHitTof(void *p);
   static void destruct_TMcHitTof(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMcHitTof*)
   {
      ::TMcHitTof *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcHitTof >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TMcHitTof", ::TMcHitTof::Class_Version(), "RootEventData/TMcHitTof.h", 8,
                  typeid(::TMcHitTof), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TMcHitTof::Dictionary, isa_proxy, 4,
                  sizeof(::TMcHitTof) );
      instance.SetNew(&new_TMcHitTof);
      instance.SetNewArray(&newArray_TMcHitTof);
      instance.SetDelete(&delete_TMcHitTof);
      instance.SetDeleteArray(&deleteArray_TMcHitTof);
      instance.SetDestructor(&destruct_TMcHitTof);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMcHitTof*)
   {
      return GenerateInitInstanceLocal(static_cast<::TMcHitTof*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TMcHitTof*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
namespace ROOT {
   static void *new_TMcHitEvent(void *p = nullptr);
   static void *newArray_TMcHitEvent(Long_t size, void *p);
   static void delete_TMcHitEvent(void *p);
   static void deleteArray_TMcHitEvent(void *p);
   static void destruct_TMcHitEvent(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMcHitEvent*)
   {
      ::TMcHitEvent *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcHitEvent >(nullptr);
      static ::ROOT::TGenericClassInfo 
         instance("TMcHitEvent", ::TMcHitEvent::Class_Version(), "RootEventData/TMcHitEvent.h", 12,
                  typeid(::TMcHitEvent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TMcHitEvent::Dictionary, isa_proxy, 4,
                  sizeof(::TMcHitEvent) );
      instance.SetNew(&new_TMcHitEvent);
      instance.SetNewArray(&newArray_TMcHitEvent);
      instance.SetDelete(&delete_TMcHitEvent);
      instance.SetDeleteArray(&deleteArray_TMcHitEvent);
      instance.SetDestructor(&destruct_TMcHitEvent);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMcHitEvent*)
   {
      return GenerateInitInstanceLocal(static_cast<::TMcHitEvent*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::TMcHitEvent*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT
 
//______________________________________________________________________________
atomic_TClass_ptr TRawData::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TRawData::Class_Name()
{
   return "TRawData";
}
 
//______________________________________________________________________________
const char *TRawData::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRawData*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TRawData::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRawData*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TRawData::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRawData*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TRawData::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRawData*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TEmcDigi::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TEmcDigi::Class_Name()
{
   return "TEmcDigi";
}
 
//______________________________________________________________________________
const char *TEmcDigi::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEmcDigi*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TEmcDigi::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEmcDigi*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TEmcDigi::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEmcDigi*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TEmcDigi::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEmcDigi*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TLumiDigi::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TLumiDigi::Class_Name()
{
   return "TLumiDigi";
}
 
//______________________________________________________________________________
const char *TLumiDigi::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TLumiDigi*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TLumiDigi::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TLumiDigi*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TLumiDigi::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TLumiDigi*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TLumiDigi::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TLumiDigi*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TMdcDigi::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TMdcDigi::Class_Name()
{
   return "TMdcDigi";
}
 
//______________________________________________________________________________
const char *TMdcDigi::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMdcDigi*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TMdcDigi::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMdcDigi*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TMdcDigi::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcDigi*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TMdcDigi::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcDigi*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TMucDigi::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TMucDigi::Class_Name()
{
   return "TMucDigi";
}
 
//______________________________________________________________________________
const char *TMucDigi::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMucDigi*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TMucDigi::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMucDigi*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TMucDigi::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMucDigi*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TMucDigi::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMucDigi*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TTofDigi::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TTofDigi::Class_Name()
{
   return "TTofDigi";
}
 
//______________________________________________________________________________
const char *TTofDigi::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TTofDigi*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TTofDigi::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TTofDigi*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TTofDigi::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTofDigi*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TTofDigi::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTofDigi*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TDigiEvent::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TDigiEvent::Class_Name()
{
   return "TDigiEvent";
}
 
//______________________________________________________________________________
const char *TDigiEvent::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TDigiEvent*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TDigiEvent::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TDigiEvent*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TDigiEvent::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDigiEvent*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TDigiEvent::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDigiEvent*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TEmcTrack::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TEmcTrack::Class_Name()
{
   return "TEmcTrack";
}
 
//______________________________________________________________________________
const char *TEmcTrack::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEmcTrack*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TEmcTrack::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEmcTrack*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TEmcTrack::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEmcTrack*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TEmcTrack::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEmcTrack*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TExtTrack::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TExtTrack::Class_Name()
{
   return "TExtTrack";
}
 
//______________________________________________________________________________
const char *TExtTrack::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TExtTrack*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TExtTrack::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TExtTrack*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TExtTrack::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TExtTrack*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TExtTrack::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TExtTrack*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TMdcDedx::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TMdcDedx::Class_Name()
{
   return "TMdcDedx";
}
 
//______________________________________________________________________________
const char *TMdcDedx::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMdcDedx*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TMdcDedx::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMdcDedx*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TMdcDedx::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcDedx*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TMdcDedx::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcDedx*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TMdcKalTrack::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TMdcKalTrack::Class_Name()
{
   return "TMdcKalTrack";
}
 
//______________________________________________________________________________
const char *TMdcKalTrack::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMdcKalTrack*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TMdcKalTrack::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMdcKalTrack*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TMdcKalTrack::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcKalTrack*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TMdcKalTrack::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcKalTrack*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TMdcTrack::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TMdcTrack::Class_Name()
{
   return "TMdcTrack";
}
 
//______________________________________________________________________________
const char *TMdcTrack::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMdcTrack*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TMdcTrack::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMdcTrack*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TMdcTrack::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcTrack*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TMdcTrack::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcTrack*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TMucTrack::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TMucTrack::Class_Name()
{
   return "TMucTrack";
}
 
//______________________________________________________________________________
const char *TMucTrack::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMucTrack*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TMucTrack::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMucTrack*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TMucTrack::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMucTrack*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TMucTrack::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMucTrack*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TTofTrack::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TTofTrack::Class_Name()
{
   return "TTofTrack";
}
 
//______________________________________________________________________________
const char *TTofTrack::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TTofTrack*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TTofTrack::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TTofTrack*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TTofTrack::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTofTrack*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TTofTrack::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTofTrack*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TDstEvent::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TDstEvent::Class_Name()
{
   return "TDstEvent";
}
 
//______________________________________________________________________________
const char *TDstEvent::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TDstEvent*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TDstEvent::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TDstEvent*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TDstEvent::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDstEvent*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TDstEvent::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDstEvent*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TEvtHeader::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TEvtHeader::Class_Name()
{
   return "TEvtHeader";
}
 
//______________________________________________________________________________
const char *TEvtHeader::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEvtHeader*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TEvtHeader::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEvtHeader*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TEvtHeader::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtHeader*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TEvtHeader::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtHeader*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TEvtRecDTag::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TEvtRecDTag::Class_Name()
{
   return "TEvtRecDTag";
}
 
//______________________________________________________________________________
const char *TEvtRecDTag::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecDTag*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TEvtRecDTag::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecDTag*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TEvtRecDTag::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecDTag*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TEvtRecDTag::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecDTag*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TEvtRecEtaToGG::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TEvtRecEtaToGG::Class_Name()
{
   return "TEvtRecEtaToGG";
}
 
//______________________________________________________________________________
const char *TEvtRecEtaToGG::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEtaToGG*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TEvtRecEtaToGG::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEtaToGG*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TEvtRecEtaToGG::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEtaToGG*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TEvtRecEtaToGG::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEtaToGG*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TEvtRecEvent::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TEvtRecEvent::Class_Name()
{
   return "TEvtRecEvent";
}
 
//______________________________________________________________________________
const char *TEvtRecEvent::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEvent*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TEvtRecEvent::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEvent*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TEvtRecEvent::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEvent*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TEvtRecEvent::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecEvent*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TEvtRecPi0::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TEvtRecPi0::Class_Name()
{
   return "TEvtRecPi0";
}
 
//______________________________________________________________________________
const char *TEvtRecPi0::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPi0*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TEvtRecPi0::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPi0*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TEvtRecPi0::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPi0*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TEvtRecPi0::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPi0*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TEvtRecPrimaryVertex::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TEvtRecPrimaryVertex::Class_Name()
{
   return "TEvtRecPrimaryVertex";
}
 
//______________________________________________________________________________
const char *TEvtRecPrimaryVertex::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPrimaryVertex*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TEvtRecPrimaryVertex::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPrimaryVertex*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TEvtRecPrimaryVertex::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPrimaryVertex*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TEvtRecPrimaryVertex::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecPrimaryVertex*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TEvtRecTrack::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TEvtRecTrack::Class_Name()
{
   return "TEvtRecTrack";
}
 
//______________________________________________________________________________
const char *TEvtRecTrack::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecTrack*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TEvtRecTrack::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecTrack*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TEvtRecTrack::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecTrack*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TEvtRecTrack::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecTrack*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TEvtRecVeeVertex::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TEvtRecVeeVertex::Class_Name()
{
   return "TEvtRecVeeVertex";
}
 
//______________________________________________________________________________
const char *TEvtRecVeeVertex::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecVeeVertex*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TEvtRecVeeVertex::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecVeeVertex*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TEvtRecVeeVertex::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecVeeVertex*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TEvtRecVeeVertex::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecVeeVertex*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TEvtRecObject::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TEvtRecObject::Class_Name()
{
   return "TEvtRecObject";
}
 
//______________________________________________________________________________
const char *TEvtRecObject::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecObject*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TEvtRecObject::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecObject*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TEvtRecObject::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecObject*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TEvtRecObject::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtRecObject*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TDstHltInf::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TDstHltInf::Class_Name()
{
   return "TDstHltInf";
}
 
//______________________________________________________________________________
const char *TDstHltInf::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TDstHltInf*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TDstHltInf::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TDstHltInf*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TDstHltInf::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDstHltInf*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TDstHltInf::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDstHltInf*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr THltInf::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *THltInf::Class_Name()
{
   return "THltInf";
}
 
//______________________________________________________________________________
const char *THltInf::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THltInf*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int THltInf::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THltInf*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *THltInf::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THltInf*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *THltInf::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THltInf*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr THltRaw::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *THltRaw::Class_Name()
{
   return "THltRaw";
}
 
//______________________________________________________________________________
const char *THltRaw::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THltRaw*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int THltRaw::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THltRaw*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *THltRaw::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THltRaw*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *THltRaw::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THltRaw*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr THltEvent::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *THltEvent::Class_Name()
{
   return "THltEvent";
}
 
//______________________________________________________________________________
const char *THltEvent::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THltEvent*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int THltEvent::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THltEvent*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *THltEvent::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THltEvent*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *THltEvent::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THltEvent*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TEmcMc::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TEmcMc::Class_Name()
{
   return "TEmcMc";
}
 
//______________________________________________________________________________
const char *TEmcMc::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEmcMc*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TEmcMc::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEmcMc*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TEmcMc::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEmcMc*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TEmcMc::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEmcMc*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TMcParticle::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TMcParticle::Class_Name()
{
   return "TMcParticle";
}
 
//______________________________________________________________________________
const char *TMcParticle::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMcParticle*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TMcParticle::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMcParticle*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TMcParticle::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcParticle*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TMcParticle::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcParticle*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TMdcMc::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TMdcMc::Class_Name()
{
   return "TMdcMc";
}
 
//______________________________________________________________________________
const char *TMdcMc::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMdcMc*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TMdcMc::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMdcMc*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TMdcMc::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcMc*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TMdcMc::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMdcMc*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TMucMc::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TMucMc::Class_Name()
{
   return "TMucMc";
}
 
//______________________________________________________________________________
const char *TMucMc::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMucMc*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TMucMc::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMucMc*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TMucMc::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMucMc*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TMucMc::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMucMc*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TTofMc::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TTofMc::Class_Name()
{
   return "TTofMc";
}
 
//______________________________________________________________________________
const char *TTofMc::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TTofMc*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TTofMc::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TTofMc*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TTofMc::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTofMc*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TTofMc::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTofMc*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TMcEvent::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TMcEvent::Class_Name()
{
   return "TMcEvent";
}
 
//______________________________________________________________________________
const char *TMcEvent::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMcEvent*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TMcEvent::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMcEvent*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TMcEvent::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcEvent*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TMcEvent::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcEvent*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TRecEmcCluster::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TRecEmcCluster::Class_Name()
{
   return "TRecEmcCluster";
}
 
//______________________________________________________________________________
const char *TRecEmcCluster::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcCluster*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TRecEmcCluster::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcCluster*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TRecEmcCluster::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcCluster*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TRecEmcCluster::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcCluster*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TRecEmcHit::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TRecEmcHit::Class_Name()
{
   return "TRecEmcHit";
}
 
//______________________________________________________________________________
const char *TRecEmcHit::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcHit*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TRecEmcHit::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcHit*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TRecEmcHit::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcHit*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TRecEmcHit::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcHit*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TRecEmcShower::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TRecEmcShower::Class_Name()
{
   return "TRecEmcShower";
}
 
//______________________________________________________________________________
const char *TRecEmcShower::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcShower*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TRecEmcShower::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcShower*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TRecEmcShower::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcShower*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TRecEmcShower::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEmcShower*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TRecEvTime::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TRecEvTime::Class_Name()
{
   return "TRecEvTime";
}
 
//______________________________________________________________________________
const char *TRecEvTime::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecEvTime*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TRecEvTime::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecEvTime*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TRecEvTime::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEvTime*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TRecEvTime::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecEvTime*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TRecExtTrack::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TRecExtTrack::Class_Name()
{
   return "TRecExtTrack";
}
 
//______________________________________________________________________________
const char *TRecExtTrack::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecExtTrack*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TRecExtTrack::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecExtTrack*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TRecExtTrack::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecExtTrack*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TRecExtTrack::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecExtTrack*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TRecMdcDedx::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TRecMdcDedx::Class_Name()
{
   return "TRecMdcDedx";
}
 
//______________________________________________________________________________
const char *TRecMdcDedx::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedx*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TRecMdcDedx::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedx*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TRecMdcDedx::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedx*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TRecMdcDedx::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedx*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TRecMdcDedxHit::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TRecMdcDedxHit::Class_Name()
{
   return "TRecMdcDedxHit";
}
 
//______________________________________________________________________________
const char *TRecMdcDedxHit::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedxHit*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TRecMdcDedxHit::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedxHit*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TRecMdcDedxHit::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedxHit*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TRecMdcDedxHit::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcDedxHit*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TRecMdcHit::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TRecMdcHit::Class_Name()
{
   return "TRecMdcHit";
}
 
//______________________________________________________________________________
const char *TRecMdcHit::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcHit*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TRecMdcHit::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcHit*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TRecMdcHit::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcHit*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TRecMdcHit::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcHit*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TRecMdcKalHelixSeg::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TRecMdcKalHelixSeg::Class_Name()
{
   return "TRecMdcKalHelixSeg";
}
 
//______________________________________________________________________________
const char *TRecMdcKalHelixSeg::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalHelixSeg*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TRecMdcKalHelixSeg::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalHelixSeg*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TRecMdcKalHelixSeg::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalHelixSeg*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TRecMdcKalHelixSeg::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalHelixSeg*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TRecMdcKalTrack::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TRecMdcKalTrack::Class_Name()
{
   return "TRecMdcKalTrack";
}
 
//______________________________________________________________________________
const char *TRecMdcKalTrack::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalTrack*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TRecMdcKalTrack::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalTrack*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TRecMdcKalTrack::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalTrack*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TRecMdcKalTrack::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcKalTrack*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TRecMdcTrack::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TRecMdcTrack::Class_Name()
{
   return "TRecMdcTrack";
}
 
//______________________________________________________________________________
const char *TRecMdcTrack::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcTrack*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TRecMdcTrack::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcTrack*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TRecMdcTrack::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcTrack*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TRecMdcTrack::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMdcTrack*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TRecMucTrack::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TRecMucTrack::Class_Name()
{
   return "TRecMucTrack";
}
 
//______________________________________________________________________________
const char *TRecMucTrack::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecMucTrack*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TRecMucTrack::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecMucTrack*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TRecMucTrack::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMucTrack*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TRecMucTrack::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecMucTrack*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TRecTofTrack::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TRecTofTrack::Class_Name()
{
   return "TRecTofTrack";
}
 
//______________________________________________________________________________
const char *TRecTofTrack::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecTofTrack*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TRecTofTrack::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecTofTrack*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TRecTofTrack::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecTofTrack*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TRecTofTrack::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecTofTrack*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TRecZddChannel::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TRecZddChannel::Class_Name()
{
   return "TRecZddChannel";
}
 
//______________________________________________________________________________
const char *TRecZddChannel::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecZddChannel*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TRecZddChannel::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecZddChannel*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TRecZddChannel::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecZddChannel*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TRecZddChannel::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecZddChannel*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TRecTrackEvent::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TRecTrackEvent::Class_Name()
{
   return "TRecTrackEvent";
}
 
//______________________________________________________________________________
const char *TRecTrackEvent::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecTrackEvent*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TRecTrackEvent::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TRecTrackEvent*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TRecTrackEvent::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecTrackEvent*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TRecTrackEvent::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TRecTrackEvent*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TTrigData::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TTrigData::Class_Name()
{
   return "TTrigData";
}
 
//______________________________________________________________________________
const char *TTrigData::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TTrigData*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TTrigData::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TTrigData*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TTrigData::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTrigData*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TTrigData::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTrigData*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TTrigEvent::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TTrigEvent::Class_Name()
{
   return "TTrigEvent";
}
 
//______________________________________________________________________________
const char *TTrigEvent::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TTrigEvent*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TTrigEvent::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TTrigEvent*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TTrigEvent::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTrigEvent*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TTrigEvent::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TTrigEvent*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TBossFullEvent::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TBossFullEvent::Class_Name()
{
   return "TBossFullEvent";
}
 
//______________________________________________________________________________
const char *TBossFullEvent::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TBossFullEvent*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TBossFullEvent::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TBossFullEvent*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TBossFullEvent::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TBossFullEvent*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TBossFullEvent::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TBossFullEvent*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TDisTrack::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TDisTrack::Class_Name()
{
   return "TDisTrack";
}
 
//______________________________________________________________________________
const char *TDisTrack::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TDisTrack*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TDisTrack::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TDisTrack*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TDisTrack::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDisTrack*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TDisTrack::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDisTrack*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TEvtNavigator::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TEvtNavigator::Class_Name()
{
   return "TEvtNavigator";
}
 
//______________________________________________________________________________
const char *TEvtNavigator::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEvtNavigator*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TEvtNavigator::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TEvtNavigator*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TEvtNavigator::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtNavigator*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TEvtNavigator::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEvtNavigator*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TJobInfo::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TJobInfo::Class_Name()
{
   return "TJobInfo";
}
 
//______________________________________________________________________________
const char *TJobInfo::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TJobInfo*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TJobInfo::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TJobInfo*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TJobInfo::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TJobInfo*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TJobInfo::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TJobInfo*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TMcDigiEmc::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TMcDigiEmc::Class_Name()
{
   return "TMcDigiEmc";
}
 
//______________________________________________________________________________
const char *TMcDigiEmc::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMcDigiEmc*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TMcDigiEmc::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMcDigiEmc*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TMcDigiEmc::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcDigiEmc*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TMcDigiEmc::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcDigiEmc*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TMcHitMdc::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TMcHitMdc::Class_Name()
{
   return "TMcHitMdc";
}
 
//______________________________________________________________________________
const char *TMcHitMdc::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMcHitMdc*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TMcHitMdc::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMcHitMdc*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TMcHitMdc::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcHitMdc*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TMcHitMdc::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcHitMdc*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TMcHitTof::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TMcHitTof::Class_Name()
{
   return "TMcHitTof";
}
 
//______________________________________________________________________________
const char *TMcHitTof::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMcHitTof*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TMcHitTof::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMcHitTof*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TMcHitTof::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcHitTof*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TMcHitTof::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcHitTof*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
atomic_TClass_ptr TMcHitEvent::fgIsA(nullptr);  // static to hold class pointer
 
//______________________________________________________________________________
const char *TMcHitEvent::Class_Name()
{
   return "TMcHitEvent";
}
 
//______________________________________________________________________________
const char *TMcHitEvent::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMcHitEvent*)nullptr)->GetImplFileName();
}
 
//______________________________________________________________________________
int TMcHitEvent::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMcHitEvent*)nullptr)->GetImplFileLine();
}
 
//______________________________________________________________________________
TClass *TMcHitEvent::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcHitEvent*)nullptr)->GetClass();
   return fgIsA;
}
 
//______________________________________________________________________________
TClass *TMcHitEvent::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMcHitEvent*)nullptr)->GetClass(); }
   return fgIsA;
}
 
//______________________________________________________________________________
void TRawData::Streamer(TBuffer &R__b)
{
   // Stream an object of class TRawData.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TRawData::Class(),this);
   } else {
      R__b.WriteClassBuffer(TRawData::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TRawData(void *p) {
      return  p ? new(p) ::TRawData : new ::TRawData;
   }
   static void *newArray_TRawData(Long_t nElements, void *p) {
      return p ? new(p) ::TRawData[nElements] : new ::TRawData[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRawData(void *p) {
      delete (static_cast<::TRawData*>(p));
   }
   static void deleteArray_TRawData(void *p) {
      delete [] (static_cast<::TRawData*>(p));
   }
   static void destruct_TRawData(void *p) {
      typedef ::TRawData current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TRawData
 
//______________________________________________________________________________
void TEmcDigi::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEmcDigi.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEmcDigi::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEmcDigi::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TEmcDigi(void *p) {
      return  p ? new(p) ::TEmcDigi : new ::TEmcDigi;
   }
   static void *newArray_TEmcDigi(Long_t nElements, void *p) {
      return p ? new(p) ::TEmcDigi[nElements] : new ::TEmcDigi[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEmcDigi(void *p) {
      delete (static_cast<::TEmcDigi*>(p));
   }
   static void deleteArray_TEmcDigi(void *p) {
      delete [] (static_cast<::TEmcDigi*>(p));
   }
   static void destruct_TEmcDigi(void *p) {
      typedef ::TEmcDigi current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TEmcDigi
 
//______________________________________________________________________________
void TLumiDigi::Streamer(TBuffer &R__b)
{
   // Stream an object of class TLumiDigi.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TLumiDigi::Class(),this);
   } else {
      R__b.WriteClassBuffer(TLumiDigi::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TLumiDigi(void *p) {
      return  p ? new(p) ::TLumiDigi : new ::TLumiDigi;
   }
   static void *newArray_TLumiDigi(Long_t nElements, void *p) {
      return p ? new(p) ::TLumiDigi[nElements] : new ::TLumiDigi[nElements];
   }
   // Wrapper around operator delete
   static void delete_TLumiDigi(void *p) {
      delete (static_cast<::TLumiDigi*>(p));
   }
   static void deleteArray_TLumiDigi(void *p) {
      delete [] (static_cast<::TLumiDigi*>(p));
   }
   static void destruct_TLumiDigi(void *p) {
      typedef ::TLumiDigi current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TLumiDigi
 
//______________________________________________________________________________
void TMdcDigi::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMdcDigi.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMdcDigi::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMdcDigi::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TMdcDigi(void *p) {
      return  p ? new(p) ::TMdcDigi : new ::TMdcDigi;
   }
   static void *newArray_TMdcDigi(Long_t nElements, void *p) {
      return p ? new(p) ::TMdcDigi[nElements] : new ::TMdcDigi[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMdcDigi(void *p) {
      delete (static_cast<::TMdcDigi*>(p));
   }
   static void deleteArray_TMdcDigi(void *p) {
      delete [] (static_cast<::TMdcDigi*>(p));
   }
   static void destruct_TMdcDigi(void *p) {
      typedef ::TMdcDigi current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TMdcDigi
 
//______________________________________________________________________________
void TMucDigi::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMucDigi.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMucDigi::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMucDigi::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TMucDigi(void *p) {
      return  p ? new(p) ::TMucDigi : new ::TMucDigi;
   }
   static void *newArray_TMucDigi(Long_t nElements, void *p) {
      return p ? new(p) ::TMucDigi[nElements] : new ::TMucDigi[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMucDigi(void *p) {
      delete (static_cast<::TMucDigi*>(p));
   }
   static void deleteArray_TMucDigi(void *p) {
      delete [] (static_cast<::TMucDigi*>(p));
   }
   static void destruct_TMucDigi(void *p) {
      typedef ::TMucDigi current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TMucDigi
 
//______________________________________________________________________________
void TTofDigi::Streamer(TBuffer &R__b)
{
   // Stream an object of class TTofDigi.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TTofDigi::Class(),this);
   } else {
      R__b.WriteClassBuffer(TTofDigi::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TTofDigi(void *p) {
      return  p ? new(p) ::TTofDigi : new ::TTofDigi;
   }
   static void *newArray_TTofDigi(Long_t nElements, void *p) {
      return p ? new(p) ::TTofDigi[nElements] : new ::TTofDigi[nElements];
   }
   // Wrapper around operator delete
   static void delete_TTofDigi(void *p) {
      delete (static_cast<::TTofDigi*>(p));
   }
   static void deleteArray_TTofDigi(void *p) {
      delete [] (static_cast<::TTofDigi*>(p));
   }
   static void destruct_TTofDigi(void *p) {
      typedef ::TTofDigi current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TTofDigi
 
//______________________________________________________________________________
void TDigiEvent::Streamer(TBuffer &R__b)
{
   // Stream an object of class TDigiEvent.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TDigiEvent::Class(),this);
   } else {
      R__b.WriteClassBuffer(TDigiEvent::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TDigiEvent(void *p) {
      return  p ? new(p) ::TDigiEvent : new ::TDigiEvent;
   }
   static void *newArray_TDigiEvent(Long_t nElements, void *p) {
      return p ? new(p) ::TDigiEvent[nElements] : new ::TDigiEvent[nElements];
   }
   // Wrapper around operator delete
   static void delete_TDigiEvent(void *p) {
      delete (static_cast<::TDigiEvent*>(p));
   }
   static void deleteArray_TDigiEvent(void *p) {
      delete [] (static_cast<::TDigiEvent*>(p));
   }
   static void destruct_TDigiEvent(void *p) {
      typedef ::TDigiEvent current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TDigiEvent
 
//______________________________________________________________________________
void TEmcTrack::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEmcTrack.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEmcTrack::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEmcTrack::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TEmcTrack(void *p) {
      return  p ? new(p) ::TEmcTrack : new ::TEmcTrack;
   }
   static void *newArray_TEmcTrack(Long_t nElements, void *p) {
      return p ? new(p) ::TEmcTrack[nElements] : new ::TEmcTrack[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEmcTrack(void *p) {
      delete (static_cast<::TEmcTrack*>(p));
   }
   static void deleteArray_TEmcTrack(void *p) {
      delete [] (static_cast<::TEmcTrack*>(p));
   }
   static void destruct_TEmcTrack(void *p) {
      typedef ::TEmcTrack current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TEmcTrack
 
//______________________________________________________________________________
void TExtTrack::Streamer(TBuffer &R__b)
{
   // Stream an object of class TExtTrack.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TExtTrack::Class(),this);
   } else {
      R__b.WriteClassBuffer(TExtTrack::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TExtTrack(void *p) {
      return  p ? new(p) ::TExtTrack : new ::TExtTrack;
   }
   static void *newArray_TExtTrack(Long_t nElements, void *p) {
      return p ? new(p) ::TExtTrack[nElements] : new ::TExtTrack[nElements];
   }
   // Wrapper around operator delete
   static void delete_TExtTrack(void *p) {
      delete (static_cast<::TExtTrack*>(p));
   }
   static void deleteArray_TExtTrack(void *p) {
      delete [] (static_cast<::TExtTrack*>(p));
   }
   static void destruct_TExtTrack(void *p) {
      typedef ::TExtTrack current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TExtTrack
 
//______________________________________________________________________________
void TMdcDedx::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMdcDedx.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMdcDedx::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMdcDedx::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TMdcDedx(void *p) {
      return  p ? new(p) ::TMdcDedx : new ::TMdcDedx;
   }
   static void *newArray_TMdcDedx(Long_t nElements, void *p) {
      return p ? new(p) ::TMdcDedx[nElements] : new ::TMdcDedx[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMdcDedx(void *p) {
      delete (static_cast<::TMdcDedx*>(p));
   }
   static void deleteArray_TMdcDedx(void *p) {
      delete [] (static_cast<::TMdcDedx*>(p));
   }
   static void destruct_TMdcDedx(void *p) {
      typedef ::TMdcDedx current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TMdcDedx
 
//______________________________________________________________________________
void TMdcKalTrack::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMdcKalTrack.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMdcKalTrack::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMdcKalTrack::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TMdcKalTrack(void *p) {
      return  p ? new(p) ::TMdcKalTrack : new ::TMdcKalTrack;
   }
   static void *newArray_TMdcKalTrack(Long_t nElements, void *p) {
      return p ? new(p) ::TMdcKalTrack[nElements] : new ::TMdcKalTrack[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMdcKalTrack(void *p) {
      delete (static_cast<::TMdcKalTrack*>(p));
   }
   static void deleteArray_TMdcKalTrack(void *p) {
      delete [] (static_cast<::TMdcKalTrack*>(p));
   }
   static void destruct_TMdcKalTrack(void *p) {
      typedef ::TMdcKalTrack current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TMdcKalTrack
 
//______________________________________________________________________________
void TMdcTrack::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMdcTrack.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMdcTrack::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMdcTrack::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TMdcTrack(void *p) {
      return  p ? new(p) ::TMdcTrack : new ::TMdcTrack;
   }
   static void *newArray_TMdcTrack(Long_t nElements, void *p) {
      return p ? new(p) ::TMdcTrack[nElements] : new ::TMdcTrack[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMdcTrack(void *p) {
      delete (static_cast<::TMdcTrack*>(p));
   }
   static void deleteArray_TMdcTrack(void *p) {
      delete [] (static_cast<::TMdcTrack*>(p));
   }
   static void destruct_TMdcTrack(void *p) {
      typedef ::TMdcTrack current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TMdcTrack
 
//______________________________________________________________________________
void TMucTrack::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMucTrack.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMucTrack::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMucTrack::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TMucTrack(void *p) {
      return  p ? new(p) ::TMucTrack : new ::TMucTrack;
   }
   static void *newArray_TMucTrack(Long_t nElements, void *p) {
      return p ? new(p) ::TMucTrack[nElements] : new ::TMucTrack[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMucTrack(void *p) {
      delete (static_cast<::TMucTrack*>(p));
   }
   static void deleteArray_TMucTrack(void *p) {
      delete [] (static_cast<::TMucTrack*>(p));
   }
   static void destruct_TMucTrack(void *p) {
      typedef ::TMucTrack current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TMucTrack
 
//______________________________________________________________________________
void TTofTrack::Streamer(TBuffer &R__b)
{
   // Stream an object of class TTofTrack.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TTofTrack::Class(),this);
   } else {
      R__b.WriteClassBuffer(TTofTrack::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TTofTrack(void *p) {
      return  p ? new(p) ::TTofTrack : new ::TTofTrack;
   }
   static void *newArray_TTofTrack(Long_t nElements, void *p) {
      return p ? new(p) ::TTofTrack[nElements] : new ::TTofTrack[nElements];
   }
   // Wrapper around operator delete
   static void delete_TTofTrack(void *p) {
      delete (static_cast<::TTofTrack*>(p));
   }
   static void deleteArray_TTofTrack(void *p) {
      delete [] (static_cast<::TTofTrack*>(p));
   }
   static void destruct_TTofTrack(void *p) {
      typedef ::TTofTrack current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TTofTrack
 
//______________________________________________________________________________
void TDstEvent::Streamer(TBuffer &R__b)
{
   // Stream an object of class TDstEvent.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TDstEvent::Class(),this);
   } else {
      R__b.WriteClassBuffer(TDstEvent::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TDstEvent(void *p) {
      return  p ? new(p) ::TDstEvent : new ::TDstEvent;
   }
   static void *newArray_TDstEvent(Long_t nElements, void *p) {
      return p ? new(p) ::TDstEvent[nElements] : new ::TDstEvent[nElements];
   }
   // Wrapper around operator delete
   static void delete_TDstEvent(void *p) {
      delete (static_cast<::TDstEvent*>(p));
   }
   static void deleteArray_TDstEvent(void *p) {
      delete [] (static_cast<::TDstEvent*>(p));
   }
   static void destruct_TDstEvent(void *p) {
      typedef ::TDstEvent current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TDstEvent
 
//______________________________________________________________________________
void TEvtHeader::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEvtHeader.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEvtHeader::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEvtHeader::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TEvtHeader(void *p) {
      return  p ? new(p) ::TEvtHeader : new ::TEvtHeader;
   }
   static void *newArray_TEvtHeader(Long_t nElements, void *p) {
      return p ? new(p) ::TEvtHeader[nElements] : new ::TEvtHeader[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEvtHeader(void *p) {
      delete (static_cast<::TEvtHeader*>(p));
   }
   static void deleteArray_TEvtHeader(void *p) {
      delete [] (static_cast<::TEvtHeader*>(p));
   }
   static void destruct_TEvtHeader(void *p) {
      typedef ::TEvtHeader current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TEvtHeader
 
//______________________________________________________________________________
void TEvtRecDTag::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEvtRecDTag.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEvtRecDTag::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEvtRecDTag::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TEvtRecDTag(void *p) {
      return  p ? new(p) ::TEvtRecDTag : new ::TEvtRecDTag;
   }
   static void *newArray_TEvtRecDTag(Long_t nElements, void *p) {
      return p ? new(p) ::TEvtRecDTag[nElements] : new ::TEvtRecDTag[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEvtRecDTag(void *p) {
      delete (static_cast<::TEvtRecDTag*>(p));
   }
   static void deleteArray_TEvtRecDTag(void *p) {
      delete [] (static_cast<::TEvtRecDTag*>(p));
   }
   static void destruct_TEvtRecDTag(void *p) {
      typedef ::TEvtRecDTag current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TEvtRecDTag
 
//______________________________________________________________________________
void TEvtRecEtaToGG::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEvtRecEtaToGG.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEvtRecEtaToGG::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEvtRecEtaToGG::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TEvtRecEtaToGG(void *p) {
      return  p ? new(p) ::TEvtRecEtaToGG : new ::TEvtRecEtaToGG;
   }
   static void *newArray_TEvtRecEtaToGG(Long_t nElements, void *p) {
      return p ? new(p) ::TEvtRecEtaToGG[nElements] : new ::TEvtRecEtaToGG[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEvtRecEtaToGG(void *p) {
      delete (static_cast<::TEvtRecEtaToGG*>(p));
   }
   static void deleteArray_TEvtRecEtaToGG(void *p) {
      delete [] (static_cast<::TEvtRecEtaToGG*>(p));
   }
   static void destruct_TEvtRecEtaToGG(void *p) {
      typedef ::TEvtRecEtaToGG current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TEvtRecEtaToGG
 
//______________________________________________________________________________
void TEvtRecEvent::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEvtRecEvent.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEvtRecEvent::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEvtRecEvent::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TEvtRecEvent(void *p) {
      return  p ? new(p) ::TEvtRecEvent : new ::TEvtRecEvent;
   }
   static void *newArray_TEvtRecEvent(Long_t nElements, void *p) {
      return p ? new(p) ::TEvtRecEvent[nElements] : new ::TEvtRecEvent[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEvtRecEvent(void *p) {
      delete (static_cast<::TEvtRecEvent*>(p));
   }
   static void deleteArray_TEvtRecEvent(void *p) {
      delete [] (static_cast<::TEvtRecEvent*>(p));
   }
   static void destruct_TEvtRecEvent(void *p) {
      typedef ::TEvtRecEvent current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TEvtRecEvent
 
//______________________________________________________________________________
void TEvtRecPi0::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEvtRecPi0.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEvtRecPi0::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEvtRecPi0::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TEvtRecPi0(void *p) {
      return  p ? new(p) ::TEvtRecPi0 : new ::TEvtRecPi0;
   }
   static void *newArray_TEvtRecPi0(Long_t nElements, void *p) {
      return p ? new(p) ::TEvtRecPi0[nElements] : new ::TEvtRecPi0[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEvtRecPi0(void *p) {
      delete (static_cast<::TEvtRecPi0*>(p));
   }
   static void deleteArray_TEvtRecPi0(void *p) {
      delete [] (static_cast<::TEvtRecPi0*>(p));
   }
   static void destruct_TEvtRecPi0(void *p) {
      typedef ::TEvtRecPi0 current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TEvtRecPi0
 
//______________________________________________________________________________
void TEvtRecPrimaryVertex::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEvtRecPrimaryVertex.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEvtRecPrimaryVertex::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEvtRecPrimaryVertex::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TEvtRecPrimaryVertex(void *p) {
      return  p ? new(p) ::TEvtRecPrimaryVertex : new ::TEvtRecPrimaryVertex;
   }
   static void *newArray_TEvtRecPrimaryVertex(Long_t nElements, void *p) {
      return p ? new(p) ::TEvtRecPrimaryVertex[nElements] : new ::TEvtRecPrimaryVertex[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEvtRecPrimaryVertex(void *p) {
      delete (static_cast<::TEvtRecPrimaryVertex*>(p));
   }
   static void deleteArray_TEvtRecPrimaryVertex(void *p) {
      delete [] (static_cast<::TEvtRecPrimaryVertex*>(p));
   }
   static void destruct_TEvtRecPrimaryVertex(void *p) {
      typedef ::TEvtRecPrimaryVertex current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TEvtRecPrimaryVertex
 
//______________________________________________________________________________
void TEvtRecTrack::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEvtRecTrack.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEvtRecTrack::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEvtRecTrack::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TEvtRecTrack(void *p) {
      return  p ? new(p) ::TEvtRecTrack : new ::TEvtRecTrack;
   }
   static void *newArray_TEvtRecTrack(Long_t nElements, void *p) {
      return p ? new(p) ::TEvtRecTrack[nElements] : new ::TEvtRecTrack[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEvtRecTrack(void *p) {
      delete (static_cast<::TEvtRecTrack*>(p));
   }
   static void deleteArray_TEvtRecTrack(void *p) {
      delete [] (static_cast<::TEvtRecTrack*>(p));
   }
   static void destruct_TEvtRecTrack(void *p) {
      typedef ::TEvtRecTrack current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TEvtRecTrack
 
//______________________________________________________________________________
void TEvtRecVeeVertex::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEvtRecVeeVertex.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEvtRecVeeVertex::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEvtRecVeeVertex::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TEvtRecVeeVertex(void *p) {
      return  p ? new(p) ::TEvtRecVeeVertex : new ::TEvtRecVeeVertex;
   }
   static void *newArray_TEvtRecVeeVertex(Long_t nElements, void *p) {
      return p ? new(p) ::TEvtRecVeeVertex[nElements] : new ::TEvtRecVeeVertex[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEvtRecVeeVertex(void *p) {
      delete (static_cast<::TEvtRecVeeVertex*>(p));
   }
   static void deleteArray_TEvtRecVeeVertex(void *p) {
      delete [] (static_cast<::TEvtRecVeeVertex*>(p));
   }
   static void destruct_TEvtRecVeeVertex(void *p) {
      typedef ::TEvtRecVeeVertex current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TEvtRecVeeVertex
 
//______________________________________________________________________________
void TEvtRecObject::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEvtRecObject.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEvtRecObject::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEvtRecObject::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TEvtRecObject(void *p) {
      return  p ? new(p) ::TEvtRecObject : new ::TEvtRecObject;
   }
   static void *newArray_TEvtRecObject(Long_t nElements, void *p) {
      return p ? new(p) ::TEvtRecObject[nElements] : new ::TEvtRecObject[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEvtRecObject(void *p) {
      delete (static_cast<::TEvtRecObject*>(p));
   }
   static void deleteArray_TEvtRecObject(void *p) {
      delete [] (static_cast<::TEvtRecObject*>(p));
   }
   static void destruct_TEvtRecObject(void *p) {
      typedef ::TEvtRecObject current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TEvtRecObject
 
//______________________________________________________________________________
void TDstHltInf::Streamer(TBuffer &R__b)
{
   // Stream an object of class TDstHltInf.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TDstHltInf::Class(),this);
   } else {
      R__b.WriteClassBuffer(TDstHltInf::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TDstHltInf(void *p) {
      return  p ? new(p) ::TDstHltInf : new ::TDstHltInf;
   }
   static void *newArray_TDstHltInf(Long_t nElements, void *p) {
      return p ? new(p) ::TDstHltInf[nElements] : new ::TDstHltInf[nElements];
   }
   // Wrapper around operator delete
   static void delete_TDstHltInf(void *p) {
      delete (static_cast<::TDstHltInf*>(p));
   }
   static void deleteArray_TDstHltInf(void *p) {
      delete [] (static_cast<::TDstHltInf*>(p));
   }
   static void destruct_TDstHltInf(void *p) {
      typedef ::TDstHltInf current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TDstHltInf
 
//______________________________________________________________________________
void THltInf::Streamer(TBuffer &R__b)
{
   // Stream an object of class THltInf.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(THltInf::Class(),this);
   } else {
      R__b.WriteClassBuffer(THltInf::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_THltInf(void *p) {
      return  p ? new(p) ::THltInf : new ::THltInf;
   }
   static void *newArray_THltInf(Long_t nElements, void *p) {
      return p ? new(p) ::THltInf[nElements] : new ::THltInf[nElements];
   }
   // Wrapper around operator delete
   static void delete_THltInf(void *p) {
      delete (static_cast<::THltInf*>(p));
   }
   static void deleteArray_THltInf(void *p) {
      delete [] (static_cast<::THltInf*>(p));
   }
   static void destruct_THltInf(void *p) {
      typedef ::THltInf current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::THltInf
 
//______________________________________________________________________________
void THltRaw::Streamer(TBuffer &R__b)
{
   // Stream an object of class THltRaw.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(THltRaw::Class(),this);
   } else {
      R__b.WriteClassBuffer(THltRaw::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_THltRaw(void *p) {
      return  p ? new(p) ::THltRaw : new ::THltRaw;
   }
   static void *newArray_THltRaw(Long_t nElements, void *p) {
      return p ? new(p) ::THltRaw[nElements] : new ::THltRaw[nElements];
   }
   // Wrapper around operator delete
   static void delete_THltRaw(void *p) {
      delete (static_cast<::THltRaw*>(p));
   }
   static void deleteArray_THltRaw(void *p) {
      delete [] (static_cast<::THltRaw*>(p));
   }
   static void destruct_THltRaw(void *p) {
      typedef ::THltRaw current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::THltRaw
 
//______________________________________________________________________________
void THltEvent::Streamer(TBuffer &R__b)
{
   // Stream an object of class THltEvent.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(THltEvent::Class(),this);
   } else {
      R__b.WriteClassBuffer(THltEvent::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_THltEvent(void *p) {
      return  p ? new(p) ::THltEvent : new ::THltEvent;
   }
   static void *newArray_THltEvent(Long_t nElements, void *p) {
      return p ? new(p) ::THltEvent[nElements] : new ::THltEvent[nElements];
   }
   // Wrapper around operator delete
   static void delete_THltEvent(void *p) {
      delete (static_cast<::THltEvent*>(p));
   }
   static void deleteArray_THltEvent(void *p) {
      delete [] (static_cast<::THltEvent*>(p));
   }
   static void destruct_THltEvent(void *p) {
      typedef ::THltEvent current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::THltEvent
 
//______________________________________________________________________________
void TEmcMc::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEmcMc.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEmcMc::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEmcMc::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TEmcMc(void *p) {
      return  p ? new(p) ::TEmcMc : new ::TEmcMc;
   }
   static void *newArray_TEmcMc(Long_t nElements, void *p) {
      return p ? new(p) ::TEmcMc[nElements] : new ::TEmcMc[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEmcMc(void *p) {
      delete (static_cast<::TEmcMc*>(p));
   }
   static void deleteArray_TEmcMc(void *p) {
      delete [] (static_cast<::TEmcMc*>(p));
   }
   static void destruct_TEmcMc(void *p) {
      typedef ::TEmcMc current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TEmcMc
 
//______________________________________________________________________________
void TMcParticle::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMcParticle.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMcParticle::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMcParticle::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TMcParticle(void *p) {
      return  p ? new(p) ::TMcParticle : new ::TMcParticle;
   }
   static void *newArray_TMcParticle(Long_t nElements, void *p) {
      return p ? new(p) ::TMcParticle[nElements] : new ::TMcParticle[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMcParticle(void *p) {
      delete (static_cast<::TMcParticle*>(p));
   }
   static void deleteArray_TMcParticle(void *p) {
      delete [] (static_cast<::TMcParticle*>(p));
   }
   static void destruct_TMcParticle(void *p) {
      typedef ::TMcParticle current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TMcParticle
 
//______________________________________________________________________________
void TMdcMc::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMdcMc.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMdcMc::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMdcMc::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TMdcMc(void *p) {
      return  p ? new(p) ::TMdcMc : new ::TMdcMc;
   }
   static void *newArray_TMdcMc(Long_t nElements, void *p) {
      return p ? new(p) ::TMdcMc[nElements] : new ::TMdcMc[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMdcMc(void *p) {
      delete (static_cast<::TMdcMc*>(p));
   }
   static void deleteArray_TMdcMc(void *p) {
      delete [] (static_cast<::TMdcMc*>(p));
   }
   static void destruct_TMdcMc(void *p) {
      typedef ::TMdcMc current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TMdcMc
 
//______________________________________________________________________________
void TMucMc::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMucMc.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMucMc::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMucMc::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TMucMc(void *p) {
      return  p ? new(p) ::TMucMc : new ::TMucMc;
   }
   static void *newArray_TMucMc(Long_t nElements, void *p) {
      return p ? new(p) ::TMucMc[nElements] : new ::TMucMc[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMucMc(void *p) {
      delete (static_cast<::TMucMc*>(p));
   }
   static void deleteArray_TMucMc(void *p) {
      delete [] (static_cast<::TMucMc*>(p));
   }
   static void destruct_TMucMc(void *p) {
      typedef ::TMucMc current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TMucMc
 
//______________________________________________________________________________
void TTofMc::Streamer(TBuffer &R__b)
{
   // Stream an object of class TTofMc.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TTofMc::Class(),this);
   } else {
      R__b.WriteClassBuffer(TTofMc::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TTofMc(void *p) {
      return  p ? new(p) ::TTofMc : new ::TTofMc;
   }
   static void *newArray_TTofMc(Long_t nElements, void *p) {
      return p ? new(p) ::TTofMc[nElements] : new ::TTofMc[nElements];
   }
   // Wrapper around operator delete
   static void delete_TTofMc(void *p) {
      delete (static_cast<::TTofMc*>(p));
   }
   static void deleteArray_TTofMc(void *p) {
      delete [] (static_cast<::TTofMc*>(p));
   }
   static void destruct_TTofMc(void *p) {
      typedef ::TTofMc current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TTofMc
 
//______________________________________________________________________________
void TMcEvent::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMcEvent.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMcEvent::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMcEvent::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TMcEvent(void *p) {
      return  p ? new(p) ::TMcEvent : new ::TMcEvent;
   }
   static void *newArray_TMcEvent(Long_t nElements, void *p) {
      return p ? new(p) ::TMcEvent[nElements] : new ::TMcEvent[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMcEvent(void *p) {
      delete (static_cast<::TMcEvent*>(p));
   }
   static void deleteArray_TMcEvent(void *p) {
      delete [] (static_cast<::TMcEvent*>(p));
   }
   static void destruct_TMcEvent(void *p) {
      typedef ::TMcEvent current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TMcEvent
 
//______________________________________________________________________________
void TRecEmcCluster::Streamer(TBuffer &R__b)
{
   // Stream an object of class TRecEmcCluster.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TRecEmcCluster::Class(),this);
   } else {
      R__b.WriteClassBuffer(TRecEmcCluster::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TRecEmcCluster(void *p) {
      return  p ? new(p) ::TRecEmcCluster : new ::TRecEmcCluster;
   }
   static void *newArray_TRecEmcCluster(Long_t nElements, void *p) {
      return p ? new(p) ::TRecEmcCluster[nElements] : new ::TRecEmcCluster[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRecEmcCluster(void *p) {
      delete (static_cast<::TRecEmcCluster*>(p));
   }
   static void deleteArray_TRecEmcCluster(void *p) {
      delete [] (static_cast<::TRecEmcCluster*>(p));
   }
   static void destruct_TRecEmcCluster(void *p) {
      typedef ::TRecEmcCluster current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TRecEmcCluster
 
//______________________________________________________________________________
void TRecEmcHit::Streamer(TBuffer &R__b)
{
   // Stream an object of class TRecEmcHit.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TRecEmcHit::Class(),this);
   } else {
      R__b.WriteClassBuffer(TRecEmcHit::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TRecEmcHit(void *p) {
      return  p ? new(p) ::TRecEmcHit : new ::TRecEmcHit;
   }
   static void *newArray_TRecEmcHit(Long_t nElements, void *p) {
      return p ? new(p) ::TRecEmcHit[nElements] : new ::TRecEmcHit[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRecEmcHit(void *p) {
      delete (static_cast<::TRecEmcHit*>(p));
   }
   static void deleteArray_TRecEmcHit(void *p) {
      delete [] (static_cast<::TRecEmcHit*>(p));
   }
   static void destruct_TRecEmcHit(void *p) {
      typedef ::TRecEmcHit current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TRecEmcHit
 
//______________________________________________________________________________
void TRecEmcShower::Streamer(TBuffer &R__b)
{
   // Stream an object of class TRecEmcShower.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TRecEmcShower::Class(),this);
   } else {
      R__b.WriteClassBuffer(TRecEmcShower::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TRecEmcShower(void *p) {
      return  p ? new(p) ::TRecEmcShower : new ::TRecEmcShower;
   }
   static void *newArray_TRecEmcShower(Long_t nElements, void *p) {
      return p ? new(p) ::TRecEmcShower[nElements] : new ::TRecEmcShower[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRecEmcShower(void *p) {
      delete (static_cast<::TRecEmcShower*>(p));
   }
   static void deleteArray_TRecEmcShower(void *p) {
      delete [] (static_cast<::TRecEmcShower*>(p));
   }
   static void destruct_TRecEmcShower(void *p) {
      typedef ::TRecEmcShower current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TRecEmcShower
 
//______________________________________________________________________________
void TRecEvTime::Streamer(TBuffer &R__b)
{
   // Stream an object of class TRecEvTime.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TRecEvTime::Class(),this);
   } else {
      R__b.WriteClassBuffer(TRecEvTime::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TRecEvTime(void *p) {
      return  p ? new(p) ::TRecEvTime : new ::TRecEvTime;
   }
   static void *newArray_TRecEvTime(Long_t nElements, void *p) {
      return p ? new(p) ::TRecEvTime[nElements] : new ::TRecEvTime[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRecEvTime(void *p) {
      delete (static_cast<::TRecEvTime*>(p));
   }
   static void deleteArray_TRecEvTime(void *p) {
      delete [] (static_cast<::TRecEvTime*>(p));
   }
   static void destruct_TRecEvTime(void *p) {
      typedef ::TRecEvTime current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TRecEvTime
 
//______________________________________________________________________________
void TRecExtTrack::Streamer(TBuffer &R__b)
{
   // Stream an object of class TRecExtTrack.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TRecExtTrack::Class(),this);
   } else {
      R__b.WriteClassBuffer(TRecExtTrack::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TRecExtTrack(void *p) {
      return  p ? new(p) ::TRecExtTrack : new ::TRecExtTrack;
   }
   static void *newArray_TRecExtTrack(Long_t nElements, void *p) {
      return p ? new(p) ::TRecExtTrack[nElements] : new ::TRecExtTrack[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRecExtTrack(void *p) {
      delete (static_cast<::TRecExtTrack*>(p));
   }
   static void deleteArray_TRecExtTrack(void *p) {
      delete [] (static_cast<::TRecExtTrack*>(p));
   }
   static void destruct_TRecExtTrack(void *p) {
      typedef ::TRecExtTrack current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TRecExtTrack
 
//______________________________________________________________________________
void TRecMdcDedx::Streamer(TBuffer &R__b)
{
   // Stream an object of class TRecMdcDedx.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TRecMdcDedx::Class(),this);
   } else {
      R__b.WriteClassBuffer(TRecMdcDedx::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TRecMdcDedx(void *p) {
      return  p ? new(p) ::TRecMdcDedx : new ::TRecMdcDedx;
   }
   static void *newArray_TRecMdcDedx(Long_t nElements, void *p) {
      return p ? new(p) ::TRecMdcDedx[nElements] : new ::TRecMdcDedx[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRecMdcDedx(void *p) {
      delete (static_cast<::TRecMdcDedx*>(p));
   }
   static void deleteArray_TRecMdcDedx(void *p) {
      delete [] (static_cast<::TRecMdcDedx*>(p));
   }
   static void destruct_TRecMdcDedx(void *p) {
      typedef ::TRecMdcDedx current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TRecMdcDedx
 
//______________________________________________________________________________
void TRecMdcDedxHit::Streamer(TBuffer &R__b)
{
   // Stream an object of class TRecMdcDedxHit.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TRecMdcDedxHit::Class(),this);
   } else {
      R__b.WriteClassBuffer(TRecMdcDedxHit::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TRecMdcDedxHit(void *p) {
      return  p ? new(p) ::TRecMdcDedxHit : new ::TRecMdcDedxHit;
   }
   static void *newArray_TRecMdcDedxHit(Long_t nElements, void *p) {
      return p ? new(p) ::TRecMdcDedxHit[nElements] : new ::TRecMdcDedxHit[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRecMdcDedxHit(void *p) {
      delete (static_cast<::TRecMdcDedxHit*>(p));
   }
   static void deleteArray_TRecMdcDedxHit(void *p) {
      delete [] (static_cast<::TRecMdcDedxHit*>(p));
   }
   static void destruct_TRecMdcDedxHit(void *p) {
      typedef ::TRecMdcDedxHit current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TRecMdcDedxHit
 
//______________________________________________________________________________
void TRecMdcHit::Streamer(TBuffer &R__b)
{
   // Stream an object of class TRecMdcHit.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TRecMdcHit::Class(),this);
   } else {
      R__b.WriteClassBuffer(TRecMdcHit::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TRecMdcHit(void *p) {
      return  p ? new(p) ::TRecMdcHit : new ::TRecMdcHit;
   }
   static void *newArray_TRecMdcHit(Long_t nElements, void *p) {
      return p ? new(p) ::TRecMdcHit[nElements] : new ::TRecMdcHit[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRecMdcHit(void *p) {
      delete (static_cast<::TRecMdcHit*>(p));
   }
   static void deleteArray_TRecMdcHit(void *p) {
      delete [] (static_cast<::TRecMdcHit*>(p));
   }
   static void destruct_TRecMdcHit(void *p) {
      typedef ::TRecMdcHit current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TRecMdcHit
 
//______________________________________________________________________________
void TRecMdcKalHelixSeg::Streamer(TBuffer &R__b)
{
   // Stream an object of class TRecMdcKalHelixSeg.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TRecMdcKalHelixSeg::Class(),this);
   } else {
      R__b.WriteClassBuffer(TRecMdcKalHelixSeg::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TRecMdcKalHelixSeg(void *p) {
      return  p ? new(p) ::TRecMdcKalHelixSeg : new ::TRecMdcKalHelixSeg;
   }
   static void *newArray_TRecMdcKalHelixSeg(Long_t nElements, void *p) {
      return p ? new(p) ::TRecMdcKalHelixSeg[nElements] : new ::TRecMdcKalHelixSeg[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRecMdcKalHelixSeg(void *p) {
      delete (static_cast<::TRecMdcKalHelixSeg*>(p));
   }
   static void deleteArray_TRecMdcKalHelixSeg(void *p) {
      delete [] (static_cast<::TRecMdcKalHelixSeg*>(p));
   }
   static void destruct_TRecMdcKalHelixSeg(void *p) {
      typedef ::TRecMdcKalHelixSeg current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TRecMdcKalHelixSeg
 
//______________________________________________________________________________
void TRecMdcKalTrack::Streamer(TBuffer &R__b)
{
   // Stream an object of class TRecMdcKalTrack.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TRecMdcKalTrack::Class(),this);
   } else {
      R__b.WriteClassBuffer(TRecMdcKalTrack::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TRecMdcKalTrack(void *p) {
      return  p ? new(p) ::TRecMdcKalTrack : new ::TRecMdcKalTrack;
   }
   static void *newArray_TRecMdcKalTrack(Long_t nElements, void *p) {
      return p ? new(p) ::TRecMdcKalTrack[nElements] : new ::TRecMdcKalTrack[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRecMdcKalTrack(void *p) {
      delete (static_cast<::TRecMdcKalTrack*>(p));
   }
   static void deleteArray_TRecMdcKalTrack(void *p) {
      delete [] (static_cast<::TRecMdcKalTrack*>(p));
   }
   static void destruct_TRecMdcKalTrack(void *p) {
      typedef ::TRecMdcKalTrack current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TRecMdcKalTrack
 
//______________________________________________________________________________
void TRecMdcTrack::Streamer(TBuffer &R__b)
{
   // Stream an object of class TRecMdcTrack.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TRecMdcTrack::Class(),this);
   } else {
      R__b.WriteClassBuffer(TRecMdcTrack::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TRecMdcTrack(void *p) {
      return  p ? new(p) ::TRecMdcTrack : new ::TRecMdcTrack;
   }
   static void *newArray_TRecMdcTrack(Long_t nElements, void *p) {
      return p ? new(p) ::TRecMdcTrack[nElements] : new ::TRecMdcTrack[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRecMdcTrack(void *p) {
      delete (static_cast<::TRecMdcTrack*>(p));
   }
   static void deleteArray_TRecMdcTrack(void *p) {
      delete [] (static_cast<::TRecMdcTrack*>(p));
   }
   static void destruct_TRecMdcTrack(void *p) {
      typedef ::TRecMdcTrack current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TRecMdcTrack
 
//______________________________________________________________________________
void TRecMucTrack::Streamer(TBuffer &R__b)
{
   // Stream an object of class TRecMucTrack.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TRecMucTrack::Class(),this);
   } else {
      R__b.WriteClassBuffer(TRecMucTrack::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TRecMucTrack(void *p) {
      return  p ? new(p) ::TRecMucTrack : new ::TRecMucTrack;
   }
   static void *newArray_TRecMucTrack(Long_t nElements, void *p) {
      return p ? new(p) ::TRecMucTrack[nElements] : new ::TRecMucTrack[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRecMucTrack(void *p) {
      delete (static_cast<::TRecMucTrack*>(p));
   }
   static void deleteArray_TRecMucTrack(void *p) {
      delete [] (static_cast<::TRecMucTrack*>(p));
   }
   static void destruct_TRecMucTrack(void *p) {
      typedef ::TRecMucTrack current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TRecMucTrack
 
//______________________________________________________________________________
void TRecTofTrack::Streamer(TBuffer &R__b)
{
   // Stream an object of class TRecTofTrack.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TRecTofTrack::Class(),this);
   } else {
      R__b.WriteClassBuffer(TRecTofTrack::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TRecTofTrack(void *p) {
      return  p ? new(p) ::TRecTofTrack : new ::TRecTofTrack;
   }
   static void *newArray_TRecTofTrack(Long_t nElements, void *p) {
      return p ? new(p) ::TRecTofTrack[nElements] : new ::TRecTofTrack[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRecTofTrack(void *p) {
      delete (static_cast<::TRecTofTrack*>(p));
   }
   static void deleteArray_TRecTofTrack(void *p) {
      delete [] (static_cast<::TRecTofTrack*>(p));
   }
   static void destruct_TRecTofTrack(void *p) {
      typedef ::TRecTofTrack current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TRecTofTrack
 
//______________________________________________________________________________
void TRecZddChannel::Streamer(TBuffer &R__b)
{
   // Stream an object of class TRecZddChannel.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TRecZddChannel::Class(),this);
   } else {
      R__b.WriteClassBuffer(TRecZddChannel::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TRecZddChannel(void *p) {
      return  p ? new(p) ::TRecZddChannel : new ::TRecZddChannel;
   }
   static void *newArray_TRecZddChannel(Long_t nElements, void *p) {
      return p ? new(p) ::TRecZddChannel[nElements] : new ::TRecZddChannel[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRecZddChannel(void *p) {
      delete (static_cast<::TRecZddChannel*>(p));
   }
   static void deleteArray_TRecZddChannel(void *p) {
      delete [] (static_cast<::TRecZddChannel*>(p));
   }
   static void destruct_TRecZddChannel(void *p) {
      typedef ::TRecZddChannel current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TRecZddChannel
 
//______________________________________________________________________________
void TRecTrackEvent::Streamer(TBuffer &R__b)
{
   // Stream an object of class TRecTrackEvent.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TRecTrackEvent::Class(),this);
   } else {
      R__b.WriteClassBuffer(TRecTrackEvent::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TRecTrackEvent(void *p) {
      return  p ? new(p) ::TRecTrackEvent : new ::TRecTrackEvent;
   }
   static void *newArray_TRecTrackEvent(Long_t nElements, void *p) {
      return p ? new(p) ::TRecTrackEvent[nElements] : new ::TRecTrackEvent[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRecTrackEvent(void *p) {
      delete (static_cast<::TRecTrackEvent*>(p));
   }
   static void deleteArray_TRecTrackEvent(void *p) {
      delete [] (static_cast<::TRecTrackEvent*>(p));
   }
   static void destruct_TRecTrackEvent(void *p) {
      typedef ::TRecTrackEvent current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TRecTrackEvent
 
//______________________________________________________________________________
void TTrigData::Streamer(TBuffer &R__b)
{
   // Stream an object of class TTrigData.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TTrigData::Class(),this);
   } else {
      R__b.WriteClassBuffer(TTrigData::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TTrigData(void *p) {
      return  p ? new(p) ::TTrigData : new ::TTrigData;
   }
   static void *newArray_TTrigData(Long_t nElements, void *p) {
      return p ? new(p) ::TTrigData[nElements] : new ::TTrigData[nElements];
   }
   // Wrapper around operator delete
   static void delete_TTrigData(void *p) {
      delete (static_cast<::TTrigData*>(p));
   }
   static void deleteArray_TTrigData(void *p) {
      delete [] (static_cast<::TTrigData*>(p));
   }
   static void destruct_TTrigData(void *p) {
      typedef ::TTrigData current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TTrigData
 
//______________________________________________________________________________
void TTrigEvent::Streamer(TBuffer &R__b)
{
   // Stream an object of class TTrigEvent.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TTrigEvent::Class(),this);
   } else {
      R__b.WriteClassBuffer(TTrigEvent::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TTrigEvent(void *p) {
      return  p ? new(p) ::TTrigEvent : new ::TTrigEvent;
   }
   static void *newArray_TTrigEvent(Long_t nElements, void *p) {
      return p ? new(p) ::TTrigEvent[nElements] : new ::TTrigEvent[nElements];
   }
   // Wrapper around operator delete
   static void delete_TTrigEvent(void *p) {
      delete (static_cast<::TTrigEvent*>(p));
   }
   static void deleteArray_TTrigEvent(void *p) {
      delete [] (static_cast<::TTrigEvent*>(p));
   }
   static void destruct_TTrigEvent(void *p) {
      typedef ::TTrigEvent current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TTrigEvent
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TBossFullEvent(void *p) {
      return  p ? new(p) ::TBossFullEvent : new ::TBossFullEvent;
   }
   static void *newArray_TBossFullEvent(Long_t nElements, void *p) {
      return p ? new(p) ::TBossFullEvent[nElements] : new ::TBossFullEvent[nElements];
   }
   // Wrapper around operator delete
   static void delete_TBossFullEvent(void *p) {
      delete (static_cast<::TBossFullEvent*>(p));
   }
   static void deleteArray_TBossFullEvent(void *p) {
      delete [] (static_cast<::TBossFullEvent*>(p));
   }
   static void destruct_TBossFullEvent(void *p) {
      typedef ::TBossFullEvent current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TBossFullEvent(TBuffer &buf, void *obj) {
      ((::TBossFullEvent*)obj)->::TBossFullEvent::Streamer(buf);
   }
} // end of namespace ROOT for class ::TBossFullEvent
 
//______________________________________________________________________________
void TDisTrack::Streamer(TBuffer &R__b)
{
   // Stream an object of class TDisTrack.
 
   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TObject::Streamer(R__b);
      R__b >> m_recMdcTrackCol;
      R__b >> m_recTofTrackCol;
      R__b >> m_recMdcHitCol;
      R__b >> m_recMucTrackCol;
      R__b >> m_recEmcShowerCol;
      R__b.CheckByteCount(R__s, R__c, TDisTrack::IsA());
   } else {
      R__c = R__b.WriteVersion(TDisTrack::IsA(), kTRUE);
      TObject::Streamer(R__b);
      R__b << m_recMdcTrackCol;
      R__b << m_recTofTrackCol;
      R__b << m_recMdcHitCol;
      R__b << m_recMucTrackCol;
      R__b << m_recEmcShowerCol;
      R__b.SetByteCount(R__c, kTRUE);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TDisTrack(void *p) {
      return  p ? new(p) ::TDisTrack : new ::TDisTrack;
   }
   static void *newArray_TDisTrack(Long_t nElements, void *p) {
      return p ? new(p) ::TDisTrack[nElements] : new ::TDisTrack[nElements];
   }
   // Wrapper around operator delete
   static void delete_TDisTrack(void *p) {
      delete (static_cast<::TDisTrack*>(p));
   }
   static void deleteArray_TDisTrack(void *p) {
      delete [] (static_cast<::TDisTrack*>(p));
   }
   static void destruct_TDisTrack(void *p) {
      typedef ::TDisTrack current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TDisTrack(TBuffer &buf, void *obj) {
      ((::TDisTrack*)obj)->::TDisTrack::Streamer(buf);
   }
} // end of namespace ROOT for class ::TDisTrack
 
//______________________________________________________________________________
void TEvtNavigator::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEvtNavigator.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEvtNavigator::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEvtNavigator::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TEvtNavigator(void *p) {
      return  p ? new(p) ::TEvtNavigator : new ::TEvtNavigator;
   }
   static void *newArray_TEvtNavigator(Long_t nElements, void *p) {
      return p ? new(p) ::TEvtNavigator[nElements] : new ::TEvtNavigator[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEvtNavigator(void *p) {
      delete (static_cast<::TEvtNavigator*>(p));
   }
   static void deleteArray_TEvtNavigator(void *p) {
      delete [] (static_cast<::TEvtNavigator*>(p));
   }
   static void destruct_TEvtNavigator(void *p) {
      typedef ::TEvtNavigator current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TEvtNavigator
 
//______________________________________________________________________________
void TJobInfo::Streamer(TBuffer &R__b)
{
   // Stream an object of class TJobInfo.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TJobInfo::Class(),this);
   } else {
      R__b.WriteClassBuffer(TJobInfo::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TJobInfo(void *p) {
      return  p ? new(p) ::TJobInfo : new ::TJobInfo;
   }
   static void *newArray_TJobInfo(Long_t nElements, void *p) {
      return p ? new(p) ::TJobInfo[nElements] : new ::TJobInfo[nElements];
   }
   // Wrapper around operator delete
   static void delete_TJobInfo(void *p) {
      delete (static_cast<::TJobInfo*>(p));
   }
   static void deleteArray_TJobInfo(void *p) {
      delete [] (static_cast<::TJobInfo*>(p));
   }
   static void destruct_TJobInfo(void *p) {
      typedef ::TJobInfo current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TJobInfo
 
//______________________________________________________________________________
void TMcDigiEmc::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMcDigiEmc.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMcDigiEmc::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMcDigiEmc::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TMcDigiEmc(void *p) {
      return  p ? new(p) ::TMcDigiEmc : new ::TMcDigiEmc;
   }
   static void *newArray_TMcDigiEmc(Long_t nElements, void *p) {
      return p ? new(p) ::TMcDigiEmc[nElements] : new ::TMcDigiEmc[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMcDigiEmc(void *p) {
      delete (static_cast<::TMcDigiEmc*>(p));
   }
   static void deleteArray_TMcDigiEmc(void *p) {
      delete [] (static_cast<::TMcDigiEmc*>(p));
   }
   static void destruct_TMcDigiEmc(void *p) {
      typedef ::TMcDigiEmc current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TMcDigiEmc
 
//______________________________________________________________________________
void TMcHitMdc::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMcHitMdc.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMcHitMdc::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMcHitMdc::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TMcHitMdc(void *p) {
      return  p ? new(p) ::TMcHitMdc : new ::TMcHitMdc;
   }
   static void *newArray_TMcHitMdc(Long_t nElements, void *p) {
      return p ? new(p) ::TMcHitMdc[nElements] : new ::TMcHitMdc[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMcHitMdc(void *p) {
      delete (static_cast<::TMcHitMdc*>(p));
   }
   static void deleteArray_TMcHitMdc(void *p) {
      delete [] (static_cast<::TMcHitMdc*>(p));
   }
   static void destruct_TMcHitMdc(void *p) {
      typedef ::TMcHitMdc current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TMcHitMdc
 
//______________________________________________________________________________
void TMcHitTof::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMcHitTof.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMcHitTof::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMcHitTof::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TMcHitTof(void *p) {
      return  p ? new(p) ::TMcHitTof : new ::TMcHitTof;
   }
   static void *newArray_TMcHitTof(Long_t nElements, void *p) {
      return p ? new(p) ::TMcHitTof[nElements] : new ::TMcHitTof[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMcHitTof(void *p) {
      delete (static_cast<::TMcHitTof*>(p));
   }
   static void deleteArray_TMcHitTof(void *p) {
      delete [] (static_cast<::TMcHitTof*>(p));
   }
   static void destruct_TMcHitTof(void *p) {
      typedef ::TMcHitTof current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TMcHitTof
 
//______________________________________________________________________________
void TMcHitEvent::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMcHitEvent.
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMcHitEvent::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMcHitEvent::Class(),this);
   }
}
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_TMcHitEvent(void *p) {
      return  p ? new(p) ::TMcHitEvent : new ::TMcHitEvent;
   }
   static void *newArray_TMcHitEvent(Long_t nElements, void *p) {
      return p ? new(p) ::TMcHitEvent[nElements] : new ::TMcHitEvent[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMcHitEvent(void *p) {
      delete (static_cast<::TMcHitEvent*>(p));
   }
   static void deleteArray_TMcHitEvent(void *p) {
      delete [] (static_cast<::TMcHitEvent*>(p));
   }
   static void destruct_TMcHitEvent(void *p) {
      typedef ::TMcHitEvent current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::TMcHitEvent
 
namespace ROOT {
   static TClass *vectorlEvectorlEdoublegRsPgR_Dictionary();
   static void vectorlEvectorlEdoublegRsPgR_TClassManip(TClass*);
   static void *new_vectorlEvectorlEdoublegRsPgR(void *p = nullptr);
   static void *newArray_vectorlEvectorlEdoublegRsPgR(Long_t size, void *p);
   static void delete_vectorlEvectorlEdoublegRsPgR(void *p);
   static void deleteArray_vectorlEvectorlEdoublegRsPgR(void *p);
   static void destruct_vectorlEvectorlEdoublegRsPgR(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<vector<double> >*)
   {
      vector<vector<double> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<vector<double> >));
      static ::ROOT::TGenericClassInfo 
         instance("vector<vector<double> >", -2, "vector", 423,
                  typeid(vector<vector<double> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEvectorlEdoublegRsPgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<vector<double> >) );
      instance.SetNew(&new_vectorlEvectorlEdoublegRsPgR);
      instance.SetNewArray(&newArray_vectorlEvectorlEdoublegRsPgR);
      instance.SetDelete(&delete_vectorlEvectorlEdoublegRsPgR);
      instance.SetDeleteArray(&deleteArray_vectorlEvectorlEdoublegRsPgR);
      instance.SetDestructor(&destruct_vectorlEvectorlEdoublegRsPgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<vector<double> > >()));
 
      instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<vector<double> >","std::vector<std::vector<double, std::allocator<double> >, std::allocator<std::vector<double, std::allocator<double> > > >"));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<vector<double> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
 
   // Dictionary for non-ClassDef classes
   static TClass *vectorlEvectorlEdoublegRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<vector<double> >*>(nullptr))->GetClass();
      vectorlEvectorlEdoublegRsPgR_TClassManip(theClass);
   return theClass;
   }
 
   static void vectorlEvectorlEdoublegRsPgR_TClassManip(TClass* ){
   }
 
} // end of namespace ROOT
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEvectorlEdoublegRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<vector<double> > : new vector<vector<double> >;
   }
   static void *newArray_vectorlEvectorlEdoublegRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<vector<double> >[nElements] : new vector<vector<double> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEvectorlEdoublegRsPgR(void *p) {
      delete (static_cast<vector<vector<double> >*>(p));
   }
   static void deleteArray_vectorlEvectorlEdoublegRsPgR(void *p) {
      delete [] (static_cast<vector<vector<double> >*>(p));
   }
   static void destruct_vectorlEvectorlEdoublegRsPgR(void *p) {
      typedef vector<vector<double> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class vector<vector<double> >
 
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<string>*)
   {
      vector<string> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<string>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<string>", -2, "vector", 423,
                  typeid(vector<string>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEstringgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<string>) );
      instance.SetNew(&new_vectorlEstringgR);
      instance.SetNewArray(&newArray_vectorlEstringgR);
      instance.SetDelete(&delete_vectorlEstringgR);
      instance.SetDeleteArray(&deleteArray_vectorlEstringgR);
      instance.SetDestructor(&destruct_vectorlEstringgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<string> >()));
 
      instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<string>","std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >"));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<string>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
 
   // Dictionary for non-ClassDef classes
   static TClass *vectorlEstringgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<string>*>(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(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<string> : new vector<string>;
   }
   static void *newArray_vectorlEstringgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<string>[nElements] : new vector<string>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEstringgR(void *p) {
      delete (static_cast<vector<string>*>(p));
   }
   static void deleteArray_vectorlEstringgR(void *p) {
      delete [] (static_cast<vector<string>*>(p));
   }
   static void destruct_vectorlEstringgR(void *p) {
      typedef vector<string> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class vector<string>
 
namespace ROOT {
   static TClass *vectorlEpairlEintcOfloatgRsPgR_Dictionary();
   static void vectorlEpairlEintcOfloatgRsPgR_TClassManip(TClass*);
   static void *new_vectorlEpairlEintcOfloatgRsPgR(void *p = nullptr);
   static void *newArray_vectorlEpairlEintcOfloatgRsPgR(Long_t size, void *p);
   static void delete_vectorlEpairlEintcOfloatgRsPgR(void *p);
   static void deleteArray_vectorlEpairlEintcOfloatgRsPgR(void *p);
   static void destruct_vectorlEpairlEintcOfloatgRsPgR(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<pair<int,float> >*)
   {
      vector<pair<int,float> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<pair<int,float> >));
      static ::ROOT::TGenericClassInfo 
         instance("vector<pair<int,float> >", -2, "vector", 423,
                  typeid(vector<pair<int,float> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEpairlEintcOfloatgRsPgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<pair<int,float> >) );
      instance.SetNew(&new_vectorlEpairlEintcOfloatgRsPgR);
      instance.SetNewArray(&newArray_vectorlEpairlEintcOfloatgRsPgR);
      instance.SetDelete(&delete_vectorlEpairlEintcOfloatgRsPgR);
      instance.SetDeleteArray(&deleteArray_vectorlEpairlEintcOfloatgRsPgR);
      instance.SetDestructor(&destruct_vectorlEpairlEintcOfloatgRsPgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<pair<int,float> > >()));
 
      instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<pair<int,float> >","std::vector<std::pair<int, float>, std::allocator<std::pair<int, float> > >"));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<pair<int,float> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
 
   // Dictionary for non-ClassDef classes
   static TClass *vectorlEpairlEintcOfloatgRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<pair<int,float> >*>(nullptr))->GetClass();
      vectorlEpairlEintcOfloatgRsPgR_TClassManip(theClass);
   return theClass;
   }
 
   static void vectorlEpairlEintcOfloatgRsPgR_TClassManip(TClass* ){
   }
 
} // end of namespace ROOT
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEpairlEintcOfloatgRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<pair<int,float> > : new vector<pair<int,float> >;
   }
   static void *newArray_vectorlEpairlEintcOfloatgRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<pair<int,float> >[nElements] : new vector<pair<int,float> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEpairlEintcOfloatgRsPgR(void *p) {
      delete (static_cast<vector<pair<int,float> >*>(p));
   }
   static void deleteArray_vectorlEpairlEintcOfloatgRsPgR(void *p) {
      delete [] (static_cast<vector<pair<int,float> >*>(p));
   }
   static void destruct_vectorlEpairlEintcOfloatgRsPgR(void *p) {
      typedef vector<pair<int,float> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class vector<pair<int,float> >
 
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<int>*)
   {
      vector<int> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<int>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<int>", -2, "vector", 423,
                  typeid(vector<int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEintgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<int>) );
      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<int> >()));
 
      instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<int>","std::vector<int, std::allocator<int> >"));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<int>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
 
   // Dictionary for non-ClassDef classes
   static TClass *vectorlEintgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<int>*>(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(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<int> : new vector<int>;
   }
   static void *newArray_vectorlEintgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<int>[nElements] : new vector<int>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEintgR(void *p) {
      delete (static_cast<vector<int>*>(p));
   }
   static void deleteArray_vectorlEintgR(void *p) {
      delete [] (static_cast<vector<int>*>(p));
   }
   static void destruct_vectorlEintgR(void *p) {
      typedef vector<int> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class vector<int>
 
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<float>*)
   {
      vector<float> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<float>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<float>", -2, "vector", 423,
                  typeid(vector<float>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEfloatgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<float>) );
      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<float> >()));
 
      instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<float>","std::vector<float, std::allocator<float> >"));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<float>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
 
   // Dictionary for non-ClassDef classes
   static TClass *vectorlEfloatgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<float>*>(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(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<float> : new vector<float>;
   }
   static void *newArray_vectorlEfloatgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<float>[nElements] : new vector<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEfloatgR(void *p) {
      delete (static_cast<vector<float>*>(p));
   }
   static void deleteArray_vectorlEfloatgR(void *p) {
      delete [] (static_cast<vector<float>*>(p));
   }
   static void destruct_vectorlEfloatgR(void *p) {
      typedef vector<float> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class vector<float>
 
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<double>*)
   {
      vector<double> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<double>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<double>", -2, "vector", 423,
                  typeid(vector<double>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(vector<double>) );
      instance.SetNew(&new_vectorlEdoublegR);
      instance.SetNewArray(&newArray_vectorlEdoublegR);
      instance.SetDelete(&delete_vectorlEdoublegR);
      instance.SetDeleteArray(&deleteArray_vectorlEdoublegR);
      instance.SetDestructor(&destruct_vectorlEdoublegR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<double> >()));
 
      instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<double>","std::vector<double, std::allocator<double> >"));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<double>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
 
   // Dictionary for non-ClassDef classes
   static TClass *vectorlEdoublegR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<double>*>(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(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<double> : new vector<double>;
   }
   static void *newArray_vectorlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<double>[nElements] : new vector<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEdoublegR(void *p) {
      delete (static_cast<vector<double>*>(p));
   }
   static void deleteArray_vectorlEdoublegR(void *p) {
      delete [] (static_cast<vector<double>*>(p));
   }
   static void destruct_vectorlEdoublegR(void *p) {
      typedef vector<double> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class vector<double>
 
namespace ROOT {
   static TClass *vectorlETStringgR_Dictionary();
   static void vectorlETStringgR_TClassManip(TClass*);
   static void *new_vectorlETStringgR(void *p = nullptr);
   static void *newArray_vectorlETStringgR(Long_t size, void *p);
   static void delete_vectorlETStringgR(void *p);
   static void deleteArray_vectorlETStringgR(void *p);
   static void destruct_vectorlETStringgR(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<TString>*)
   {
      vector<TString> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<TString>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<TString>", -2, "vector", 423,
                  typeid(vector<TString>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlETStringgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<TString>) );
      instance.SetNew(&new_vectorlETStringgR);
      instance.SetNewArray(&newArray_vectorlETStringgR);
      instance.SetDelete(&delete_vectorlETStringgR);
      instance.SetDeleteArray(&deleteArray_vectorlETStringgR);
      instance.SetDestructor(&destruct_vectorlETStringgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<TString> >()));
 
      instance.AdoptAlternate(::ROOT::AddClassAlternate("vector<TString>","std::vector<TString, std::allocator<TString> >"));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const vector<TString>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
 
   // Dictionary for non-ClassDef classes
   static TClass *vectorlETStringgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const vector<TString>*>(nullptr))->GetClass();
      vectorlETStringgR_TClassManip(theClass);
   return theClass;
   }
 
   static void vectorlETStringgR_TClassManip(TClass* ){
   }
 
} // end of namespace ROOT
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlETStringgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<TString> : new vector<TString>;
   }
   static void *newArray_vectorlETStringgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) vector<TString>[nElements] : new vector<TString>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlETStringgR(void *p) {
      delete (static_cast<vector<TString>*>(p));
   }
   static void deleteArray_vectorlETStringgR(void *p) {
      delete [] (static_cast<vector<TString>*>(p));
   }
   static void destruct_vectorlETStringgR(void *p) {
      typedef vector<TString> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class vector<TString>
 
namespace ROOT {
   static TClass *multimaplEintcOintgR_Dictionary();
   static void multimaplEintcOintgR_TClassManip(TClass*);
   static void *new_multimaplEintcOintgR(void *p = nullptr);
   static void *newArray_multimaplEintcOintgR(Long_t size, void *p);
   static void delete_multimaplEintcOintgR(void *p);
   static void deleteArray_multimaplEintcOintgR(void *p);
   static void destruct_multimaplEintcOintgR(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const multimap<int,int>*)
   {
      multimap<int,int> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(multimap<int,int>));
      static ::ROOT::TGenericClassInfo 
         instance("multimap<int,int>", -2, "map", 99,
                  typeid(multimap<int,int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &multimaplEintcOintgR_Dictionary, isa_proxy, 0,
                  sizeof(multimap<int,int>) );
      instance.SetNew(&new_multimaplEintcOintgR);
      instance.SetNewArray(&newArray_multimaplEintcOintgR);
      instance.SetDelete(&delete_multimaplEintcOintgR);
      instance.SetDeleteArray(&deleteArray_multimaplEintcOintgR);
      instance.SetDestructor(&destruct_multimaplEintcOintgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< multimap<int,int> >()));
 
      instance.AdoptAlternate(::ROOT::AddClassAlternate("multimap<int,int>","std::multimap<int, int, std::less<int>, std::allocator<std::pair<int const, int> > >"));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const multimap<int,int>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
 
   // Dictionary for non-ClassDef classes
   static TClass *multimaplEintcOintgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const multimap<int,int>*>(nullptr))->GetClass();
      multimaplEintcOintgR_TClassManip(theClass);
   return theClass;
   }
 
   static void multimaplEintcOintgR_TClassManip(TClass* ){
   }
 
} // end of namespace ROOT
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_multimaplEintcOintgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) multimap<int,int> : new multimap<int,int>;
   }
   static void *newArray_multimaplEintcOintgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) multimap<int,int>[nElements] : new multimap<int,int>[nElements];
   }
   // Wrapper around operator delete
   static void delete_multimaplEintcOintgR(void *p) {
      delete (static_cast<multimap<int,int>*>(p));
   }
   static void deleteArray_multimaplEintcOintgR(void *p) {
      delete [] (static_cast<multimap<int,int>*>(p));
   }
   static void destruct_multimaplEintcOintgR(void *p) {
      typedef multimap<int,int> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class multimap<int,int>
 
namespace ROOT {
   static TClass *maplEintcOdoublegR_Dictionary();
   static void maplEintcOdoublegR_TClassManip(TClass*);
   static void *new_maplEintcOdoublegR(void *p = nullptr);
   static void *newArray_maplEintcOdoublegR(Long_t size, void *p);
   static void delete_maplEintcOdoublegR(void *p);
   static void deleteArray_maplEintcOdoublegR(void *p);
   static void destruct_maplEintcOdoublegR(void *p);
 
   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const map<int,double>*)
   {
      map<int,double> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<int,double>));
      static ::ROOT::TGenericClassInfo 
         instance("map<int,double>", -2, "map", 100,
                  typeid(map<int,double>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &maplEintcOdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(map<int,double>) );
      instance.SetNew(&new_maplEintcOdoublegR);
      instance.SetNewArray(&newArray_maplEintcOdoublegR);
      instance.SetDelete(&delete_maplEintcOdoublegR);
      instance.SetDeleteArray(&deleteArray_maplEintcOdoublegR);
      instance.SetDestructor(&destruct_maplEintcOdoublegR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<int,double> >()));
 
      instance.AdoptAlternate(::ROOT::AddClassAlternate("map<int,double>","std::map<int, double, std::less<int>, std::allocator<std::pair<int const, double> > >"));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const map<int,double>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));
 
   // Dictionary for non-ClassDef classes
   static TClass *maplEintcOdoublegR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const map<int,double>*>(nullptr))->GetClass();
      maplEintcOdoublegR_TClassManip(theClass);
   return theClass;
   }
 
   static void maplEintcOdoublegR_TClassManip(TClass* ){
   }
 
} // end of namespace ROOT
 
namespace ROOT {
   // Wrappers around operator new
   static void *new_maplEintcOdoublegR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map<int,double> : new map<int,double>;
   }
   static void *newArray_maplEintcOdoublegR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) map<int,double>[nElements] : new map<int,double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplEintcOdoublegR(void *p) {
      delete (static_cast<map<int,double>*>(p));
   }
   static void deleteArray_maplEintcOdoublegR(void *p) {
      delete [] (static_cast<map<int,double>*>(p));
   }
   static void destruct_maplEintcOdoublegR(void *p) {
      typedef map<int,double> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class map<int,double>
 
namespace {
  void TriggerDictionaryInitialization_libRootEventData_Impl() {
    static const char* headers[] = {
"include/RootEventData/TBossFullEvent.h",
"include/RootEventData/TDigiEvent.h",
"include/RootEventData/TDisTrack.h",
"include/RootEventData/TDstEvent.h",
"include/RootEventData/TDstHltInf.h",
"include/RootEventData/TEmcDigi.h",
"include/RootEventData/TEmcMc.h",
"include/RootEventData/TEmcTrack.h",
"include/RootEventData/TEvtHeader.h",
"include/RootEventData/TEvtNavigator.h",
"include/RootEventData/TEvtRecDTag.h",
"include/RootEventData/TEvtRecEtaToGG.h",
"include/RootEventData/TEvtRecEvent.h",
"include/RootEventData/TEvtRecObject.h",
"include/RootEventData/TEvtRecPi0.h",
"include/RootEventData/TEvtRecPrimaryVertex.h",
"include/RootEventData/TEvtRecTrack.h",
"include/RootEventData/TEvtRecVeeVertex.h",
"include/RootEventData/TExtTrack.h",
"include/RootEventData/THltEvent.h",
"include/RootEventData/THltInf.h",
"include/RootEventData/THltRaw.h",
"include/RootEventData/TJobInfo.h",
"include/RootEventData/TLumiDigi.h",
"include/RootEventData/TMcDigiEmc.h",
"include/RootEventData/TMcEvent.h",
"include/RootEventData/TMcHitEvent.h",
"include/RootEventData/TMcHitMdc.h",
"include/RootEventData/TMcHitTof.h",
"include/RootEventData/TMcParticle.h",
"include/RootEventData/TMdcDedx.h",
"include/RootEventData/TMdcDigi.h",
"include/RootEventData/TMdcKalTrack.h",
"include/RootEventData/TMdcMc.h",
"include/RootEventData/TMdcTrack.h",
"include/RootEventData/TMucDigi.h",
"include/RootEventData/TMucMc.h",
"include/RootEventData/TMucTrack.h",
"include/RootEventData/TRawData.h",
"include/RootEventData/TRecEmcCluster.h",
"include/RootEventData/TRecEmcHit.h",
"include/RootEventData/TRecEmcShower.h",
"include/RootEventData/TRecEvTime.h",
"include/RootEventData/TRecExtTrack.h",
"include/RootEventData/TRecMdcDedx.h",
"include/RootEventData/TRecMdcDedxHit.h",
"include/RootEventData/TRecMdcHit.h",
"include/RootEventData/TRecMdcKalHelixSeg.h",
"include/RootEventData/TRecMdcKalTrack.h",
"include/RootEventData/TRecMdcTrack.h",
"include/RootEventData/TRecMucTrack.h",
"include/RootEventData/TRecTofTrack.h",
"include/RootEventData/TRecTrackEvent.h",
"include/RootEventData/TRecZddChannel.h",
"include/RootEventData/TTofDigi.h",
"include/RootEventData/TTofMc.h",
"include/RootEventData/TTofTrack.h",
"include/RootEventData/TTrigData.h",
"include/RootEventData/TTrigEvent.h",
nullptr
    };
    static const char* includePaths[] = {
"/cvmfs/bes3.ihep.ac.cn/bes3sw/ExternalLib/lcg/LCG_106/106/x86_64-el9-gcc13-opt/include",
"/cvmfs/bes3.ihep.ac.cn/bes3sw/Boss/8.0.0/BOSS_Source/Event/RootEventData",
"/cvmfs/bes3.ihep.ac.cn/bes3sw/Boss/8.0.0/BOSS_Source/Event/RootEventData/include",
"/cvmfs/bes3.ihep.ac.cn/bes3sw/ExternalLib/lcg/LCG_106/106/x86_64-el9-gcc13-opt/include",
"/cvmfs/bes3.ihep.ac.cn/bes3sw/Boss/8.0.0/BOSS_Source/Event/RootEventData/include",
"/cvmfs/bes3.ihep.ac.cn/bes3sw/ExternalLib/lcg/LCG_106/ROOT/6.32.02-51ebb/x86_64-el9-gcc13-opt/include/",
"/cvmfs/bes3.ihep.ac.cn/bes3sw/Boss/8.0.0/BOSS_Source/BuildArea/x86_64-el9-gcc13-dbg/Event/RootEventData/",
nullptr
    };
    static const char* fwdDeclCode = R"DICTFWDDCLS(
#line 1 "libRootEventData 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$include/RootEventData/TBossFullEvent.h")))  TRawData;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TEmcDigi;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TLumiDigi;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TMdcDigi;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TMucDigi;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TTofDigi;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TDigiEvent;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TEmcTrack;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TExtTrack;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TMdcDedx;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TMdcKalTrack;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TMdcTrack;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TMucTrack;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TTofTrack;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TDstEvent;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TEvtHeader;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TEvtRecDTag;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TEvtRecEtaToGG;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TEvtRecEvent;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TEvtRecPi0;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TEvtRecPrimaryVertex;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TEvtRecTrack;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TEvtRecVeeVertex;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TEvtRecObject;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TDstHltInf;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  THltInf;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  THltRaw;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  THltEvent;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TEmcMc;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TMcParticle;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TMdcMc;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TMucMc;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TTofMc;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TMcEvent;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TRecEmcCluster;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TRecEmcHit;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TRecEmcShower;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TRecEvTime;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TRecExtTrack;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TRecMdcDedx;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TRecMdcDedxHit;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TRecMdcHit;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TRecMdcKalHelixSeg;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TRecMdcKalTrack;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TRecMdcTrack;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TRecMucTrack;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TRecTofTrack;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TRecZddChannel;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TRecTrackEvent;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TTrigData;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TTrigEvent;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TBossFullEvent.h")))  TBossFullEvent;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TDisTrack.h")))  TDisTrack;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TEvtNavigator.h")))  TEvtNavigator;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TJobInfo.h")))  TJobInfo;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TMcDigiEmc.h")))  TMcDigiEmc;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TMcHitEvent.h")))  TMcHitMdc;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TMcHitEvent.h")))  TMcHitTof;
class __attribute__((annotate("$clingAutoload$include/RootEventData/TMcHitEvent.h")))  TMcHitEvent;
)DICTFWDDCLS";
    static const char* payloadCode = R"DICTPAYLOAD(
#line 1 "libRootEventData dictionary payload"
 
#ifndef DEBUG_LEVEL
  #define DEBUG_LEVEL 0
#endif
 
#define _BACKWARD_BACKWARD_WARNING_H
// Inline headers
#include "include/RootEventData/TBossFullEvent.h"
#include "include/RootEventData/TDigiEvent.h"
#include "include/RootEventData/TDisTrack.h"
#include "include/RootEventData/TDstEvent.h"
#include "include/RootEventData/TDstHltInf.h"
#include "include/RootEventData/TEmcDigi.h"
#include "include/RootEventData/TEmcMc.h"
#include "include/RootEventData/TEmcTrack.h"
#include "include/RootEventData/TEvtHeader.h"
#include "include/RootEventData/TEvtNavigator.h"
#include "include/RootEventData/TEvtRecDTag.h"
#include "include/RootEventData/TEvtRecEtaToGG.h"
#include "include/RootEventData/TEvtRecEvent.h"
#include "include/RootEventData/TEvtRecObject.h"
#include "include/RootEventData/TEvtRecPi0.h"
#include "include/RootEventData/TEvtRecPrimaryVertex.h"
#include "include/RootEventData/TEvtRecTrack.h"
#include "include/RootEventData/TEvtRecVeeVertex.h"
#include "include/RootEventData/TExtTrack.h"
#include "include/RootEventData/THltEvent.h"
#include "include/RootEventData/THltInf.h"
#include "include/RootEventData/THltRaw.h"
#include "include/RootEventData/TJobInfo.h"
#include "include/RootEventData/TLumiDigi.h"
#include "include/RootEventData/TMcDigiEmc.h"
#include "include/RootEventData/TMcEvent.h"
#include "include/RootEventData/TMcHitEvent.h"
#include "include/RootEventData/TMcHitMdc.h"
#include "include/RootEventData/TMcHitTof.h"
#include "include/RootEventData/TMcParticle.h"
#include "include/RootEventData/TMdcDedx.h"
#include "include/RootEventData/TMdcDigi.h"
#include "include/RootEventData/TMdcKalTrack.h"
#include "include/RootEventData/TMdcMc.h"
#include "include/RootEventData/TMdcTrack.h"
#include "include/RootEventData/TMucDigi.h"
#include "include/RootEventData/TMucMc.h"
#include "include/RootEventData/TMucTrack.h"
#include "include/RootEventData/TRawData.h"
#include "include/RootEventData/TRecEmcCluster.h"
#include "include/RootEventData/TRecEmcHit.h"
#include "include/RootEventData/TRecEmcShower.h"
#include "include/RootEventData/TRecEvTime.h"
#include "include/RootEventData/TRecExtTrack.h"
#include "include/RootEventData/TRecMdcDedx.h"
#include "include/RootEventData/TRecMdcDedxHit.h"
#include "include/RootEventData/TRecMdcHit.h"
#include "include/RootEventData/TRecMdcKalHelixSeg.h"
#include "include/RootEventData/TRecMdcKalTrack.h"
#include "include/RootEventData/TRecMdcTrack.h"
#include "include/RootEventData/TRecMucTrack.h"
#include "include/RootEventData/TRecTofTrack.h"
#include "include/RootEventData/TRecTrackEvent.h"
#include "include/RootEventData/TRecZddChannel.h"
#include "include/RootEventData/TTofDigi.h"
#include "include/RootEventData/TTofMc.h"
#include "include/RootEventData/TTofTrack.h"
#include "include/RootEventData/TTrigData.h"
#include "include/RootEventData/TTrigEvent.h"
 
#undef  _BACKWARD_BACKWARD_WARNING_H
)DICTPAYLOAD";
    static const char* classesHeaders[] = {
"TBossFullEvent", payloadCode, "@",
"TDigiEvent", payloadCode, "@",
"TDisTrack", payloadCode, "@",
"TDstEvent", payloadCode, "@",
"TDstHltInf", payloadCode, "@",
"TEmcDigi", payloadCode, "@",
"TEmcMc", payloadCode, "@",
"TEmcTrack", payloadCode, "@",
"TEvtHeader", payloadCode, "@",
"TEvtNavigator", payloadCode, "@",
"TEvtRecDTag", payloadCode, "@",
"TEvtRecEtaToGG", payloadCode, "@",
"TEvtRecEvent", payloadCode, "@",
"TEvtRecObject", payloadCode, "@",
"TEvtRecPi0", payloadCode, "@",
"TEvtRecPrimaryVertex", payloadCode, "@",
"TEvtRecTrack", payloadCode, "@",
"TEvtRecVeeVertex", payloadCode, "@",
"TExtTrack", payloadCode, "@",
"THltEvent", payloadCode, "@",
"THltInf", payloadCode, "@",
"THltRaw", payloadCode, "@",
"TJobInfo", payloadCode, "@",
"TLumiDigi", payloadCode, "@",
"TMcDigiEmc", payloadCode, "@",
"TMcEvent", payloadCode, "@",
"TMcHitEvent", payloadCode, "@",
"TMcHitMdc", payloadCode, "@",
"TMcHitTof", payloadCode, "@",
"TMcParticle", payloadCode, "@",
"TMdcDedx", payloadCode, "@",
"TMdcDigi", payloadCode, "@",
"TMdcKalTrack", payloadCode, "@",
"TMdcMc", payloadCode, "@",
"TMdcTrack", payloadCode, "@",
"TMucDigi", payloadCode, "@",
"TMucMc", payloadCode, "@",
"TMucTrack", payloadCode, "@",
"TRawData", payloadCode, "@",
"TRecEmcCluster", payloadCode, "@",
"TRecEmcHit", payloadCode, "@",
"TRecEmcShower", payloadCode, "@",
"TRecEvTime", payloadCode, "@",
"TRecExtTrack", payloadCode, "@",
"TRecMdcDedx", payloadCode, "@",
"TRecMdcDedxHit", payloadCode, "@",
"TRecMdcHit", payloadCode, "@",
"TRecMdcKalHelixSeg", payloadCode, "@",
"TRecMdcKalTrack", payloadCode, "@",
"TRecMdcTrack", payloadCode, "@",
"TRecMucTrack", payloadCode, "@",
"TRecTofTrack", payloadCode, "@",
"TRecTrackEvent", payloadCode, "@",
"TRecZddChannel", payloadCode, "@",
"TTofDigi", payloadCode, "@",
"TTofMc", payloadCode, "@",
"TTofTrack", payloadCode, "@",
"TTrigData", payloadCode, "@",
"TTrigEvent", payloadCode, "@",
nullptr
};
    static bool isInitialized = false;
    if (!isInitialized) {
      TROOT::RegisterModule("libRootEventData",
        headers, includePaths, payloadCode, fwdDeclCode,
        TriggerDictionaryInitialization_libRootEventData_Impl, {}, classesHeaders, /*hasCxxModule*/false);
      isInitialized = true;
    }
  }
  static struct DictInit {
    DictInit() {
      TriggerDictionaryInitialization_libRootEventData_Impl();
    }
  } __TheDictionaryInitializer;
}
void TriggerDictionaryInitialization_libRootEventData() {
  TriggerDictionaryInitialization_libRootEventData_Impl();
}