/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Event/RootEventData/RootEventData-00-03-80/RootEventData/RootEventData_rootcint.cxx

Go to the documentation of this file.

//
// File generated by /afs/.jinr.ru/bes3/build//external/ROOT/5.34.09/x86_64-slc6-gcc46-opt/root/bin/rootcint at Thu Oct  6 21:00:51 2016

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

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

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

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

#ifndef G__ROOT
#define G__ROOT
#endif

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

// START OF SHADOWS

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

namespace ROOT {
   void TJobInfo_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TJobInfo(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TJobInfo >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TJobInfo", ::TJobInfo::Class_Version(), "./../RootEventData/TJobInfo.h", 9,
                  typeid(::TJobInfo), 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((::TJobInfo*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TJobInfo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TRawData_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRawData(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRawData >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRawData", ::TRawData::Class_Version(), "./../RootEventData/TRawData.h", 7,
                  typeid(::TRawData), 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((::TRawData*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRawData*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMdcDigi_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMdcDigi(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMdcDigi >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMdcDigi", ::TMdcDigi::Class_Version(), "./../RootEventData/TMdcDigi.h", 7,
                  typeid(::TMdcDigi), 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((::TMdcDigi*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMdcDigi*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TEmcDigi_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEmcDigi(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEmcDigi >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEmcDigi", ::TEmcDigi::Class_Version(), "./../RootEventData/TEmcDigi.h", 6,
                  typeid(::TEmcDigi), 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((::TEmcDigi*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEmcDigi*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TTofDigi_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TTofDigi(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTofDigi >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TTofDigi", ::TTofDigi::Class_Version(), "./../RootEventData/TTofDigi.h", 7,
                  typeid(::TTofDigi), 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((::TTofDigi*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTofDigi*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMucDigi_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMucDigi(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMucDigi >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMucDigi", ::TMucDigi::Class_Version(), "./../RootEventData/TMucDigi.h", 7,
                  typeid(::TMucDigi), 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((::TMucDigi*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMucDigi*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TLumiDigi_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TLumiDigi(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TLumiDigi >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TLumiDigi", ::TLumiDigi::Class_Version(), "./../RootEventData/TLumiDigi.h", 6,
                  typeid(::TLumiDigi), 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((::TLumiDigi*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TLumiDigi*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TDigiEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TDigiEvent(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDigiEvent >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TDigiEvent", ::TDigiEvent::Class_Version(), "./../RootEventData/TDigiEvent.h", 14,
                  typeid(::TDigiEvent), 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((::TDigiEvent*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDigiEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TRecMdcTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRecMdcTrack(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcTrack >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRecMdcTrack", ::TRecMdcTrack::Class_Version(), "./../RootEventData/TRecMdcTrack.h", 9,
                  typeid(::TRecMdcTrack), 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((::TRecMdcTrack*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecMdcTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TRecMdcKalTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRecMdcKalTrack(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcKalTrack >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRecMdcKalTrack", ::TRecMdcKalTrack::Class_Version(), "./../RootEventData/TRecMdcKalTrack.h", 7,
                  typeid(::TRecMdcKalTrack), 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((::TRecMdcKalTrack*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecMdcKalTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TRecMdcHit_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRecMdcHit(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcHit >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRecMdcHit", ::TRecMdcHit::Class_Version(), "./../RootEventData/TRecMdcHit.h", 9,
                  typeid(::TRecMdcHit), 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((::TRecMdcHit*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecMdcHit*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TTofTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TTofTrack(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTofTrack >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TTofTrack", ::TTofTrack::Class_Version(), "./../RootEventData/TTofTrack.h", 10,
                  typeid(::TTofTrack), 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((::TTofTrack*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTofTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TRecTofTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRecTofTrack(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecTofTrack >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRecTofTrack", ::TRecTofTrack::Class_Version(), "./../RootEventData/TRecTofTrack.h", 9,
                  typeid(::TRecTofTrack), 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((::TRecTofTrack*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecTofTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TRecEmcHit_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRecEmcHit(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecEmcHit >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRecEmcHit", ::TRecEmcHit::Class_Version(), "./../RootEventData/TRecEmcHit.h", 9,
                  typeid(::TRecEmcHit), 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((::TRecEmcHit*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecEmcHit*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TRecEmcCluster_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRecEmcCluster(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecEmcCluster >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRecEmcCluster", ::TRecEmcCluster::Class_Version(), "./../RootEventData/TRecEmcCluster.h", 9,
                  typeid(::TRecEmcCluster), 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((::TRecEmcCluster*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecEmcCluster*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TRecEmcShower_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRecEmcShower(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecEmcShower >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRecEmcShower", ::TRecEmcShower::Class_Version(), "./../RootEventData/TRecEmcShower.h", 11,
                  typeid(::TRecEmcShower), 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((::TRecEmcShower*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecEmcShower*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TRecMucTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRecMucTrack(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMucTrack >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRecMucTrack", ::TRecMucTrack::Class_Version(), "./../RootEventData/TRecMucTrack.h", 9,
                  typeid(::TRecMucTrack), 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((::TRecMucTrack*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecMucTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TRecMdcDedx_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRecMdcDedx(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcDedx >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRecMdcDedx", ::TRecMdcDedx::Class_Version(), "./../RootEventData/TRecMdcDedx.h", 6,
                  typeid(::TRecMdcDedx), 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((::TRecMdcDedx*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecMdcDedx*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TRecMdcDedxHit_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRecMdcDedxHit(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcDedxHit >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRecMdcDedxHit", ::TRecMdcDedxHit::Class_Version(), "./../RootEventData/TRecMdcDedxHit.h", 7,
                  typeid(::TRecMdcDedxHit), 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((::TRecMdcDedxHit*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecMdcDedxHit*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TRecExtTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRecExtTrack(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecExtTrack >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRecExtTrack", ::TRecExtTrack::Class_Version(), "./../RootEventData/TRecExtTrack.h", 8,
                  typeid(::TRecExtTrack), 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((::TRecExtTrack*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecExtTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TRecEvTime_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRecEvTime(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecEvTime >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRecEvTime", ::TRecEvTime::Class_Version(), "./../RootEventData/TRecEvTime.h", 10,
                  typeid(::TRecEvTime), 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((::TRecEvTime*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecEvTime*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TRecMdcKalHelixSeg_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRecMdcKalHelixSeg(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecMdcKalHelixSeg >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRecMdcKalHelixSeg", ::TRecMdcKalHelixSeg::Class_Version(), "./../RootEventData/TRecMdcKalHelixSeg.h", 9,
                  typeid(::TRecMdcKalHelixSeg), 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((::TRecMdcKalHelixSeg*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecMdcKalHelixSeg*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TRecZddChannel_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRecZddChannel(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecZddChannel >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRecZddChannel", ::TRecZddChannel::Class_Version(), "./../RootEventData/TRecZddChannel.h", 9,
                  typeid(::TRecZddChannel), 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((::TRecZddChannel*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecZddChannel*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TRecTrackEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRecTrackEvent(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRecTrackEvent >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRecTrackEvent", ::TRecTrackEvent::Class_Version(), "./../RootEventData/TRecTrackEvent.h", 24,
                  typeid(::TRecTrackEvent), 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((::TRecTrackEvent*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRecTrackEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMdcTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMdcTrack(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMdcTrack >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMdcTrack", ::TMdcTrack::Class_Version(), "./../RootEventData/TMdcTrack.h", 6,
                  typeid(::TMdcTrack), 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((::TMdcTrack*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMdcTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TEmcTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEmcTrack(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEmcTrack >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEmcTrack", ::TEmcTrack::Class_Version(), "./../RootEventData/TEmcTrack.h", 7,
                  typeid(::TEmcTrack), 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((::TEmcTrack*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEmcTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMucTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMucTrack(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMucTrack >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMucTrack", ::TMucTrack::Class_Version(), "./../RootEventData/TMucTrack.h", 9,
                  typeid(::TMucTrack), 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((::TMucTrack*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMucTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMdcDedx_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMdcDedx(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMdcDedx >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMdcDedx", ::TMdcDedx::Class_Version(), "./../RootEventData/TMdcDedx.h", 6,
                  typeid(::TMdcDedx), 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((::TMdcDedx*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMdcDedx*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TExtTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TExtTrack(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TExtTrack >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TExtTrack", ::TExtTrack::Class_Version(), "./../RootEventData/TExtTrack.h", 9,
                  typeid(::TExtTrack), 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((::TExtTrack*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TExtTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMdcKalTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMdcKalTrack(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMdcKalTrack >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMdcKalTrack", ::TMdcKalTrack::Class_Version(), "./../RootEventData/TMdcKalTrack.h", 8,
                  typeid(::TMdcKalTrack), 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((::TMdcKalTrack*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMdcKalTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TDstEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TDstEvent(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDstEvent >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TDstEvent", ::TDstEvent::Class_Version(), "./../RootEventData/TDstEvent.h", 16,
                  typeid(::TDstEvent), 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((::TDstEvent*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDstEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMdcMc_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMdcMc(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMdcMc >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMdcMc", ::TMdcMc::Class_Version(), "./../RootEventData/TMdcMc.h", 8,
                  typeid(::TMdcMc), 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((::TMdcMc*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMdcMc*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TEmcMc_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEmcMc(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEmcMc >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEmcMc", ::TEmcMc::Class_Version(), "./../RootEventData/TEmcMc.h", 10,
                  typeid(::TEmcMc), 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((::TEmcMc*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEmcMc*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TTofMc_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TTofMc(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTofMc >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TTofMc", ::TTofMc::Class_Version(), "./../RootEventData/TTofMc.h", 8,
                  typeid(::TTofMc), 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((::TTofMc*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTofMc*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMucMc_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMucMc(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMucMc >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMucMc", ::TMucMc::Class_Version(), "./../RootEventData/TMucMc.h", 8,
                  typeid(::TMucMc), 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((::TMucMc*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMucMc*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMcParticle_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMcParticle(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcParticle >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMcParticle", ::TMcParticle::Class_Version(), "./../RootEventData/TMcParticle.h", 9,
                  typeid(::TMcParticle), 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((::TMcParticle*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMcParticle*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMcEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMcEvent(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcEvent >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMcEvent", ::TMcEvent::Class_Version(), "./../RootEventData/TMcEvent.h", 16,
                  typeid(::TMcEvent), 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((::TMcEvent*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMcEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TEvtHeader_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEvtHeader(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtHeader >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEvtHeader", ::TEvtHeader::Class_Version(), "./../RootEventData/TEvtHeader.h", 8,
                  typeid(::TEvtHeader), 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((::TEvtHeader*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEvtHeader*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TEvtNavigator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEvtNavigator(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtNavigator >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEvtNavigator", ::TEvtNavigator::Class_Version(), "./../RootEventData/TEvtNavigator.h", 11,
                  typeid(::TEvtNavigator), 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((::TEvtNavigator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEvtNavigator*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TTrigData_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TTrigData(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTrigData >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TTrigData", ::TTrigData::Class_Version(), "./../RootEventData/TTrigData.h", 8,
                  typeid(::TTrigData), 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((::TTrigData*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTrigData*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TTrigEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TTrigEvent(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTrigEvent >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TTrigEvent", ::TTrigEvent::Class_Version(), "./../RootEventData/TTrigEvent.h", 10,
                  typeid(::TTrigEvent), 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((::TTrigEvent*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTrigEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void THltRaw_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_THltRaw(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THltRaw >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THltRaw", ::THltRaw::Class_Version(), "./../RootEventData/THltRaw.h", 7,
                  typeid(::THltRaw), 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((::THltRaw*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THltRaw*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void THltInf_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_THltInf(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THltInf >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THltInf", ::THltInf::Class_Version(), "./../RootEventData/THltInf.h", 9,
                  typeid(::THltInf), 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((::THltInf*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THltInf*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TDstHltInf_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TDstHltInf(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDstHltInf >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TDstHltInf", ::TDstHltInf::Class_Version(), "./../RootEventData/TDstHltInf.h", 9,
                  typeid(::TDstHltInf), 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((::TDstHltInf*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDstHltInf*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void THltEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_THltEvent(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THltEvent >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THltEvent", ::THltEvent::Class_Version(), "./../RootEventData/THltEvent.h", 12,
                  typeid(::THltEvent), 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((::THltEvent*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THltEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TDisTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TDisTrack(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDisTrack >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TDisTrack", ::TDisTrack::Class_Version(), "./../RootEventData/TDisTrack.h", 12,
                  typeid(::TDisTrack), DefineBehavior(ptr, ptr),
                  &::TDisTrack::Dictionary, isa_proxy, 0,
                  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((::TDisTrack*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDisTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TEvtRecEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEvtRecEvent(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecEvent >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEvtRecEvent", ::TEvtRecEvent::Class_Version(), "./../RootEventData/TEvtRecEvent.h", 7,
                  typeid(::TEvtRecEvent), 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((::TEvtRecEvent*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEvtRecEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TEvtRecTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEvtRecTrack(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecTrack >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEvtRecTrack", ::TEvtRecTrack::Class_Version(), "./../RootEventData/TEvtRecTrack.h", 7,
                  typeid(::TEvtRecTrack), 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((::TEvtRecTrack*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEvtRecTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TEvtRecPrimaryVertex_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEvtRecPrimaryVertex(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecPrimaryVertex >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEvtRecPrimaryVertex", ::TEvtRecPrimaryVertex::Class_Version(), "./../RootEventData/TEvtRecPrimaryVertex.h", 7,
                  typeid(::TEvtRecPrimaryVertex), 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((::TEvtRecPrimaryVertex*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEvtRecPrimaryVertex*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TEvtRecVeeVertex_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEvtRecVeeVertex(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecVeeVertex >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEvtRecVeeVertex", ::TEvtRecVeeVertex::Class_Version(), "./../RootEventData/TEvtRecVeeVertex.h", 6,
                  typeid(::TEvtRecVeeVertex), 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((::TEvtRecVeeVertex*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEvtRecVeeVertex*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TEvtRecPi0_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEvtRecPi0(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecPi0 >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEvtRecPi0", ::TEvtRecPi0::Class_Version(), "./../RootEventData/TEvtRecPi0.h", 8,
                  typeid(::TEvtRecPi0), 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((::TEvtRecPi0*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEvtRecPi0*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TEvtRecEtaToGG_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEvtRecEtaToGG(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecEtaToGG >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEvtRecEtaToGG", ::TEvtRecEtaToGG::Class_Version(), "./../RootEventData/TEvtRecEtaToGG.h", 8,
                  typeid(::TEvtRecEtaToGG), 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((::TEvtRecEtaToGG*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEvtRecEtaToGG*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TEvtRecDTag_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEvtRecDTag(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecDTag >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEvtRecDTag", ::TEvtRecDTag::Class_Version(), "./../RootEventData/TEvtRecDTag.h", 8,
                  typeid(::TEvtRecDTag), 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((::TEvtRecDTag*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEvtRecDTag*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TEvtRecObject_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEvtRecObject(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvtRecObject >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEvtRecObject", ::TEvtRecObject::Class_Version(), "./../RootEventData/TEvtRecObject.h", 15,
                  typeid(::TEvtRecObject), 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((::TEvtRecObject*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEvtRecObject*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMcHitTof_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMcHitTof(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcHitTof >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMcHitTof", ::TMcHitTof::Class_Version(), "./../RootEventData/TMcHitTof.h", 8,
                  typeid(::TMcHitTof), 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((::TMcHitTof*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMcHitTof*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMcHitMdc_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMcHitMdc(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcHitMdc >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMcHitMdc", ::TMcHitMdc::Class_Version(), "./../RootEventData/TMcHitMdc.h", 8,
                  typeid(::TMcHitMdc), 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((::TMcHitMdc*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMcHitMdc*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMcDigiEmc_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMcDigiEmc(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcDigiEmc >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMcDigiEmc", ::TMcDigiEmc::Class_Version(), "./../RootEventData/TMcDigiEmc.h", 8,
                  typeid(::TMcDigiEmc), 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((::TMcDigiEmc*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMcDigiEmc*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMcHitEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMcHitEvent(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMcHitEvent >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMcHitEvent", ::TMcHitEvent::Class_Version(), "./../RootEventData/TMcHitEvent.h", 12,
                  typeid(::TMcHitEvent), 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((::TMcHitEvent*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMcHitEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TBossFullEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TBossFullEvent(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TBossFullEvent >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TBossFullEvent", ::TBossFullEvent::Class_Version(), "./../RootEventData/TBossFullEvent.h", 15,
                  typeid(::TBossFullEvent), DefineBehavior(ptr, ptr),
                  &::TBossFullEvent::Dictionary, isa_proxy, 1,
                  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((::TBossFullEvent*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TBossFullEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TDigiEvent::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TDigiEvent.
      TClass *R__cl = ::TDigiEvent::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fromMc", &m_fromMc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_mdcDigiCol", &m_mdcDigiCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_emcDigiCol", &m_emcDigiCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_tofDigiCol", &m_tofDigiCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_mucDigiCol", &m_mucDigiCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_lumiDigiCol", &m_lumiDigiCol);
      TObject::ShowMembers(R__insp);
}

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 ((::TDigiEvent*)p);
   }
   static void deleteArray_TDigiEvent(void *p) {
      delete [] ((::TDigiEvent*)p);
   }
   static void destruct_TDigiEvent(void *p) {
      typedef ::TDigiEvent current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TDigiEvent

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TRawData::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TRawData.
      TClass *R__cl = ::TRawData::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_intId", &m_intId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_timeChannel", &m_timeChannel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chargeChannel", &m_chargeChannel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackIndex", &m_trackIndex);
      TObject::ShowMembers(R__insp);
}

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 ((::TRawData*)p);
   }
   static void deleteArray_TRawData(void *p) {
      delete [] ((::TRawData*)p);
   }
   static void destruct_TRawData(void *p) {
      typedef ::TRawData current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TRawData

//______________________________________________________________________________
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);
   }
}

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

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 ((::TMdcDigi*)p);
   }
   static void deleteArray_TMdcDigi(void *p) {
      delete [] ((::TMdcDigi*)p);
   }
   static void destruct_TMdcDigi(void *p) {
      typedef ::TMdcDigi current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMdcDigi

//______________________________________________________________________________
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);
   }
}

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

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 ((::TEmcDigi*)p);
   }
   static void deleteArray_TEmcDigi(void *p) {
      delete [] ((::TEmcDigi*)p);
   }
   static void destruct_TEmcDigi(void *p) {
      typedef ::TEmcDigi current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEmcDigi

//______________________________________________________________________________
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);
   }
}

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

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 ((::TTofDigi*)p);
   }
   static void deleteArray_TTofDigi(void *p) {
      delete [] ((::TTofDigi*)p);
   }
   static void destruct_TTofDigi(void *p) {
      typedef ::TTofDigi current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TTofDigi

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TMucDigi::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMucDigi.
      TClass *R__cl = ::TMucDigi::IsA();
      if (R__cl || R__insp.IsA()) { }
      TRawData::ShowMembers(R__insp);
}

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 ((::TMucDigi*)p);
   }
   static void deleteArray_TMucDigi(void *p) {
      delete [] ((::TMucDigi*)p);
   }
   static void destruct_TMucDigi(void *p) {
      typedef ::TMucDigi current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMucDigi

//______________________________________________________________________________
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);
   }
}

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

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 ((::TLumiDigi*)p);
   }
   static void deleteArray_TLumiDigi(void *p) {
      delete [] ((::TLumiDigi*)p);
   }
   static void destruct_TLumiDigi(void *p) {
      typedef ::TLumiDigi current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TLumiDigi

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TDstEvent::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TDstEvent.
      TClass *R__cl = ::TDstEvent::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_emcTrackCol", &m_emcTrackCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_mdcTrackCol", &m_mdcTrackCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_tofTrackCol", &m_tofTrackCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_mucTrackCol", &m_mucTrackCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_mdcDedxCol", &m_mdcDedxCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_extTrackCol", &m_extTrackCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_mdcKalTrackCol", &m_mdcKalTrackCol);
      TObject::ShowMembers(R__insp);
}

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 ((::TDstEvent*)p);
   }
   static void deleteArray_TDstEvent(void *p) {
      delete [] ((::TDstEvent*)p);
   }
   static void destruct_TDstEvent(void *p) {
      typedef ::TDstEvent current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TDstEvent

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TMdcTrack::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMdcTrack.
      TClass *R__cl = ::TMdcTrack::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_helix[5]", m_helix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_err[15]", m_err);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_stat", &m_stat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chi2", &m_chi2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ndof", &m_ndof);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nster", &m_nster);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nlayer", &m_nlayer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_firstLayer", &m_firstLayer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lastLayer", &m_lastLayer);
      TObject::ShowMembers(R__insp);
}

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 ((::TMdcTrack*)p);
   }
   static void deleteArray_TMdcTrack(void *p) {
      delete [] ((::TMdcTrack*)p);
   }
   static void destruct_TMdcTrack(void *p) {
      typedef ::TMdcTrack current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMdcTrack

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TEmcTrack::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEmcTrack.
      TClass *R__cl = ::TEmcTrack::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_numHits", &m_numHits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_status", &m_status);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_cellId", &m_cellId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_module", &m_module);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_x", &m_x);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_y", &m_y);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_z", &m_z);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dTheta", &m_dTheta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dPhi", &m_dPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_energy", &m_energy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dE", &m_dE);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_eSeed", &m_eSeed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_e3x3", &m_e3x3);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_e5x5", &m_e5x5);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_time", &m_time);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_secondMoment", &m_secondMoment);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_latMoment", &m_latMoment);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_a20Moment", &m_a20Moment);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_a42Moment", &m_a42Moment);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_err[6]", m_err);
      TObject::ShowMembers(R__insp);
}

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 ((::TEmcTrack*)p);
   }
   static void deleteArray_TEmcTrack(void *p) {
      delete [] ((::TEmcTrack*)p);
   }
   static void destruct_TEmcTrack(void *p) {
      typedef ::TEmcTrack current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEmcTrack

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TTofTrack::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TTofTrack.
      TClass *R__cl = ::TTofTrack::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tofTrackID", &m_tofTrackID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackID", &m_trackID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tofID", &m_tofID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_status", &m_status);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_path", &m_path);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zrhit", &m_zrhit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ph", &m_ph);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tof", &m_tof);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_beta", &m_beta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_texp[5]", m_texp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_toffset[6]", m_toffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_sigma[6]", m_sigma);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_quality", &m_quality);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_t0", &m_t0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_errt0", &m_errt0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_errz", &m_errz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_phi", &m_phi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_errphi", &m_errphi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_energy", &m_energy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_errenergy", &m_errenergy);
      TObject::ShowMembers(R__insp);
}

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 ((::TTofTrack*)p);
   }
   static void deleteArray_TTofTrack(void *p) {
      delete [] ((::TTofTrack*)p);
   }
   static void destruct_TTofTrack(void *p) {
      typedef ::TTofTrack current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TTofTrack

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TMucTrack::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMucTrack.
      TClass *R__cl = ::TMucTrack::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_id", &m_id);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_status", &m_status);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_type", &m_type);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_startPart", &m_startPart);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_endPart", &m_endPart);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_brLastLayer", &m_brLastLayer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ecLastLayer", &m_ecLastLayer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_numHits", &m_numHits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_numLayers", &m_numLayers);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_maxHitsInLayer", &m_maxHitsInLayer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_depth", &m_depth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chi2", &m_chi2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dof", &m_dof);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_rms", &m_rms);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_xPos", &m_xPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_yPos", &m_yPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zPos", &m_zPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_xPosSigma", &m_xPosSigma);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_yPosSigma", &m_yPosSigma);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zPosSigma", &m_zPosSigma);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_px", &m_px);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_py", &m_py);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pz", &m_pz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_distance", &m_distance);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_deltaPhi", &m_deltaPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kalrechi2", &m_kalrechi2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kaldof", &m_kaldof);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kaldepth", &m_kaldepth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kalbrLastLayer", &m_kalbrLastLayer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kalecLastLayer", &m_kalecLastLayer);
      TObject::ShowMembers(R__insp);
}

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 ((::TMucTrack*)p);
   }
   static void deleteArray_TMucTrack(void *p) {
      delete [] ((::TMucTrack*)p);
   }
   static void destruct_TMucTrack(void *p) {
      typedef ::TMucTrack current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMucTrack

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TMdcDedx::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMdcDedx.
      TClass *R__cl = ::TMdcDedx::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_particleId", &m_particleId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_status", &m_status);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trunc_alg", &m_trunc_alg);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chiE", &m_chiE);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chiMu", &m_chiMu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chiPi", &m_chiPi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chiK", &m_chiK);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chiP", &m_chiP);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_numGoodHits", &m_numGoodHits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_numTotalHits", &m_numTotalHits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_probPH", &m_probPH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_normPH", &m_normPH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_errorPH", &m_errorPH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_twentyPH", &m_twentyPH);
      TObject::ShowMembers(R__insp);
}

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 ((::TMdcDedx*)p);
   }
   static void deleteArray_TMdcDedx(void *p) {
      delete [] ((::TMdcDedx*)p);
   }
   static void destruct_TMdcDedx(void *p) {
      typedef ::TMdcDedx current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMdcDedx

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TExtTrack::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TExtTrack.
      TClass *R__cl = ::TExtTrack::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PositionX", &myTof1PositionX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PositionY", &myTof1PositionY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PositionZ", &myTof1PositionZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1MomentumX", &myTof1MomentumX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1MomentumY", &myTof1MomentumY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1MomentumZ", &myTof1MomentumZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1VolumeName", &myTof1VolumeName);
      R__insp.InspectMember(myTof1VolumeName, "myTof1VolumeName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1VolumeNumber", &myTof1VolumeNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1", &myTof1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1Path", &myTof1Path);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PosSigmaAlongZ", &myTof1PosSigmaAlongZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PosSigmaAlongT", &myTof1PosSigmaAlongT);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PosSigmaAlongX", &myTof1PosSigmaAlongX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PosSigmaAlongY", &myTof1PosSigmaAlongY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1ErrorMatrix[21]", myTof1ErrorMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PositionX", &myTof2PositionX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PositionY", &myTof2PositionY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PositionZ", &myTof2PositionZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2MomentumX", &myTof2MomentumX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2MomentumY", &myTof2MomentumY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2MomentumZ", &myTof2MomentumZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2VolumeName", &myTof2VolumeName);
      R__insp.InspectMember(myTof2VolumeName, "myTof2VolumeName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2VolumeNumber", &myTof2VolumeNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2", &myTof2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2Path", &myTof2Path);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PosSigmaAlongZ", &myTof2PosSigmaAlongZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PosSigmaAlongT", &myTof2PosSigmaAlongT);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PosSigmaAlongX", &myTof2PosSigmaAlongX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PosSigmaAlongY", &myTof2PosSigmaAlongY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2ErrorMatrix[21]", myTof2ErrorMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPositionX", &myEmcPositionX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPositionY", &myEmcPositionY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPositionZ", &myEmcPositionZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcMomentumX", &myEmcMomentumX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcMomentumY", &myEmcMomentumY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcMomentumZ", &myEmcMomentumZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcVolumeName", &myEmcVolumeName);
      R__insp.InspectMember(myEmcVolumeName, "myEmcVolumeName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcVolumeNumber", &myEmcVolumeNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPosSigmaAlongTheta", &myEmcPosSigmaAlongTheta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPosSigmaAlongPhi", &myEmcPosSigmaAlongPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcErrorMatrix[21]", myEmcErrorMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPath", &myEmcPath);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPositionX", &myMucPositionX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPositionY", &myMucPositionY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPositionZ", &myMucPositionZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucMomentumX", &myMucMomentumX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucMomentumY", &myMucMomentumY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucMomentumZ", &myMucMomentumZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucVolumeName", &myMucVolumeName);
      R__insp.InspectMember(myMucVolumeName, "myMucVolumeName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucVolumeNumber", &myMucVolumeNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPosSigmaAlongZ", &myMucPosSigmaAlongZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPosSigmaAlongT", &myMucPosSigmaAlongT);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPosSigmaAlongX", &myMucPosSigmaAlongX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPosSigmaAlongY", &myMucPosSigmaAlongY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucErrorMatrix[21]", myMucErrorMatrix);
      TObject::ShowMembers(R__insp);
}

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 ((::TExtTrack*)p);
   }
   static void deleteArray_TExtTrack(void *p) {
      delete [] ((::TExtTrack*)p);
   }
   static void destruct_TExtTrack(void *p) {
      typedef ::TExtTrack current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TExtTrack

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TMdcKalTrack::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMdcKalTrack.
      TClass *R__cl = ::TMdcKalTrack::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_stat[5]", m_stat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_stat2[5]", m_stat2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chisq[5]", m_chisq);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ndf[5]", m_ndf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nlayer[5]", m_nlayer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhelix[5]", m_zhelix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zerror[15]", m_zerror);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhelix_e[5]", m_zhelix_e);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zerror_e[15]", m_zerror_e);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhelix_mu[5]", m_zhelix_mu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zerror_mu[15]", m_zerror_mu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhelix_k[5]", m_zhelix_k);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zerror_k[15]", m_zerror_k);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhelix_p[5]", m_zhelix_p);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zerror_p[15]", m_zerror_p);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fhelix[5]", m_fhelix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ferror[15]", m_ferror);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fhelix_e[5]", m_fhelix_e);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ferror_e[15]", m_ferror_e);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fhelix_mu[5]", m_fhelix_mu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ferror_mu[15]", m_ferror_mu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fhelix_k[5]", m_fhelix_k);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ferror_k[15]", m_ferror_k);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fhelix_p[5]", m_fhelix_p);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ferror_p[15]", m_ferror_p);
      TObject::ShowMembers(R__insp);
}

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 ((::TMdcKalTrack*)p);
   }
   static void deleteArray_TMdcKalTrack(void *p) {
      delete [] ((::TMdcKalTrack*)p);
   }
   static void destruct_TMdcKalTrack(void *p) {
      typedef ::TMdcKalTrack current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMdcKalTrack

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TMcEvent::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMcEvent.
      TClass *R__cl = ::TMcEvent::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_mdcMcHitCol", &m_mdcMcHitCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_emcMcHitCol", &m_emcMcHitCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_tofMcHitCol", &m_tofMcHitCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_mucMcHitCol", &m_mucMcHitCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_mcParticleCol", &m_mcParticleCol);
      TObject::ShowMembers(R__insp);
}

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 ((::TMcEvent*)p);
   }
   static void deleteArray_TMcEvent(void *p) {
      delete [] ((::TMcEvent*)p);
   }
   static void destruct_TMcEvent(void *p) {
      typedef ::TMcEvent current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMcEvent

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TMdcMc::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMdcMc.
      TClass *R__cl = ::TMdcMc::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_id", &m_id);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackIndex", &m_trackIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_xPosition", &m_xPosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_yPosition", &m_yPosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zPosition", &m_zPosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_driftDistance", &m_driftDistance);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_depositEnergy", &m_depositEnergy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_posFlag", &m_posFlag);
      TObject::ShowMembers(R__insp);
}

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 ((::TMdcMc*)p);
   }
   static void deleteArray_TMdcMc(void *p) {
      delete [] ((::TMdcMc*)p);
   }
   static void destruct_TMdcMc(void *p) {
      typedef ::TMdcMc current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMdcMc

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TEmcMc::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEmcMc.
      TClass *R__cl = ::TEmcMc::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hitEmc", &m_hitEmc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_PDGCode", &m_PDGCode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_PDGCharge", &m_PDGCharge);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_time", &m_time);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_id", &m_id);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackIndex", &m_trackIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_xPosition", &m_xPosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_yPosition", &m_yPosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zPosition", &m_zPosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_px", &m_px);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_py", &m_py);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pz", &m_pz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_depositEnergy", &m_depositEnergy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hitMap", (void*)&m_hitMap);
      R__insp.InspectMember("map<Int_t,Double_t>", (void*)&m_hitMap, "m_hitMap.", false);
      TObject::ShowMembers(R__insp);
}

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 ((::TEmcMc*)p);
   }
   static void deleteArray_TEmcMc(void *p) {
      delete [] ((::TEmcMc*)p);
   }
   static void destruct_TEmcMc(void *p) {
      typedef ::TEmcMc current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEmcMc

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TTofMc::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TTofMc.
      TClass *R__cl = ::TTofMc::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_id", &m_id);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackIndex", &m_trackIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_xPosition", &m_xPosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_yPosition", &m_yPosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zPosition", &m_zPosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_px", &m_px);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_py", &m_py);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pz", &m_pz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackLength", &m_trackLength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_flightTime", &m_flightTime);
      TObject::ShowMembers(R__insp);
}

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 ((::TTofMc*)p);
   }
   static void deleteArray_TTofMc(void *p) {
      delete [] ((::TTofMc*)p);
   }
   static void destruct_TTofMc(void *p) {
      typedef ::TTofMc current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TTofMc

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TMucMc::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMucMc.
      TClass *R__cl = ::TMucMc::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_id", &m_id);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackIndex", &m_trackIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_xPosition", &m_xPosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_yPosition", &m_yPosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zPosition", &m_zPosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_px", &m_px);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_py", &m_py);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pz", &m_pz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_depositEnergy", &m_depositEnergy);
      TObject::ShowMembers(R__insp);
}

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 ((::TMucMc*)p);
   }
   static void deleteArray_TMucMc(void *p) {
      delete [] ((::TMucMc*)p);
   }
   static void destruct_TMucMc(void *p) {
      typedef ::TMucMc current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMucMc

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TMcParticle::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMcParticle.
      TClass *R__cl = ::TMcParticle::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_particleID", &m_particleID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackIndex", &m_trackIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vertexIndex0", &m_vertexIndex0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vertexIndex1", &m_vertexIndex1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_statusFlags", &m_statusFlags);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_xInitialPosition", &m_xInitialPosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_yInitialPosition", &m_yInitialPosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zInitialPosition", &m_zInitialPosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tInitialPosition", &m_tInitialPosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_xFinalPosition", &m_xFinalPosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_yFinalPosition", &m_yFinalPosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zFinalPosition", &m_zFinalPosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tFinalPosition", &m_tFinalPosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_xInitialMomentum", &m_xInitialMomentum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_yInitialMomentum", &m_yInitialMomentum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zInitialMomentum", &m_zInitialMomentum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_eInitialMomentum", &m_eInitialMomentum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mother", &m_mother);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_daughters", (void*)&m_daughters);
      R__insp.InspectMember("vector<Int_t>", (void*)&m_daughters, "m_daughters.", false);
      TObject::ShowMembers(R__insp);
}

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 ((::TMcParticle*)p);
   }
   static void deleteArray_TMcParticle(void *p) {
      delete [] ((::TMcParticle*)p);
   }
   static void destruct_TMcParticle(void *p) {
      typedef ::TMcParticle current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMcParticle

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TRecMdcHit::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TRecMdcHit.
      TClass *R__cl = ::TRecMdcHit::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_isGrouped", &m_isGrouped);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_id", &m_id);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trkid", &m_trkid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ddl", &m_ddl);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ddr", &m_ddr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_erddl", &m_erddl);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_erddr", &m_erddr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pChisq", &m_pChisq);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lr", &m_lr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_stat", &m_stat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcid", &m_mdcid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tdc", &m_tdc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_adc", &m_adc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_driftT", &m_driftT);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_doca", &m_doca);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_entra", &m_entra);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhit", &m_zhit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fltLen", &m_fltLen);
      TObject::ShowMembers(R__insp);
}

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 ((::TRecMdcHit*)p);
   }
   static void deleteArray_TRecMdcHit(void *p) {
      delete [] ((::TRecMdcHit*)p);
   }
   static void destruct_TRecMdcHit(void *p) {
      typedef ::TRecMdcHit current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TRecMdcHit

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TRecMdcTrack::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TRecMdcTrack.
      TClass *R__cl = ::TRecMdcTrack::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_helix[5]", m_helix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_stat", &m_stat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chi2", &m_chi2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ndof", &m_ndof);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_err[15]", m_err);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nhits", &m_nhits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nster", &m_nster);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nlayer", &m_nlayer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vx0", &m_vx0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vy0", &m_vy0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vz0", &m_vz0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fiTerm", &m_fiTerm);
      TObject::ShowMembers(R__insp);
}

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 ((::TRecMdcTrack*)p);
   }
   static void deleteArray_TRecMdcTrack(void *p) {
      delete [] ((::TRecMdcTrack*)p);
   }
   static void destruct_TRecMdcTrack(void *p) {
      typedef ::TRecMdcTrack current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TRecMdcTrack

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TRecMdcKalTrack::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TRecMdcKalTrack.
      TClass *R__cl = ::TRecMdcKalTrack::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mass[5]", m_mass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_length[5]", m_length);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tof[5]", m_tof);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fiTerm[5]", m_fiTerm);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pathSM[5]", m_pathSM);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nhits[5]", m_nhits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nlayer[5]", m_nlayer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_stat[2][5]", m_stat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chisq[2][5]", m_chisq);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ndf[2][5]", m_ndf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nSegs[5]", m_nSegs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_poca[3]", m_poca);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_poca_e[3]", m_poca_e);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_poca_mu[3]", m_poca_mu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_poca_k[3]", m_poca_k);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_poca_p[3]", m_poca_p);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lpoint[3]", m_lpoint);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lpoint_e[3]", m_lpoint_e);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lpoint_mu[3]", m_lpoint_mu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lpoint_k[3]", m_lpoint_k);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lpoint_p[3]", m_lpoint_p);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lpivot[3]", m_lpivot);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lpivot_e[3]", m_lpivot_e);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lpivot_mu[3]", m_lpivot_mu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lpivot_k[3]", m_lpivot_k);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lpivot_p[3]", m_lpivot_p);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhelix[5]", m_zhelix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zerror[5][5]", m_zerror);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhelix_e[5]", m_zhelix_e);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zerror_e[5][5]", m_zerror_e);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhelix_mu[5]", m_zhelix_mu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zerror_mu[5][5]", m_zerror_mu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhelix_k[5]", m_zhelix_k);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zerror_k[5][5]", m_zerror_k);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhelix_p[5]", m_zhelix_p);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zerror_p[5][5]", m_zerror_p);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fhelix[5]", m_fhelix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ferror[5][5]", m_ferror);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fhelix_e[5]", m_fhelix_e);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ferror_e[5][5]", m_ferror_e);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fhelix_mu[5]", m_fhelix_mu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ferror_mu[5][5]", m_ferror_mu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fhelix_k[5]", m_fhelix_k);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ferror_k[5][5]", m_ferror_k);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fhelix_p[5]", m_fhelix_p);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ferror_p[5][5]", m_ferror_p);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lhelix[5]", m_lhelix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lerror[5][5]", m_lerror);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lhelix_e[5]", m_lhelix_e);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lerror_e[5][5]", m_lerror_e);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lhelix_mu[5]", m_lhelix_mu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lerror_mu[5][5]", m_lerror_mu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lhelix_k[5]", m_lhelix_k);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lerror_k[5][5]", m_lerror_k);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lhelix_p[5]", m_lhelix_p);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lerror_p[5][5]", m_lerror_p);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_thelix[5]", m_thelix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_terror[15]", m_terror);
      TObject::ShowMembers(R__insp);
}

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 ((::TRecMdcKalTrack*)p);
   }
   static void deleteArray_TRecMdcKalTrack(void *p) {
      delete [] ((::TRecMdcKalTrack*)p);
   }
   static void destruct_TRecMdcKalTrack(void *p) {
      typedef ::TRecMdcKalTrack current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TRecMdcKalTrack

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TRecMdcKalHelixSeg::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TRecMdcKalHelixSeg.
      TClass *R__cl = ::TRecMdcKalHelixSeg::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackid", &m_trackid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lr", &m_lr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcid", &m_mdcid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tdc", &m_tdc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_adc", &m_adc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zhit", &m_zhit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tof", &m_tof);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_docaincl", &m_docaincl);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_docaexcl", &m_docaexcl);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dd", &m_dd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_entra", &m_entra);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_driftT", &m_driftT);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_helixincl[5]", m_helixincl);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_helixexcl[5]", m_helixexcl);
      TObject::ShowMembers(R__insp);
}

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 ((::TRecMdcKalHelixSeg*)p);
   }
   static void deleteArray_TRecMdcKalHelixSeg(void *p) {
      delete [] ((::TRecMdcKalHelixSeg*)p);
   }
   static void destruct_TRecMdcKalHelixSeg(void *p) {
      typedef ::TRecMdcKalHelixSeg current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TRecMdcKalHelixSeg

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TRecTofTrack::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TRecTofTrack.
      TClass *R__cl = ::TRecTofTrack::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tofTrackID", &m_tofTrackID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackID", &m_trackID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tofID", &m_tofID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_status", &m_status);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_path", &m_path);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zrhit", &m_zrhit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ph", &m_ph);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tof", &m_tof);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_beta", &m_beta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_texp[5]", m_texp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_toffset[6]", m_toffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_sigma[6]", m_sigma);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_quality", &m_quality);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_t0", &m_t0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_errt0", &m_errt0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_errz", &m_errz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_phi", &m_phi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_errphi", &m_errphi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_energy", &m_energy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_errenergy", &m_errenergy);
      TObject::ShowMembers(R__insp);
}

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 ((::TRecTofTrack*)p);
   }
   static void deleteArray_TRecTofTrack(void *p) {
      delete [] ((::TRecTofTrack*)p);
   }
   static void destruct_TRecTofTrack(void *p) {
      typedef ::TRecTofTrack current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TRecTofTrack

//______________________________________________________________________________
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);
   }
}

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

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 ((::TRecEmcHit*)p);
   }
   static void deleteArray_TRecEmcHit(void *p) {
      delete [] ((::TRecEmcHit*)p);
   }
   static void destruct_TRecEmcHit(void *p) {
      typedef ::TRecEmcHit current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TRecEmcHit

//______________________________________________________________________________
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);
   }
}

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

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 ((::TRecEmcCluster*)p);
   }
   static void deleteArray_TRecEmcCluster(void *p) {
      delete [] ((::TRecEmcCluster*)p);
   }
   static void destruct_TRecEmcCluster(void *p) {
      typedef ::TRecEmcCluster current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TRecEmcCluster

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TRecEmcShower::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TRecEmcShower.
      TClass *R__cl = ::TRecEmcShower::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_numHits", &m_numHits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_status", &m_status);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_cellId", &m_cellId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_module", &m_module);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_x", &m_x);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_y", &m_y);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_z", &m_z);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_theta", &m_theta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dTheta", &m_dTheta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_phi", &m_phi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dPhi", &m_dPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_energy", &m_energy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dE", &m_dE);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_eSeed", &m_eSeed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_e3x3", &m_e3x3);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_e5x5", &m_e5x5);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_eall", &m_eall);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_elepton", &m_elepton);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_time", &m_time);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_secondMoment", &m_secondMoment);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_latMoment", &m_latMoment);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_a20Moment", &m_a20Moment);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_a42Moment", &m_a42Moment);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_err[6]", m_err);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_cellIdMap", (void*)&m_cellIdMap);
      R__insp.InspectMember("map<Int_t,Double_t>", (void*)&m_cellIdMap, "m_cellIdMap.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_cellId3x3", (void*)&m_cellId3x3);
      R__insp.InspectMember("vector<Int_t>", (void*)&m_cellId3x3, "m_cellId3x3.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_cellId5x5", (void*)&m_cellId5x5);
      R__insp.InspectMember("vector<Int_t>", (void*)&m_cellId5x5, "m_cellId5x5.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_clusterId", &m_clusterId);
      TObject::ShowMembers(R__insp);
}

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 ((::TRecEmcShower*)p);
   }
   static void deleteArray_TRecEmcShower(void *p) {
      delete [] ((::TRecEmcShower*)p);
   }
   static void destruct_TRecEmcShower(void *p) {
      typedef ::TRecEmcShower current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TRecEmcShower

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TRecMucTrack::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TRecMucTrack.
      TClass *R__cl = ::TRecMucTrack::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_id", &m_id);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_status", &m_status);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_type", &m_type);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_startPart", &m_startPart);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_endPart", &m_endPart);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_brLastLayer", &m_brLastLayer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ecLastLayer", &m_ecLastLayer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_numHits", &m_numHits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_numLayers", &m_numLayers);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_maxHitsInLayer", &m_maxHitsInLayer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_depth", &m_depth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chi2", &m_chi2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dof", &m_dof);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_rms", &m_rms);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_xPos", &m_xPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_yPos", &m_yPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zPos", &m_zPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_xPosSigma", &m_xPosSigma);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_yPosSigma", &m_yPosSigma);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_zPosSigma", &m_zPosSigma);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_px", &m_px);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_py", &m_py);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pz", &m_pz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_distance", &m_distance);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_deltaPhi", &m_deltaPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vecHits", (void*)&m_vecHits);
      R__insp.InspectMember("vector<Int_t>", (void*)&m_vecHits, "m_vecHits.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_expHits", (void*)&m_expHits);
      R__insp.InspectMember("vector<Int_t>", (void*)&m_expHits, "m_expHits.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_distHits", (void*)&m_distHits);
      R__insp.InspectMember("vector<Float_t>", (void*)&m_distHits, "m_distHits.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kalrechi2", &m_kalrechi2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kaldof", &m_kaldof);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kaldepth", &m_kaldepth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kalbrLastLayer", &m_kalbrLastLayer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kalecLastLayer", &m_kalecLastLayer);
      TObject::ShowMembers(R__insp);
}

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 ((::TRecMucTrack*)p);
   }
   static void deleteArray_TRecMucTrack(void *p) {
      delete [] ((::TRecMucTrack*)p);
   }
   static void destruct_TRecMucTrack(void *p) {
      typedef ::TRecMucTrack current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TRecMucTrack

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TRecTrackEvent::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TRecTrackEvent.
      TClass *R__cl = ::TRecTrackEvent::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recMdcTrackCol", &m_recMdcTrackCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recMdcHitCol", &m_recMdcHitCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recEmcHitCol", &m_recEmcHitCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recEmcClusterCol", &m_recEmcClusterCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recEmcShowerCol", &m_recEmcShowerCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recTofTrackCol", &m_recTofTrackCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recMucTrackCol", &m_recMucTrackCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recMdcDedxCol", &m_recMdcDedxCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recMdcDedxHitCol", &m_recMdcDedxHitCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recExtTrackCol", &m_recExtTrackCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recMdcKalTrackCol", &m_recMdcKalTrackCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recMdcKalHelixSegCol", &m_recMdcKalHelixSegCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recEvTimeCol", &m_recEvTimeCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recZddChannelCol", &m_recZddChannelCol);
      TObject::ShowMembers(R__insp);
}

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 ((::TRecTrackEvent*)p);
   }
   static void deleteArray_TRecTrackEvent(void *p) {
      delete [] ((::TRecTrackEvent*)p);
   }
   static void destruct_TRecTrackEvent(void *p) {
      typedef ::TRecTrackEvent current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TRecTrackEvent

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TRecMdcDedx::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TRecMdcDedx.
      TClass *R__cl = ::TRecMdcDedx::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dedx_hit", &m_dedx_hit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dedx_esat", &m_dedx_esat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dedx_norun", &m_dedx_norun);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dedx_momentum", &m_dedx_momentum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcTrackId", &m_mdcTrackId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcKalTrackId", &m_mdcKalTrackId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_particleId", &m_particleId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_status", &m_status);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trunc_alg", &m_trunc_alg);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chiE", &m_chiE);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chiMu", &m_chiMu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chiPi", &m_chiPi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chiK", &m_chiK);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chiP", &m_chiP);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_numGoodHits", &m_numGoodHits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_numTotalHits", &m_numTotalHits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_probPH", &m_probPH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_normPH", &m_normPH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_errorPH", &m_errorPH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_twentyPH", &m_twentyPH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chi[5]", m_chi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dedx_exp[5]", m_dedx_exp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_sigma_dedx[5]", m_sigma_dedx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pid_prob[5]", m_pid_prob);
      TObject::ShowMembers(R__insp);
}

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 ((::TRecMdcDedx*)p);
   }
   static void deleteArray_TRecMdcDedx(void *p) {
      delete [] ((::TRecMdcDedx*)p);
   }
   static void destruct_TRecMdcDedx(void *p) {
      typedef ::TRecMdcDedx current_t;
      ((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);
   }
}

//______________________________________________________________________________
void TRecMdcDedxHit::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TRecMdcDedxHit.
      TClass *R__cl = ::TRecMdcDedxHit::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_isGrouped", &m_isGrouped);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trkid", &m_trkid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcHitId", &m_mdcHitId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcKalHelixSegId", &m_mdcKalHelixSegId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_lr", &m_lr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcid", &m_mdcid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pathlength", &m_pathlength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_dedx", &m_dedx);
      TObject::ShowMembers(R__insp);
}

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 ((::TRecMdcDedxHit*)p);
   }
   static void deleteArray_TRecMdcDedxHit(void *p) {
      delete [] ((::TRecMdcDedxHit*)p);
   }
   static void destruct_TRecMdcDedxHit(void *p) {
      typedef ::TRecMdcDedxHit current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TRecMdcDedxHit

//______________________________________________________________________________
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);
   }
}

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

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 ((::TRecEvTime*)p);
   }
   static void deleteArray_TRecEvTime(void *p) {
      delete [] ((::TRecEvTime*)p);
   }
   static void destruct_TRecEvTime(void *p) {
      typedef ::TRecEvTime current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TRecEvTime

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TEvtHeader::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEvtHeader.
      TClass *R__cl = ::TEvtHeader::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_eventId", &m_eventId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_runId", &m_runId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_time", &m_time);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_eventTag", &m_eventTag);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_flag1", &m_flag1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_flag2", &m_flag2);
      TObject::ShowMembers(R__insp);
}

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 ((::TEvtHeader*)p);
   }
   static void deleteArray_TEvtHeader(void *p) {
      delete [] ((::TEvtHeader*)p);
   }
   static void destruct_TEvtHeader(void *p) {
      typedef ::TEvtHeader current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvtHeader

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TEvtNavigator::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEvtNavigator.
      TClass *R__cl = ::TEvtNavigator::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mcMdcMcHits", (void*)&m_mcMdcMcHits);
      R__insp.InspectMember("multimap<int,int>", (void*)&m_mcMdcMcHits, "m_mcMdcMcHits.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mcMdcTracks", (void*)&m_mcMdcTracks);
      R__insp.InspectMember("multimap<int,int>", (void*)&m_mcMdcTracks, "m_mcMdcTracks.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mcEmcMcHits", (void*)&m_mcEmcMcHits);
      R__insp.InspectMember("multimap<int,int>", (void*)&m_mcEmcMcHits, "m_mcEmcMcHits.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mcEmcRecShowers", (void*)&m_mcEmcRecShowers);
      R__insp.InspectMember("multimap<int,int>", (void*)&m_mcEmcRecShowers, "m_mcEmcRecShowers.", false);
      TObject::ShowMembers(R__insp);
}

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 ((::TEvtNavigator*)p);
   }
   static void deleteArray_TEvtNavigator(void *p) {
      delete [] ((::TEvtNavigator*)p);
   }
   static void destruct_TEvtNavigator(void *p) {
      typedef ::TEvtNavigator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvtNavigator

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TRecExtTrack::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TRecExtTrack.
      TClass *R__cl = ::TRecExtTrack::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PositionX[5]", myTof1PositionX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PositionY[5]", myTof1PositionY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PositionZ[5]", myTof1PositionZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1MomentumX[5]", myTof1MomentumX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1MomentumY[5]", myTof1MomentumY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1MomentumZ[5]", myTof1MomentumZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1VolumeName[5]", myTof1VolumeName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1VolumeNumber[5]", myTof1VolumeNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1[5]", myTof1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1Path[5]", myTof1Path);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PosSigmaAlongZ[5]", myTof1PosSigmaAlongZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PosSigmaAlongT[5]", myTof1PosSigmaAlongT);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PosSigmaAlongX[5]", myTof1PosSigmaAlongX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1PosSigmaAlongY[5]", myTof1PosSigmaAlongY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof1ErrorMatrix[5][6][6]", myTof1ErrorMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PositionX[5]", myTof2PositionX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PositionY[5]", myTof2PositionY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PositionZ[5]", myTof2PositionZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2MomentumX[5]", myTof2MomentumX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2MomentumY[5]", myTof2MomentumY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2MomentumZ[5]", myTof2MomentumZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2VolumeName[5]", myTof2VolumeName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2VolumeNumber[5]", myTof2VolumeNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2[5]", myTof2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2Path[5]", myTof2Path);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PosSigmaAlongZ[5]", myTof2PosSigmaAlongZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PosSigmaAlongT[5]", myTof2PosSigmaAlongT);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PosSigmaAlongX[5]", myTof2PosSigmaAlongX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2PosSigmaAlongY[5]", myTof2PosSigmaAlongY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myTof2ErrorMatrix[5][6][6]", myTof2ErrorMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPositionX[5]", myEmcPositionX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPositionY[5]", myEmcPositionY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPositionZ[5]", myEmcPositionZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcMomentumX[5]", myEmcMomentumX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcMomentumY[5]", myEmcMomentumY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcMomentumZ[5]", myEmcMomentumZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcVolumeName[5]", myEmcVolumeName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcVolumeNumber[5]", myEmcVolumeNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPosSigmaAlongTheta[5]", myEmcPosSigmaAlongTheta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPosSigmaAlongPhi[5]", myEmcPosSigmaAlongPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcErrorMatrix[5][6][6]", myEmcErrorMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myEmcPath[5]", myEmcPath);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPositionX[5]", myMucPositionX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPositionY[5]", myMucPositionY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPositionZ[5]", myMucPositionZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucMomentumX[5]", myMucMomentumX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucMomentumY[5]", myMucMomentumY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucMomentumZ[5]", myMucMomentumZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucVolumeName[5]", myMucVolumeName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucVolumeNumber[5]", myMucVolumeNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPosSigmaAlongZ[5]", myMucPosSigmaAlongZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPosSigmaAlongT[5]", myMucPosSigmaAlongT);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPosSigmaAlongX[5]", myMucPosSigmaAlongX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucPosSigmaAlongY[5]", myMucPosSigmaAlongY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMucErrorMatrix[5][6][6]", myMucErrorMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "mySize[5]", mySize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myPositionX[5]", myPositionX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myPositionY[5]", myPositionY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myPositionZ[5]", myPositionZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMomentumX[5]", myMomentumX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMomentumY[5]", myMomentumY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myMomentumZ[5]", myMomentumZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myVolumeName[5]", myVolumeName);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myVolumeNumber[5]", myVolumeNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myPosSigmaAlongZ[5]", myPosSigmaAlongZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myPosSigmaAlongT[5]", myPosSigmaAlongT);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myPosSigmaAlongX[5]", myPosSigmaAlongX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myPosSigmaAlongY[5]", myPosSigmaAlongY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "myErrorMatrix[5]", myErrorMatrix);
      TObject::ShowMembers(R__insp);
}

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 ((::TRecExtTrack*)p);
   }
   static void deleteArray_TRecExtTrack(void *p) {
      delete [] ((::TRecExtTrack*)p);
   }
   static void destruct_TRecExtTrack(void *p) {
      typedef ::TRecExtTrack current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TRecExtTrack

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TRecZddChannel::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TRecZddChannel.
      TClass *R__cl = ::TRecZddChannel::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chId", &m_chId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_scanCode", &m_scanCode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_baseLine", &m_baseLine);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_phase", &m_phase);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_frags", (void*)&m_frags);
      R__insp.InspectMember("vector<std::pair<Int_t,Float_t> >", (void*)&m_frags, "m_frags.", false);
      TObject::ShowMembers(R__insp);
}

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 ((::TRecZddChannel*)p);
   }
   static void deleteArray_TRecZddChannel(void *p) {
      delete [] ((::TRecZddChannel*)p);
   }
   static void destruct_TRecZddChannel(void *p) {
      typedef ::TRecZddChannel current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TRecZddChannel

//______________________________________________________________________________
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);
   }
}

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

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 ((::TTrigEvent*)p);
   }
   static void deleteArray_TTrigEvent(void *p) {
      delete [] ((::TTrigEvent*)p);
   }
   static void destruct_TTrigEvent(void *p) {
      typedef ::TTrigEvent current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TTrigEvent

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TTrigData::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TTrigData.
      TClass *R__cl = ::TTrigData::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_preScale", &m_preScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trigcond[48]", m_trigcond);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trigChan[16]", m_trigChan);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_timeWindow", &m_timeWindow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_Timing", &m_Timing);
      TObject::ShowMembers(R__insp);
}

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 ((::TTrigData*)p);
   }
   static void deleteArray_TTrigData(void *p) {
      delete [] ((::TTrigData*)p);
   }
   static void destruct_TTrigData(void *p) {
      typedef ::TTrigData current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TTrigData

//______________________________________________________________________________
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);
   }
}

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

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 ((::THltEvent*)p);
   }
   static void deleteArray_THltEvent(void *p) {
      delete [] ((::THltEvent*)p);
   }
   static void destruct_THltEvent(void *p) {
      typedef ::THltEvent current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THltEvent

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void THltRaw::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class THltRaw.
      TClass *R__cl = ::THltRaw::IsA();
      if (R__cl || R__insp.IsA()) { }
      TRawData::ShowMembers(R__insp);
}

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 ((::THltRaw*)p);
   }
   static void deleteArray_THltRaw(void *p) {
      delete [] ((::THltRaw*)p);
   }
   static void destruct_THltRaw(void *p) {
      typedef ::THltRaw current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THltRaw

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void THltInf::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class THltInf.
      TClass *R__cl = ::THltInf::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_evtType", &m_evtType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_algProcess", &m_algProcess);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_criTable", &m_criTable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_verNumber", &m_verNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_eTotal", &m_eTotal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_subNumber", &m_subNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_conNumber", &m_conNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcData", (void*)&m_mdcData);
      R__insp.InspectMember("vector<Int_t>", (void*)&m_mdcData, "m_mdcData.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tofData", (void*)&m_tofData);
      R__insp.InspectMember("vector<Int_t>", (void*)&m_tofData, "m_tofData.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_emcData", (void*)&m_emcData);
      R__insp.InspectMember("vector<Int_t>", (void*)&m_emcData, "m_emcData.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mucData", (void*)&m_mucData);
      R__insp.InspectMember("vector<Int_t>", (void*)&m_mucData, "m_mucData.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_conData", (void*)&m_conData);
      R__insp.InspectMember("vector<Int_t>", (void*)&m_conData, "m_conData.", false);
      TObject::ShowMembers(R__insp);
}

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 ((::THltInf*)p);
   }
   static void deleteArray_THltInf(void *p) {
      delete [] ((::THltInf*)p);
   }
   static void destruct_THltInf(void *p) {
      typedef ::THltInf current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THltInf

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TDstHltInf::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TDstHltInf.
      TClass *R__cl = ::TDstHltInf::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_evtType", &m_evtType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_algProcess", &m_algProcess);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_criTable", &m_criTable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_verNumber", &m_verNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_eTotal", &m_eTotal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_subNumber", &m_subNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_conNumber", &m_conNumber);
      TObject::ShowMembers(R__insp);
}

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 ((::TDstHltInf*)p);
   }
   static void deleteArray_TDstHltInf(void *p) {
      delete [] ((::TDstHltInf*)p);
   }
   static void destruct_TDstHltInf(void *p) {
      typedef ::TDstHltInf current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TDstHltInf

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TDisTrack::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TDisTrack.
      TClass *R__cl = ::TDisTrack::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recMdcTrackCol", &m_recMdcTrackCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recTofTrackCol", &m_recTofTrackCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recMdcHitCol", &m_recMdcHitCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recMucTrackCol", &m_recMucTrackCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_recEmcShowerCol", &m_recEmcShowerCol);
      TObject::ShowMembers(R__insp);
}

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 ((::TDisTrack*)p);
   }
   static void deleteArray_TDisTrack(void *p) {
      delete [] ((::TDisTrack*)p);
   }
   static void destruct_TDisTrack(void *p) {
      typedef ::TDisTrack current_t;
      ((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 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);
   }
}

//______________________________________________________________________________
void TEvtRecObject::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEvtRecObject.
      TClass *R__cl = ::TEvtRecObject::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecEvent", &m_evtRecEvent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecTrackCol", &m_evtRecTrackCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecPrimaryVertex", &m_evtRecPrimaryVertex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecVeeVertexCol", &m_evtRecVeeVertexCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecPi0Col", &m_evtRecPi0Col);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecEtaToGGCol", &m_evtRecEtaToGGCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecDTagCol", &m_evtRecDTagCol);
      TObject::ShowMembers(R__insp);
}

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 ((::TEvtRecObject*)p);
   }
   static void deleteArray_TEvtRecObject(void *p) {
      delete [] ((::TEvtRecObject*)p);
   }
   static void destruct_TEvtRecObject(void *p) {
      typedef ::TEvtRecObject current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvtRecObject

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TEvtRecEvent::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEvtRecEvent.
      TClass *R__cl = ::TEvtRecEvent::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tottks", &m_tottks);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nchrg", &m_nchrg);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nneu", &m_nneu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nvee", &m_nvee);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_npi0", &m_npi0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_neta", &m_neta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ndtag", &m_ndtag);
      TObject::ShowMembers(R__insp);
}

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 ((::TEvtRecEvent*)p);
   }
   static void deleteArray_TEvtRecEvent(void *p) {
      delete [] ((::TEvtRecEvent*)p);
   }
   static void destruct_TEvtRecEvent(void *p) {
      typedef ::TEvtRecEvent current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvtRecEvent

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TEvtRecTrack::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEvtRecTrack.
      TClass *R__cl = ::TEvtRecTrack::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackId", &m_trackId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_partId", &m_partId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_quality", &m_quality);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcTrackId", &m_mdcTrackId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcKalTrackId", &m_mdcKalTrackId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mdcDedxId", &m_mdcDedxId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_extTrackId", &m_extTrackId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_emcShowerId", &m_emcShowerId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mucTrackId", &m_mucTrackId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tofTrackIds", (void*)&m_tofTrackIds);
      R__insp.InspectMember("vector<Int_t>", (void*)&m_tofTrackIds, "m_tofTrackIds.", false);
      TObject::ShowMembers(R__insp);
}

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 ((::TEvtRecTrack*)p);
   }
   static void deleteArray_TEvtRecTrack(void *p) {
      delete [] ((::TEvtRecTrack*)p);
   }
   static void destruct_TEvtRecTrack(void *p) {
      typedef ::TEvtRecTrack current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvtRecTrack

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TEvtRecPrimaryVertex::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEvtRecPrimaryVertex.
      TClass *R__cl = ::TEvtRecPrimaryVertex::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_isValid", &m_isValid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nTracks", &m_nTracks);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackIdList", (void*)&m_trackIdList);
      R__insp.InspectMember("vector<Int_t>", (void*)&m_trackIdList, "m_trackIdList.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chi2", &m_chi2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ndof", &m_ndof);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_fitMethod", &m_fitMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vtx[3]", m_vtx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_Evtx[6]", m_Evtx);
      TObject::ShowMembers(R__insp);
}

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 ((::TEvtRecPrimaryVertex*)p);
   }
   static void deleteArray_TEvtRecPrimaryVertex(void *p) {
      delete [] ((::TEvtRecPrimaryVertex*)p);
   }
   static void destruct_TEvtRecPrimaryVertex(void *p) {
      typedef ::TEvtRecPrimaryVertex current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvtRecPrimaryVertex

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TEvtRecVeeVertex::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEvtRecVeeVertex.
      TClass *R__cl = ::TEvtRecVeeVertex::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vertexId", &m_vertexId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_vertexType", &m_vertexType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chi2", &m_chi2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_ndof", &m_ndof);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mass", &m_mass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_w[7]", m_w);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_Ew[28]", m_Ew);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pair[2]", m_pair);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nCharge", &m_nCharge);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nTracks", &m_nTracks);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_daughter[2]", m_daughter);
      TObject::ShowMembers(R__insp);
}

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 ((::TEvtRecVeeVertex*)p);
   }
   static void deleteArray_TEvtRecVeeVertex(void *p) {
      delete [] ((::TEvtRecVeeVertex*)p);
   }
   static void destruct_TEvtRecVeeVertex(void *p) {
      typedef ::TEvtRecVeeVertex current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvtRecVeeVertex

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TEvtRecPi0::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEvtRecPi0.
      TClass *R__cl = ::TEvtRecPi0::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_unconMass", &m_unconMass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chisq", &m_chisq);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPx", &m_hiPx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPy", &m_hiPy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPz", &m_hiPz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPe", &m_hiPe);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPx", &m_loPx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPy", &m_loPy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPz", &m_loPz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPe", &m_loPe);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiEnGamma", &m_hiEnGamma);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loEnGamma", &m_loEnGamma);
      TObject::ShowMembers(R__insp);
}

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 ((::TEvtRecPi0*)p);
   }
   static void deleteArray_TEvtRecPi0(void *p) {
      delete [] ((::TEvtRecPi0*)p);
   }
   static void destruct_TEvtRecPi0(void *p) {
      typedef ::TEvtRecPi0 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvtRecPi0

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TEvtRecEtaToGG::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEvtRecEtaToGG.
      TClass *R__cl = ::TEvtRecEtaToGG::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_unconMass", &m_unconMass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_chisq", &m_chisq);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPx", &m_hiPx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPy", &m_hiPy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPz", &m_hiPz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiPe", &m_hiPe);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPx", &m_loPx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPy", &m_loPy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPz", &m_loPz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loPe", &m_loPe);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_hiEnGamma", &m_hiEnGamma);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_loEnGamma", &m_loEnGamma);
      TObject::ShowMembers(R__insp);
}

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 ((::TEvtRecEtaToGG*)p);
   }
   static void deleteArray_TEvtRecEtaToGG(void *p) {
      delete [] ((::TEvtRecEtaToGG*)p);
   }
   static void destruct_TEvtRecEtaToGG(void *p) {
      typedef ::TEvtRecEtaToGG current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvtRecEtaToGG

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TEvtRecDTag::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEvtRecDTag.
      TClass *R__cl = ::TEvtRecDTag::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_decayMode", &m_decayMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_type", &m_type);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_beamE", &m_beamE);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mass", &m_mass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mBC", &m_mBC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_deltaE", &m_deltaE);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_charge", &m_charge);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_charm", &m_charm);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_numOfChildren", &m_numOfChildren);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_px", &m_px);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_py", &m_py);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pz", &m_pz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pe", &m_pe);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_tracks", (void*)&m_tracks);
      R__insp.InspectMember("vector<Int_t>", (void*)&m_tracks, "m_tracks.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_showers", (void*)&m_showers);
      R__insp.InspectMember("vector<Int_t>", (void*)&m_showers, "m_showers.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_otherTracks", (void*)&m_otherTracks);
      R__insp.InspectMember("vector<Int_t>", (void*)&m_otherTracks, "m_otherTracks.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_otherShowers", (void*)&m_otherShowers);
      R__insp.InspectMember("vector<Int_t>", (void*)&m_otherShowers, "m_otherShowers.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pionId", (void*)&m_pionId);
      R__insp.InspectMember("vector<Int_t>", (void*)&m_pionId, "m_pionId.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_kaonId", (void*)&m_kaonId);
      R__insp.InspectMember("vector<Int_t>", (void*)&m_kaonId, "m_kaonId.", false);
      TObject::ShowMembers(R__insp);
}

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 ((::TEvtRecDTag*)p);
   }
   static void deleteArray_TEvtRecDTag(void *p) {
      delete [] ((::TEvtRecDTag*)p);
   }
   static void destruct_TEvtRecDTag(void *p) {
      typedef ::TEvtRecDTag current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvtRecDTag

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TMcHitEvent::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMcHitEvent.
      TClass *R__cl = ::TMcHitEvent::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_tTofMcHitCol", &m_tTofMcHitCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_tMdcMcHitCol", &m_tMdcMcHitCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_tEmcMcDigiCol", &m_tEmcMcDigiCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_beamTime", &m_beamTime);
      TObject::ShowMembers(R__insp);
}

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 ((::TMcHitEvent*)p);
   }
   static void deleteArray_TMcHitEvent(void *p) {
      delete [] ((::TMcHitEvent*)p);
   }
   static void destruct_TMcHitEvent(void *p) {
      typedef ::TMcHitEvent current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMcHitEvent

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TMcDigiEmc::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMcDigiEmc.
      TClass *R__cl = ::TMcDigiEmc::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_partId", &m_partId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nTheta", &m_nTheta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_nPhi", &m_nPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_energy", &m_energy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_time", &m_time);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackIndex", &m_trackIndex);
      TObject::ShowMembers(R__insp);
}

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 ((::TMcDigiEmc*)p);
   }
   static void deleteArray_TMcDigiEmc(void *p) {
      delete [] ((::TMcDigiEmc*)p);
   }
   static void destruct_TMcDigiEmc(void *p) {
      typedef ::TMcDigiEmc current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMcDigiEmc

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TMcHitTof::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMcHitTof.
      TClass *R__cl = ::TMcHitTof::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackIndex", &m_trackIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_g4Index", &m_g4Index);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_partId", &m_partId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_scinNb", &m_scinNb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_edep", &m_edep);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_stepL", &m_stepL);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_trackL", &m_trackL);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pos", &m_pos);
      R__insp.InspectMember(m_pos, "m_pos.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_time", &m_time);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_deltaT", &m_deltaT);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_pDirection", &m_pDirection);
      R__insp.InspectMember(m_pDirection, "m_pDirection.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_momentum", &m_momentum);
      R__insp.InspectMember(m_momentum, "m_momentum.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_charge", &m_charge);
      TObject::ShowMembers(R__insp);
}

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 ((::TMcHitTof*)p);
   }
   static void deleteArray_TMcHitTof(void *p) {
      delete [] ((::TMcHitTof*)p);
   }
   static void destruct_TMcHitTof(void *p) {
      typedef ::TMcHitTof current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMcHitTof

//______________________________________________________________________________
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);
   }
}

//______________________________________________________________________________
void TMcHitMdc::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMcHitMdc.
      TClass *R__cl = ::TMcHitMdc::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "trackID", &trackID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "layerNo", &layerNo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "cellNo", &cellNo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "edep", &edep);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "pos", &pos);
      R__insp.InspectMember(pos, "pos.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "driftD", &driftD);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "driftT", &driftT);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "globalT", &globalT);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "theta", &theta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "enterAngle", &enterAngle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "posFlag", &posFlag);
      TObject::ShowMembers(R__insp);
}

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 ((::TMcHitMdc*)p);
   }
   static void deleteArray_TMcHitMdc(void *p) {
      delete [] ((::TMcHitMdc*)p);
   }
   static void destruct_TMcHitMdc(void *p) {
      typedef ::TMcHitMdc current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMcHitMdc

//______________________________________________________________________________
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);
   }
}

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

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 ((::TJobInfo*)p);
   }
   static void deleteArray_TJobInfo(void *p) {
      delete [] ((::TJobInfo*)p);
   }
   static void destruct_TJobInfo(void *p) {
      typedef ::TJobInfo current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TJobInfo

//______________________________________________________________________________
void TBossFullEvent::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TBossFullEvent.
      TClass *R__cl = ::TBossFullEvent::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "m_mask", &m_mask);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_EvtHeader", &m_EvtHeader);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_digiEvt", &m_digiEvt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_dstEvt", &m_dstEvt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_mcEvt", &m_mcEvt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_trigEvt", &m_trigEvt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_hltEvt", &m_hltEvt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_rectrackEvt", &m_rectrackEvt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_evtRecObject", &m_evtRecObject);
      TObject::ShowMembers(R__insp);
}

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 ((::TBossFullEvent*)p);
   }
   static void deleteArray_TBossFullEvent(void *p) {
      delete [] ((::TBossFullEvent*)p);
   }
   static void destruct_TBossFullEvent(void *p) {
      typedef ::TBossFullEvent current_t;
      ((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

namespace ROOT {
   void maplEintcOdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void maplEintcOdoublegR_Dictionary();
   static void *new_maplEintcOdoublegR(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<int,double>),0);
      static ::ROOT::TGenericClassInfo 
         instance("map<int,double>", -2, "prec_stl/map", 63,
                  typeid(map<int,double>), DefineBehavior(ptr, ptr),
                  0, &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> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<int,double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_maplEintcOdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<int,double> : new map<int,double>;
   }
   static void *newArray_maplEintcOdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<int,double>[nElements] : new map<int,double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplEintcOdoublegR(void *p) {
      delete ((map<int,double>*)p);
   }
   static void deleteArray_maplEintcOdoublegR(void *p) {
      delete [] ((map<int,double>*)p);
   }
   static void destruct_maplEintcOdoublegR(void *p) {
      typedef map<int,double> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class map<int,double>

namespace ROOT {
   void multimaplEintcOintgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void multimaplEintcOintgR_Dictionary();
   static void *new_multimaplEintcOintgR(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(multimap<int,int>),0);
      static ::ROOT::TGenericClassInfo 
         instance("multimap<int,int>", -2, "prec_stl/multimap", 63,
                  typeid(multimap<int,int>), DefineBehavior(ptr, ptr),
                  0, &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> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const multimap<int,int>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_multimaplEintcOintgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) multimap<int,int> : new multimap<int,int>;
   }
   static void *newArray_multimaplEintcOintgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) multimap<int,int>[nElements] : new multimap<int,int>[nElements];
   }
   // Wrapper around operator delete
   static void delete_multimaplEintcOintgR(void *p) {
      delete ((multimap<int,int>*)p);
   }
   static void deleteArray_multimaplEintcOintgR(void *p) {
      delete [] ((multimap<int,int>*)p);
   }
   static void destruct_multimaplEintcOintgR(void *p) {
      typedef multimap<int,int> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class multimap<int,int>

namespace ROOT {
   void vectorlETStringgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlETStringgR_Dictionary();
   static void *new_vectorlETStringgR(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<TString>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<TString>", -2, "prec_stl/vector", 49,
                  typeid(vector<TString>), DefineBehavior(ptr, ptr),
                  0, &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> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<TString>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlETStringgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TString> : new vector<TString>;
   }
   static void *newArray_vectorlETStringgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TString>[nElements] : new vector<TString>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlETStringgR(void *p) {
      delete ((vector<TString>*)p);
   }
   static void deleteArray_vectorlETStringgR(void *p) {
      delete [] ((vector<TString>*)p);
   }
   static void destruct_vectorlETStringgR(void *p) {
      typedef vector<TString> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<TString>

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

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

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

} // end of namespace ROOT

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

namespace ROOT {
   void vectorlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEfloatgR_Dictionary();
   static void *new_vectorlEfloatgR(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<float>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<float>", -2, "vector.dll", 0,
                  typeid(vector<float>), DefineBehavior(ptr, ptr),
                  0, &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> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEfloatgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<float> : new vector<float>;
   }
   static void *newArray_vectorlEfloatgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<float>[nElements] : new vector<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEfloatgR(void *p) {
      delete ((vector<float>*)p);
   }
   static void deleteArray_vectorlEfloatgR(void *p) {
      delete [] ((vector<float>*)p);
   }
   static void destruct_vectorlEfloatgR(void *p) {
      typedef vector<float> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<float>

namespace ROOT {
   void vectorlEintgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEintgR_Dictionary();
   static void *new_vectorlEintgR(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<int>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<int>", -2, "prec_stl/vector", 49,
                  typeid(vector<int>), DefineBehavior(ptr, ptr),
                  0, &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> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<int>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEintgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<int> : new vector<int>;
   }
   static void *newArray_vectorlEintgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<int>[nElements] : new vector<int>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEintgR(void *p) {
      delete ((vector<int>*)p);
   }
   static void deleteArray_vectorlEintgR(void *p) {
      delete [] ((vector<int>*)p);
   }
   static void destruct_vectorlEintgR(void *p) {
      typedef vector<int> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<int>

namespace ROOT {
   void vectorlEpairlEintcOfloatgRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEpairlEintcOfloatgRsPgR_Dictionary();
   static void *new_vectorlEpairlEintcOfloatgRsPgR(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<pair<int,float> >),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<pair<int,float> >", -2, "prec_stl/vector", 49,
                  typeid(vector<pair<int,float> >), DefineBehavior(ptr, ptr),
                  0, &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> > >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<pair<int,float> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEpairlEintcOfloatgRsPgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<pair<int,float> > : new vector<pair<int,float> >;
   }
   static void *newArray_vectorlEpairlEintcOfloatgRsPgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<pair<int,float> >[nElements] : new vector<pair<int,float> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEpairlEintcOfloatgRsPgR(void *p) {
      delete ((vector<pair<int,float> >*)p);
   }
   static void deleteArray_vectorlEpairlEintcOfloatgRsPgR(void *p) {
      delete [] ((vector<pair<int,float> >*)p);
   }
   static void destruct_vectorlEpairlEintcOfloatgRsPgR(void *p) {
      typedef vector<pair<int,float> > current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<pair<int,float> >

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

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

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

} // end of namespace ROOT

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

namespace ROOT {
   void vectorlEvectorlEdoublegRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEvectorlEdoublegRsPgR_Dictionary();
   static void *new_vectorlEvectorlEdoublegRsPgR(void *p = 0);
   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 = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<vector<double> >),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<vector<double> >", -2, "prec_stl/vector", 49,
                  typeid(vector<vector<double> >), DefineBehavior(ptr, ptr),
                  0, &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> > >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<vector<double> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEvectorlEdoublegRsPgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<vector<double> > : new vector<vector<double> >;
   }
   static void *newArray_vectorlEvectorlEdoublegRsPgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<vector<double> >[nElements] : new vector<vector<double> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEvectorlEdoublegRsPgR(void *p) {
      delete ((vector<vector<double> >*)p);
   }
   static void deleteArray_vectorlEvectorlEdoublegRsPgR(void *p) {
      delete [] ((vector<vector<double> >*)p);
   }
   static void destruct_vectorlEvectorlEdoublegRsPgR(void *p) {
      typedef vector<vector<double> > current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<vector<double> >

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

#ifdef G__MEMTEST
#undef malloc
#undef free
#endif

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

extern "C" void G__cpp_reset_tagtableRootEventData_rootcint();

extern "C" void G__set_cpp_environmentRootEventData_rootcint() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("../RootEventData/TJobInfo.h");
  G__add_compiledheader("../RootEventData/TDigiEvent.h");
  G__add_compiledheader("../RootEventData/TRecTrackEvent.h");
  G__add_compiledheader("../RootEventData/TMdcDigi.h");
  G__add_compiledheader("../RootEventData/TEmcDigi.h");
  G__add_compiledheader("../RootEventData/TTofDigi.h");
  G__add_compiledheader("../RootEventData/TMucDigi.h");
  G__add_compiledheader("../RootEventData/TLumiDigi.h");
  G__add_compiledheader("../RootEventData/TDstEvent.h");
  G__add_compiledheader("../RootEventData/TEmcTrack.h");
  G__add_compiledheader("../RootEventData/TMdcTrack.h");
  G__add_compiledheader("../RootEventData/TRecMdcHit.h");
  G__add_compiledheader("../RootEventData/TRecMdcTrack.h");
  G__add_compiledheader("../RootEventData/TRecMucTrack.h");
  G__add_compiledheader("../RootEventData/TTofTrack.h");
  G__add_compiledheader("../RootEventData/TMucTrack.h");
  G__add_compiledheader("../RootEventData/TExtTrack.h");
  G__add_compiledheader("../RootEventData/TRecExtTrack.h");
  G__add_compiledheader("../RootEventData/TMdcKalTrack.h");
  G__add_compiledheader("../RootEventData/TRecMdcKalTrack.h");
  G__add_compiledheader("../RootEventData/TRecMdcKalHelixSeg.h");
  G__add_compiledheader("../RootEventData/TMdcDedx.h");
  G__add_compiledheader("../RootEventData/TRecMdcDedx.h");
  G__add_compiledheader("../RootEventData/TRecMdcDedxHit.h");
  G__add_compiledheader("../RootEventData/TMcEvent.h");
  G__add_compiledheader("../RootEventData/TEmcMc.h");
  G__add_compiledheader("../RootEventData/TMdcMc.h");
  G__add_compiledheader("../RootEventData/TTofMc.h");
  G__add_compiledheader("../RootEventData/TMucMc.h");
  G__add_compiledheader("../RootEventData/TMcParticle.h");
  G__add_compiledheader("../RootEventData/TRecEmcHit.h");
  G__add_compiledheader("../RootEventData/TRecEmcCluster.h");
  G__add_compiledheader("../RootEventData/TRecEmcShower.h");
  G__add_compiledheader("../RootEventData/TRecMucTrack.h");
  G__add_compiledheader("../RootEventData/TRecEvTime.h");
  G__add_compiledheader("../RootEventData/TRecZddChannel.h");
  G__add_compiledheader("../RootEventData/TEvtHeader.h");
  G__add_compiledheader("../RootEventData/TEvtNavigator.h");
  G__add_compiledheader("../RootEventData/TTrigEvent.h");
  G__add_compiledheader("../RootEventData/TTrigData.h");
  G__add_compiledheader("../RootEventData/THltEvent.h");
  G__add_compiledheader("../RootEventData/THltRaw.h");
  G__add_compiledheader("../RootEventData/THltInf.h");
  G__add_compiledheader("../RootEventData/TDstHltInf.h");
  G__add_compiledheader("../RootEventData/TDisTrack.h");
  G__add_compiledheader("../RootEventData/TEvtRecObject.h");
  G__add_compiledheader("../RootEventData/TEvtRecEvent.h");
  G__add_compiledheader("../RootEventData/TEvtRecTrack.h");
  G__add_compiledheader("../RootEventData/TMcHitEvent.h");
  G__add_compiledheader("../RootEventData/TMcHitTof.h");
  G__add_compiledheader("../RootEventData/TMcHitMdc.h");
  G__add_compiledheader("../RootEventData/TMcDigiEmc.h");
  G__add_compiledheader("../RootEventData/TEvtRecPrimaryVertex.h");
  G__add_compiledheader("../RootEventData/TEvtRecVeeVertex.h");
  G__add_compiledheader("../RootEventData/TEvtRecDTag.h");
  G__add_compiledheader("../RootEventData/TEvtRecPi0.h");
  G__add_compiledheader("../RootEventData/TBossFullEvent.h");
  G__cpp_reset_tagtableRootEventData_rootcint();
}
#include <new>
extern "C" int G__cpp_dllrevRootEventData_rootcint() { return(30051515); }

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

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

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

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

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

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

static int G__RootEventData_rootcint_168_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TJobInfo*) G__getstructoffset())->setBossVer(*((string*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_168_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TJobInfo*) G__getstructoffset())->addJobOptions(*((string*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_168_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TJobInfo*) G__getstructoffset())->setJobOptions(*((vector<string>*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_168_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TJobInfo*) G__getstructoffset())->setDecayOptions(*((string*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_168_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TJobInfo*) G__getstructoffset())->setTotEvtNo(*((vector<int>*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__RootEventData_rootcint_200_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TRawData*) G__getstructoffset())->initialize((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TRawData*) G__getstructoffset())->initialize((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRawData*) G__getstructoffset())->initialize((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_200_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRawData*) G__getstructoffset())->setTrackIndex((const int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__RootEventData_rootcint_201_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcDigi*) G__getstructoffset())->setOverflow((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__RootEventData_rootcint_202_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcDigi*) G__getstructoffset())->setMeasure((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__RootEventData_rootcint_203_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofDigi*) G__getstructoffset())->setOverflow((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__RootEventData_rootcint_205_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLumiDigi*) G__getstructoffset())->setOverflow((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__RootEventData_rootcint_206_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TDigiEvent*) G__getstructoffset())->initialize((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TDigiEvent*) G__getstructoffset())->initialize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_206_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TDigiEvent*) G__getstructoffset())->getFromMc());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_206_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getMdcDigiCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_206_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDigiEvent*) G__getstructoffset())->addMdcDigi((TMdcDigi*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_206_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getMdcDigi((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__RootEventData_rootcint_206_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getEmcDigiCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_206_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDigiEvent*) G__getstructoffset())->addEmcDigi((TEmcDigi*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_206_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getEmcDigi((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__RootEventData_rootcint_206_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getTofDigiCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_206_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDigiEvent*) G__getstructoffset())->addTofDigi((TTofDigi*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_206_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getTofDigi((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__RootEventData_rootcint_206_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getMucDigiCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_206_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDigiEvent*) G__getstructoffset())->addMucDigi((TMucDigi*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_206_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getMucDigi((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__RootEventData_rootcint_206_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getLumiDigiCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_206_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDigiEvent*) G__getstructoffset())->addLumiDigi((TLumiDigi*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_206_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDigiEvent*) G__getstructoffset())->getLumiDigi((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

static int G__RootEventData_rootcint_207_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->helix((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__RootEventData_rootcint_207_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->pxy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->px());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->py());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->pz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->p());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->theta());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__RootEventData_rootcint_207_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->x());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->y());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->z());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->r());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__RootEventData_rootcint_207_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->chi2());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__RootEventData_rootcint_207_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->err((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__RootEventData_rootcint_207_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->vx0());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->vy0());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->vz0());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcTrack*) G__getstructoffset())->fiTerm());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcTrack*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcTrack*) G__getstructoffset())->setHelix((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcTrack*) G__getstructoffset())->setStat((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcTrack*) G__getstructoffset())->setChi2((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcTrack*) G__getstructoffset())->setNdof((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcTrack*) G__getstructoffset())->setErr((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcTrack*) G__getstructoffset())->setNhits((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcTrack*) G__getstructoffset())->setNster((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcTrack*) G__getstructoffset())->setNlayer((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcTrack*) G__getstructoffset())->setVX0((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcTrack*) G__getstructoffset())->setVY0((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcTrack*) G__getstructoffset())->setVZ0((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcTrack*) G__getstructoffset())->setFiTerm((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_207_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcTrack*) G__getstructoffset())->setTRecMdcTrack((TRecMdcTrack*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

static int G__RootEventData_rootcint_208_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getMass((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLength((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getTof((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getfiTerm((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getPathSM((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TRecMdcKalTrack*) G__getstructoffset())->getNhits((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TRecMdcKalTrack*) G__getstructoffset())->getNlayer((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TRecMdcKalTrack*) G__getstructoffset())->getStat((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getChisq((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TRecMdcKalTrack*) G__getstructoffset())->getNdf((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TRecMdcKalTrack*) G__getstructoffset())->getNseg((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZHelix((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZError((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZHelixE((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZErrorE((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZHelixMu((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZErrorMu((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZHelixK((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZErrorK((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZHelixP((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getZErrorP((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFHelix((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFError((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFHelixE((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFErrorE((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFHelixMu((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFErrorMu((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFHelixK((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFErrorK((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFHelixP((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getFErrorP((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLHelix((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLError((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLHelixE((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLErrorE((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLHelixMu((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLErrorMu((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLHelixK((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLErrorK((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLHelixP((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLErrorP((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getTHelix((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getTError((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getPocaE((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getPocaMu((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getPoca((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getPocaK((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getPocaP((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPointE((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPointMu((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPoint((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPointK((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPointP((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPivotE((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPivotMu((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPivot((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPivotK((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalTrack*) G__getstructoffset())->getLPivotP((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setMass((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setLength((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setFiTerm((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setPathSM((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setTof((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setNhits((const Int_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setStat((const Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setChisq((const Double_t) G__double(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setNdf((const Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setNseg((const Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setNlayer((const Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setZHelix((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TRecMdcKalTrack*) G__getstructoffset())->setZError(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setZHelixE((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TRecMdcKalTrack*) G__getstructoffset())->setZErrorE(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setZHelixMu((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TRecMdcKalTrack*) G__getstructoffset())->setZErrorMu(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setZHelixK((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TRecMdcKalTrack*) G__getstructoffset())->setZErrorK(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setZHelixP((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TRecMdcKalTrack*) G__getstructoffset())->setZErrorP(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setFHelix((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TRecMdcKalTrack*) G__getstructoffset())->setFError(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setFHelixE((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TRecMdcKalTrack*) G__getstructoffset())->setFErrorE(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setFHelixMu((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TRecMdcKalTrack*) G__getstructoffset())->setFErrorMu(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setFHelixK((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TRecMdcKalTrack*) G__getstructoffset())->setFErrorK(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setFHelixP((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TRecMdcKalTrack*) G__getstructoffset())->setFErrorP(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setLHelix((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TRecMdcKalTrack*) G__getstructoffset())->setLError(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setLHelixE((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TRecMdcKalTrack*) G__getstructoffset())->setLErrorE(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setLHelixMu((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TRecMdcKalTrack*) G__getstructoffset())->setLErrorMu(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setLHelixK((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TRecMdcKalTrack*) G__getstructoffset())->setLErrorK(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setLHelixP((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TRecMdcKalTrack*) G__getstructoffset())->setLErrorP(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setTHelix((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setTError((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setPocaE((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setPocaMu((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setPoca((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setPocaK((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setPocaP((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setLPointE((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setLPointMu((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setLPoint((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setLPointK((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setLPointP((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setLPivotE((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setLPivotMu((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setLPivot((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setLPivotK((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_208_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalTrack*) G__getstructoffset())->setLPivotP((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

static int G__RootEventData_rootcint_209_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getDriftDistLeft());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getDriftDistRight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getErrDriftDistLeft());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getErrDriftDistRight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getChisqAdd());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__RootEventData_rootcint_209_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getTdc());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getAdc());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getDriftT());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getDoca());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getEntra());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getZhit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcHit*) G__getstructoffset())->getFltLen());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcHit*) G__getstructoffset())->setIsGrouped((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcHit*) G__getstructoffset())->setId((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcHit*) G__getstructoffset())->setTrkId((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcHit*) G__getstructoffset())->setDriftDistLeft((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcHit*) G__getstructoffset())->setDriftDistRight((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcHit*) G__getstructoffset())->setErrDriftDistLeft((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcHit*) G__getstructoffset())->setErrDriftDistRight((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcHit*) G__getstructoffset())->setChisqAdd((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcHit*) G__getstructoffset())->setFlagLR((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcHit*) G__getstructoffset())->setStat((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcHit*) G__getstructoffset())->setMdcId((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcHit*) G__getstructoffset())->setTdc((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcHit*) G__getstructoffset())->setAdc((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcHit*) G__getstructoffset())->setDriftT((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcHit*) G__getstructoffset())->setDoca((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcHit*) G__getstructoffset())->setEntra((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcHit*) G__getstructoffset())->setZhit((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcHit*) G__getstructoffset())->setFltLen((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_209_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcHit*) G__getstructoffset())->setTRecMdcHit((TRecMdcHit*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__RootEventData_rootcint_210_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setTofTrackID((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setTrackID((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setTofID((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setStatus((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setPath((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setZrHit((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setPh((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setTof((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setErrTof((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setBeta((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setTexp((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setTexpElectron((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setTexpMuon((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setTexpPion((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setTexpKaon((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setTexpProton((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setToffset((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setToffsetElectron((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setToffsetMuon((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setToffsetPion((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setToffsetKaon((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setToffsetProton((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setToffsetAntiProton((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setSigma((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setSigmaElectron((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setSigmaMuon((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setSigmaPion((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setSigmaKaon((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setSigmaProton((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setSigmaAntiProton((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setQuality((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setT0((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setErrT0((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setErrZ((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setPhi((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setErrPhi((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setEnergy((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofTrack*) G__getstructoffset())->setErrEnergy((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__RootEventData_rootcint_210_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->path());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->zrhit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->ph());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->tof());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->errtof());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->beta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->texp((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->texpElectron());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->texpMuon());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->texpPion());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->texpKaon());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->texpProton());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->toffset((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->toffsetElectron());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->toffsetMuon());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->toffsetPion());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->toffsetKaon());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->toffsetProton());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->toffsetAntiProton());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->sigma((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->sigmaElectron());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->sigmaMuon());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->sigmaPion());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->sigmaKaon());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->sigmaProton());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->sigmaAntiProton());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__RootEventData_rootcint_210_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->t0());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->errt0());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->errz());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__RootEventData_rootcint_210_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->errphi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->energy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_210_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofTrack*) G__getstructoffset())->errenergy());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

static int G__RootEventData_rootcint_211_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->path());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->zrhit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->ph());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->tof());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->errtof());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->beta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->texp((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->texpElectron());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->texpMuon());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->texpPion());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->texpKaon());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->texpProton());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->toffset((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->toffsetElectron());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->toffsetMuon());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->toffsetPion());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->toffsetKaon());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->toffsetProton());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->toffsetAntiProton());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->sigma((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->sigmaElectron());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->sigmaMuon());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->sigmaPion());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->sigmaKaon());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->sigmaProton());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->sigmaAntiProton());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__RootEventData_rootcint_211_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->t0());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->errt0());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->errz());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__RootEventData_rootcint_211_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->errphi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->energy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecTofTrack*) G__getstructoffset())->errenergy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setTofTrackID((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setTrackID((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setTofID((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setStatus((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setPath((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setZrHit((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setPh((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setTof((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setErrTof((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setBeta((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setTexp((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setTexpElectron((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setTexpMuon((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setTexpPion((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setTexpKaon((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setTexpProton((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setToffset((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setToffsetElectron((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setToffsetMuon((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setToffsetPion((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setToffsetKaon((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setToffsetProton((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setToffsetAntiProton((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setSigma((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setSigmaElectron((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setSigmaMuon((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setSigmaPion((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setSigmaKaon((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setSigmaProton((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setSigmaAntiProton((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setQuality((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setT0((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setErrT0((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setErrZ((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setPhi((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setErrPhi((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setEnergy((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setErrEnergy((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_211_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTofTrack*) G__getstructoffset())->setTRecTofTrack((TRecTofTrack*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

static int G__RootEventData_rootcint_212_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecEmcHit*) G__getstructoffset())->energy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_212_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecEmcHit*) G__getstructoffset())->time());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_212_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcHit*) G__getstructoffset())->setCellId((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_212_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcHit*) G__getstructoffset())->setEnergy((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_212_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcHit*) G__getstructoffset())->setTime((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

static int G__RootEventData_rootcint_213_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcCluster*) G__getstructoffset())->setClusterId((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

static int G__RootEventData_rootcint_449_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->x());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->y());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->z());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->theta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->dtheta());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__RootEventData_rootcint_449_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->dphi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->energy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->dE());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->eSeed());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->e3x3());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->e5x5());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->eAll());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->eLepton());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->time());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->secondMoment());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->latMoment());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->a20Moment());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->a42Moment());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecEmcShower*) G__getstructoffset())->err((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const map<Int_t,Double_t>* pobj;
         const map<Int_t,Double_t> xobj = ((const TRecEmcShower*) G__getstructoffset())->cellIdMap();
         pobj = new map<Int_t,Double_t>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__RootEventData_rootcint_449_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setNumHits((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setStatus((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setCellId((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setModule((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setEnergy((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setDE((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setTheta((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setDtheta((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setPhi((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setDphi((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setESeed((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setE3x3((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setE5x5((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setEAll((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setELepton((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setTime((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setSecondMoment((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setLatMoment((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setA20Moment((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setA42Moment((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setErr((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setCellIdMap(*(map<Int_t,Double_t>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__RootEventData_rootcint_449_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setClusterId((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_449_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEmcShower*) G__getstructoffset())->setTRecEmcShower((TRecEmcShower*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

static int G__RootEventData_rootcint_457_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->depth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->chi2());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__RootEventData_rootcint_457_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->rms());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->distance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->deltaPhi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->xPos());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->yPos());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->zPos());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->xPosSigma());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->yPosSigma());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->zPosSigma());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->px());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->py());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->pz());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__RootEventData_rootcint_457_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->kalRechi2());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__RootEventData_rootcint_457_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMucTrack*) G__getstructoffset())->kaldepth());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__RootEventData_rootcint_457_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setTrackId((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setId((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setStatus((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setType((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setStartPart((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setEndPart((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setBrLastLayer((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setEcLastLayer((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setNumHits((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setNumLayers((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setMaxHitsInLayer((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setDepth((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setChi2((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setDof((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setRms((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setDistance((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setDeltaPhi((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setXPos((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setYPos((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setZPos((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setXPosSigma((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setYPosSigma((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setZPosSigma((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setPx((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setPy((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setPz((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__RootEventData_rootcint_457_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setkalRechi2((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setkalDof((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setkalDepth((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setkalbrLastLayer((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setkalecLastLayer((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_457_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMucTrack*) G__getstructoffset())->setTRecMucTrack((TRecMucTrack*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

static int G__RootEventData_rootcint_458_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->chi((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->chiE());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->chiMu());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->chiPi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->chiK());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->chiP());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__RootEventData_rootcint_458_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->probPH());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->normPH());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->errorPH());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->twentyPH());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->dedxExpect((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->sigmaDedx((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->pidProb((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->dedxHit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->dedxEsat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->dedxNoRun());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcDedx*) G__getstructoffset())->dedxMoment());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setDedxHit((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setDedxEsat((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setDedxNoRun((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setDedxMoment((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setMdcTrackId((const int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setMdcKalTrackId((const int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setParticleId((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setStatus((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setTruncAlg((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setChiE((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setChiMu((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setChiPi((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setChiK((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setChiP((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setNumGoodHits((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setNumTotalHits((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setProbPH((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setNormPH((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setErrorPH((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setTwentyPH((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setChi((double*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setDedxExpect((double*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setSigmaDedx((double*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_458_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedx*) G__getstructoffset())->setPidProb((double*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__RootEventData_rootcint_459_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TRecMdcDedxHit*) G__getstructoffset())->isGrouped());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_459_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TRecMdcDedxHit*) G__getstructoffset())->mdcHitId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_459_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TRecMdcDedxHit*) G__getstructoffset())->mdcKalHelixSegId());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__RootEventData_rootcint_459_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcDedxHit*) G__getstructoffset())->pathLength());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_459_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcDedxHit*) G__getstructoffset())->getDedx());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_459_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedxHit*) G__getstructoffset())->setMdcHitId((const int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_459_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedxHit*) G__getstructoffset())->setMdcKalHelixSegId((const int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_459_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedxHit*) G__getstructoffset())->setDedx((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_459_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedxHit*) G__getstructoffset())->setIsGrouped((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_459_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedxHit*) G__getstructoffset())->setTrkId((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_459_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedxHit*) G__getstructoffset())->setFlagLR((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_459_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedxHit*) G__getstructoffset())->setMdcId((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_459_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcDedxHit*) G__getstructoffset())->setPathLength((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__RootEventData_rootcint_460_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecExtTrack*) G__getstructoffset())->SetTrackId((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1PositionX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1PositionX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1PositionY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1PositionY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1PositionZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1PositionZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1MomentumX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1MomentumX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1MomentumY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1MomentumY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1MomentumZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1MomentumZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1VolumeName(*((const TString*) G__int(libp->para[0])), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1VolumeName(*((const TString*) G__int(libp->para[0])));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1VolumeNumber((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1VolumeNumber((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1Path((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1Path((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongT((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongT((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1ErrorMatrix(G__Ap0->a, (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof1ErrorMatrix(G__Ap0->a);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2PositionX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2PositionX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2PositionY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2PositionY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2PositionZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2PositionZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2MomentumX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2MomentumX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2MomentumY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2MomentumY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2MomentumZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2MomentumZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2VolumeName(*((const TString*) G__int(libp->para[0])), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2VolumeName(*((const TString*) G__int(libp->para[0])));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2VolumeNumber((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2VolumeNumber((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2Path((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2Path((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongT((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongT((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2ErrorMatrix(G__Ap0->a, (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetTof2ErrorMatrix(G__Ap0->a);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcPositionX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcPositionX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcPositionY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcPositionY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcPositionZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcPositionZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcMomentumX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcMomentumX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcMomentumY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcMomentumY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcMomentumZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcMomentumZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcVolumeName(*((const TString*) G__int(libp->para[0])), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcVolumeName(*((const TString*) G__int(libp->para[0])));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcVolumeNumber((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcVolumeNumber((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcPosSigmaAlongTheta((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcPosSigmaAlongTheta((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcPosSigmaAlongPhi((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcPosSigmaAlongPhi((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcErrorMatrix(G__Ap0->a, (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcErrorMatrix(G__Ap0->a);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcPath((Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetEmcPath((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetMucPositionX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetMucPositionX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetMucPositionY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetMucPositionY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetMucPositionZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetMucPositionZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetMucMomentumX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetMucMomentumX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetMucMomentumY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetMucMomentumY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetMucMomentumZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetMucMomentumZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetMucVolumeName(*((const TString*) G__int(libp->para[0])), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetMucVolumeName(*((const TString*) G__int(libp->para[0])));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetMucVolumeNumber((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetMucVolumeNumber((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongZ((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongT((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongT((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongX((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongY((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetMucErrorMatrix(G__Ap0->a, (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetMucErrorMatrix(G__Ap0->a);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TRecExtTrack*) G__getstructoffset())->SetSize((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TRecExtTrack*) G__getstructoffset())->SetSize((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp12 { Double_t a[1][6]; }* G__Ap12 = (struct G__aRyp12*) G__int(libp->para[12]);
   switch (libp->paran) {
   case 14:
      ((TRecExtTrack*) G__getstructoffset())->SetExtMucHit(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, *((TString*) G__int(libp->para[6])), (Int_t) G__int(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])
, G__Ap12->a, (const Int_t) G__int(libp->para[13]));
      G__setnull(result7);
      break;
   case 13:
      ((TRecExtTrack*) G__getstructoffset())->SetExtMucHit(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, *((TString*) G__int(libp->para[6])), (Int_t) G__int(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])
, G__Ap12->a);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__RootEventData_rootcint_460_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PositionX((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PositionX());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PositionY((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PositionY());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PositionZ((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PositionZ());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1MomentumX((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1MomentumX());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1MomentumY((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1MomentumY());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1MomentumZ((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1MomentumZ());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__RootEventData_rootcint_460_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetTof1VolumeNumber((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetTof1VolumeNumber());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1Path((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1Path());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongZ((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongZ());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongT((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongT());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongX((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongX());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongY((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongY());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1ErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof1ErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PositionX((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PositionX());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PositionY((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PositionY());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PositionZ((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PositionZ());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2MomentumX((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2MomentumX());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2MomentumY((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2MomentumY());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2MomentumZ((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2MomentumZ());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__RootEventData_rootcint_460_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetTof2VolumeNumber((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetTof2VolumeNumber());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2Path((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2Path());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongZ((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongZ());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongT((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongT());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongX((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongX());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongY((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongY());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2ErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetTof2ErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPositionX((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPositionX());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPositionY((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPositionY());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPositionZ((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPositionZ());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcMomentumX((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcMomentumX());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcMomentumY((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcMomentumY());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcMomentumZ((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcMomentumZ());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__RootEventData_rootcint_460_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetEmcVolumeNumber((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetEmcVolumeNumber());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPosSigmaAlongTheta((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPosSigmaAlongTheta());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPosSigmaAlongPhi((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcPosSigmaAlongPhi());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetEmcErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->emcPath((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->emcPath());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPositionX((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPositionX());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPositionY((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPositionY());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPositionZ((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPositionZ());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucMomentumX((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucMomentumX());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucMomentumY((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucMomentumY());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucMomentumZ((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucMomentumZ());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__RootEventData_rootcint_460_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetMucVolumeNumber((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetMucVolumeNumber());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongZ((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongZ());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongT((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongT());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongX((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongX());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongY((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongY());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMucErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetSize((const Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetSize());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPositionX((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPositionX((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPositionY((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPositionY((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPositionZ((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPositionZ((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMomentumX((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMomentumX((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMomentumY((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMomentumY((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMomentumZ((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetMomentumZ((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__RootEventData_rootcint_460_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetVolumeNumber((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((const TRecExtTrack*) G__getstructoffset())->GetVolumeNumber((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPosSigmaAlongZ((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPosSigmaAlongZ((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPosSigmaAlongT((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPosSigmaAlongT((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPosSigmaAlongX((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPosSigmaAlongX((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_460_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPosSigmaAlongY((Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TRecExtTrack*) G__getstructoffset())->GetPosSigmaAlongY((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

static int G__RootEventData_rootcint_469_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecEvTime*) G__getstructoffset())->estime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_469_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecEvTime*) G__getstructoffset())->quality());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_469_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEvTime*) G__getstructoffset())->setTest((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_469_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEvTime*) G__getstructoffset())->setStats((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_469_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecEvTime*) G__getstructoffset())->setQuality((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

static int G__RootEventData_rootcint_470_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getTdc());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getAdc());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getZhit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getTof());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getDocaIncl());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getDocaExcl());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getDD());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getEntra());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getDT());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getHelixIncl((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TRecMdcKalHelixSeg*) G__getstructoffset())->getHelixExcl((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalHelixSeg*) G__getstructoffset())->setTrackId((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalHelixSeg*) G__getstructoffset())->setFlagLR((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalHelixSeg*) G__getstructoffset())->setMdcId((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalHelixSeg*) G__getstructoffset())->setTdc((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalHelixSeg*) G__getstructoffset())->setAdc((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalHelixSeg*) G__getstructoffset())->setZhit((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalHelixSeg*) G__getstructoffset())->setTof((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalHelixSeg*) G__getstructoffset())->setDocaIncl((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalHelixSeg*) G__getstructoffset())->setDocaExcl((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalHelixSeg*) G__getstructoffset())->setDD((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalHelixSeg*) G__getstructoffset())->setEntra((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalHelixSeg*) G__getstructoffset())->setDT((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalHelixSeg*) G__getstructoffset())->setHelixIncl((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_470_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecMdcKalHelixSeg*) G__getstructoffset())->setHelixExcl((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TRecMdcKalHelixSeg G__TTRecMdcKalHelixSeg;
static int G__RootEventData_rootcint_470_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TRecMdcKalHelixSeg*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TRecMdcKalHelixSeg*) (soff+(sizeof(TRecMdcKalHelixSeg)*i)))->~G__TTRecMdcKalHelixSeg();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TRecMdcKalHelixSeg*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TRecMdcKalHelixSeg*) (soff))->~G__TTRecMdcKalHelixSeg();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_470_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRecMdcKalHelixSeg* dest = (TRecMdcKalHelixSeg*) G__getstructoffset();
   *dest = *(TRecMdcKalHelixSeg*) libp->para[0].ref;
   const TRecMdcKalHelixSeg& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TRecZddChannel */
static int G__RootEventData_rootcint_471_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRecZddChannel* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TRecZddChannel[n];
     } else {
       p = new((void*) gvp) TRecZddChannel[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TRecZddChannel;
     } else {
       p = new((void*) gvp) TRecZddChannel;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_471_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TRecZddChannel*) G__getstructoffset())->channelId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_471_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TRecZddChannel*) G__getstructoffset())->scanCode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_471_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TRecZddChannel*) G__getstructoffset())->baseLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_471_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TRecZddChannel*) G__getstructoffset())->phase());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_471_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TRecZddChannel::Fragments& obj = ((const TRecZddChannel*) G__getstructoffset())->fragments();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_471_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecZddChannel*) G__getstructoffset())->setChannelId((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_471_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecZddChannel*) G__getstructoffset())->setScanCode((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_471_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecZddChannel*) G__getstructoffset())->setBaseLine((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_471_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecZddChannel*) G__getstructoffset())->setPhase((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_471_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecZddChannel*) G__getstructoffset())->setFragments(*(TRecZddChannel::Fragments*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_471_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TRecZddChannel::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_471_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRecZddChannel::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_471_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TRecZddChannel::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_471_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TRecZddChannel::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_471_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecZddChannel*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_471_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRecZddChannel::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_471_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TRecZddChannel::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_471_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRecZddChannel::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_471_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TRecZddChannel::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_471_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TRecZddChannel* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TRecZddChannel(*(TRecZddChannel*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TRecZddChannel G__TTRecZddChannel;
static int G__RootEventData_rootcint_471_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TRecZddChannel*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TRecZddChannel*) (soff+(sizeof(TRecZddChannel)*i)))->~G__TTRecZddChannel();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TRecZddChannel*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TRecZddChannel*) (soff))->~G__TTRecZddChannel();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_471_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRecZddChannel* dest = (TRecZddChannel*) G__getstructoffset();
   *dest = *(TRecZddChannel*) libp->para[0].ref;
   const TRecZddChannel& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TRecTrackEvent */
static int G__RootEventData_rootcint_477_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRecTrackEvent* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TRecTrackEvent[n];
     } else {
       p = new((void*) gvp) TRecTrackEvent[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TRecTrackEvent;
     } else {
       p = new((void*) gvp) TRecTrackEvent;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->initialize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcTrackCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->addRecMdcTrack((TRecMdcTrack*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcTrack((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->clearRecMdcTrackCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcHitCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->addRecMdcHit((TRecMdcHit*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcHit((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->clearRecMdcHitCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getTofTrackCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->addTofTrack((TRecTofTrack*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getTofTrack((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->clearTofTrackCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEmcHitCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->addEmcHit((TRecEmcHit*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEmcHit((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->clearEmcHitCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEmcClusterCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->addEmcCluster((TRecEmcCluster*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEmcCluster((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->clearEmcClusterCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEmcShowerCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->addEmcShower((TRecEmcShower*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEmcShower((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->clearEmcShowerCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getMucTrackCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->addMucTrack((TRecMucTrack*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getMucTrack((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->clearMucTrackCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcDedxCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->addRecMdcDedx((TRecMdcDedx*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcDedx((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->clearRecMdcDedxCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcDedxHitCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->addRecMdcDedxHit((TRecMdcDedxHit*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcDedxHit((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->clearRecMdcDedxHitCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getExtTrackCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->addExtTrack((TRecExtTrack*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getExtTrack((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->clearExtTrackCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcKalTrackCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->addRecMdcKalTrack((TRecMdcKalTrack*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcKalTrack((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->clearRecMdcKalTrackCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcKalHelixSegCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->addRecMdcKalHelixSeg((TRecMdcKalHelixSeg*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecMdcKalHelixSeg((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->clearRecMdcKalHelixSegCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEvTimeCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->addEvTime((TRecEvTime*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getEvTime((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->clearEvTimeCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecZddChannelCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->addRecZddChannel((TRecZddChannel*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRecTrackEvent*) G__getstructoffset())->getRecZddChannel((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->clearRecZddChannelCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TRecTrackEvent::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRecTrackEvent::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TRecTrackEvent::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TRecTrackEvent::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRecTrackEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRecTrackEvent::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TRecTrackEvent::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRecTrackEvent::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_477_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TRecTrackEvent::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_477_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TRecTrackEvent* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TRecTrackEvent(*(TRecTrackEvent*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TRecTrackEvent G__TTRecTrackEvent;
static int G__RootEventData_rootcint_477_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TRecTrackEvent*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TRecTrackEvent*) (soff+(sizeof(TRecTrackEvent)*i)))->~G__TTRecTrackEvent();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TRecTrackEvent*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TRecTrackEvent*) (soff))->~G__TTRecTrackEvent();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_477_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRecTrackEvent* dest = (TRecTrackEvent*) G__getstructoffset();
   *dest = *(TRecTrackEvent*) libp->para[0].ref;
   const TRecTrackEvent& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMdcTrack */
static int G__RootEventData_rootcint_478_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMdcTrack* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMdcTrack[n];
     } else {
       p = new((void*) gvp) TMdcTrack[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMdcTrack;
     } else {
       p = new((void*) gvp) TMdcTrack;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->trackId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->helix((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->stat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->chi2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->ndof());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->err((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->nster());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->nlayer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->firstLayer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->lastLayer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->x());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->y());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->z());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->r());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMdcTrack*) G__getstructoffset())->charge());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->pxy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->px());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->py());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->pz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->p());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->theta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcTrack*) G__getstructoffset())->phi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcTrack*) G__getstructoffset())->setHelix((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcTrack*) G__getstructoffset())->setErr((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcTrack*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcTrack*) G__getstructoffset())->setStat((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcTrack*) G__getstructoffset())->setChi2((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcTrack*) G__getstructoffset())->setNdof((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcTrack*) G__getstructoffset())->setNster((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcTrack*) G__getstructoffset())->setNlayer((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcTrack*) G__getstructoffset())->setFirstLayer((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcTrack*) G__getstructoffset())->setLastLayer((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMdcTrack::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMdcTrack::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMdcTrack::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMdcTrack::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMdcTrack::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMdcTrack::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMdcTrack::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_478_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMdcTrack::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_478_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMdcTrack* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMdcTrack(*(TMdcTrack*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMdcTrack G__TTMdcTrack;
static int G__RootEventData_rootcint_478_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMdcTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMdcTrack*) (soff+(sizeof(TMdcTrack)*i)))->~G__TTMdcTrack();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMdcTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMdcTrack*) (soff))->~G__TTMdcTrack();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_478_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMdcTrack* dest = (TMdcTrack*) G__getstructoffset();
   *dest = *(TMdcTrack*) libp->para[0].ref;
   const TMdcTrack& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEmcTrack */
static int G__RootEventData_rootcint_479_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEmcTrack* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEmcTrack[n];
     } else {
       p = new((void*) gvp) TEmcTrack[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEmcTrack;
     } else {
       p = new((void*) gvp) TEmcTrack;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEmcTrack*) G__getstructoffset())->trackId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEmcTrack*) G__getstructoffset())->numHits());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEmcTrack*) G__getstructoffset())->status());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEmcTrack*) G__getstructoffset())->cellId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEmcTrack*) G__getstructoffset())->module());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->x());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->y());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->z());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->theta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->phi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->dx());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->dy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->dz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->dtheta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->dphi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->energy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->dE());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->eSeed());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->e3x3());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->e5x5());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->time());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->secondMoment());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->latMoment());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->a20Moment());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->a42Moment());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcTrack*) G__getstructoffset())->err((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcTrack*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcTrack*) G__getstructoffset())->setNumHits((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcTrack*) G__getstructoffset())->setStatus((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcTrack*) G__getstructoffset())->setCellId((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcTrack*) G__getstructoffset())->setModule((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcTrack*) G__getstructoffset())->setX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcTrack*) G__getstructoffset())->setY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcTrack*) G__getstructoffset())->setZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcTrack*) G__getstructoffset())->setEnergy((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcTrack*) G__getstructoffset())->setDE((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcTrack*) G__getstructoffset())->setDtheta((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcTrack*) G__getstructoffset())->setDphi((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcTrack*) G__getstructoffset())->setESeed((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcTrack*) G__getstructoffset())->setE3x3((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcTrack*) G__getstructoffset())->setE5x5((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcTrack*) G__getstructoffset())->setTime((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcTrack*) G__getstructoffset())->setSecondMoment((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcTrack*) G__getstructoffset())->setLatMoment((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcTrack*) G__getstructoffset())->setA20Moment((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcTrack*) G__getstructoffset())->setA42Moment((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcTrack*) G__getstructoffset())->setErr((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEmcTrack::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEmcTrack::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEmcTrack::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEmcTrack::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEmcTrack::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEmcTrack::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEmcTrack::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_479_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEmcTrack::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_479_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEmcTrack* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEmcTrack(*(TEmcTrack*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEmcTrack G__TTEmcTrack;
static int G__RootEventData_rootcint_479_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEmcTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEmcTrack*) (soff+(sizeof(TEmcTrack)*i)))->~G__TTEmcTrack();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEmcTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEmcTrack*) (soff))->~G__TTEmcTrack();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_479_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEmcTrack* dest = (TEmcTrack*) G__getstructoffset();
   *dest = *(TEmcTrack*) libp->para[0].ref;
   const TEmcTrack& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMucTrack */
static int G__RootEventData_rootcint_480_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMucTrack* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMucTrack[n];
     } else {
       p = new((void*) gvp) TMucTrack[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMucTrack;
     } else {
       p = new((void*) gvp) TMucTrack;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->trackId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->id());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->status());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->type());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->startPart());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->endPart());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->brLastLayer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->ecLastLayer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->numHits());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->numLayers());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->maxHitsInLayer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->depth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->chi2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->dof());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->rms());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->xPos());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->yPos());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->zPos());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->xPosSigma());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->yPosSigma());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->zPosSigma());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->px());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->py());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->pz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->distance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->deltaPhi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->kalRechi2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->kaldof());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMucTrack*) G__getstructoffset())->kaldepth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->kalbrLastLayer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMucTrack*) G__getstructoffset())->kalecLastLayer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setTrackId((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setId((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setStatus((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setType((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setStartPart((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setEndPart((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setBrLastLayer((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setEcLastLayer((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setNumHits((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setNumLayers((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setMaxHitsInLayer((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setDepth((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setChi2((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setDof((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setRms((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setXPos((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setYPos((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setZPos((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setXPosSigma((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setYPosSigma((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setZPosSigma((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setPx((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setPy((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setPz((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setDistance((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setDeltaPhi((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setkalRechi2((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setkalDof((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setkalDepth((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setkalbrLastLayer((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->setkalecLastLayer((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMucTrack::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMucTrack::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMucTrack::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMucTrack::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMucTrack::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMucTrack::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMucTrack::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_480_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMucTrack::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_480_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMucTrack* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMucTrack(*(TMucTrack*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMucTrack G__TTMucTrack;
static int G__RootEventData_rootcint_480_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMucTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMucTrack*) (soff+(sizeof(TMucTrack)*i)))->~G__TTMucTrack();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMucTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMucTrack*) (soff))->~G__TTMucTrack();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_480_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMucTrack* dest = (TMucTrack*) G__getstructoffset();
   *dest = *(TMucTrack*) libp->para[0].ref;
   const TMucTrack& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMdcDedx */
static int G__RootEventData_rootcint_481_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMdcDedx* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMdcDedx[n];
     } else {
       p = new((void*) gvp) TMdcDedx[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMdcDedx;
     } else {
       p = new((void*) gvp) TMdcDedx;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMdcDedx*) G__getstructoffset())->trackId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMdcDedx*) G__getstructoffset())->particleId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMdcDedx*) G__getstructoffset())->status());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMdcDedx*) G__getstructoffset())->truncAlg());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->chi((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->chiE());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->chiMu());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->chiPi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->chiK());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->chiP());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMdcDedx*) G__getstructoffset())->numGoodHits());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMdcDedx*) G__getstructoffset())->numTotalHits());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->probPH());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->normPH());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->errorPH());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcDedx*) G__getstructoffset())->twentyPH());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcDedx*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcDedx*) G__getstructoffset())->setParticleId((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcDedx*) G__getstructoffset())->setStatus((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcDedx*) G__getstructoffset())->setTruncAlg((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcDedx*) G__getstructoffset())->setChiE((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcDedx*) G__getstructoffset())->setChiMu((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcDedx*) G__getstructoffset())->setChiPi((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcDedx*) G__getstructoffset())->setChiK((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcDedx*) G__getstructoffset())->setChiP((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcDedx*) G__getstructoffset())->setNumGoodHits((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcDedx*) G__getstructoffset())->setNumTotalHits((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcDedx*) G__getstructoffset())->setProbPH((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcDedx*) G__getstructoffset())->setNormPH((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcDedx*) G__getstructoffset())->setErrorPH((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcDedx*) G__getstructoffset())->setTwentyPH((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMdcDedx::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMdcDedx::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMdcDedx::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMdcDedx::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcDedx*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMdcDedx::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMdcDedx::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMdcDedx::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_481_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMdcDedx::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_481_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMdcDedx* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMdcDedx(*(TMdcDedx*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMdcDedx G__TTMdcDedx;
static int G__RootEventData_rootcint_481_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMdcDedx*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMdcDedx*) (soff+(sizeof(TMdcDedx)*i)))->~G__TTMdcDedx();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMdcDedx*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMdcDedx*) (soff))->~G__TTMdcDedx();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_481_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMdcDedx* dest = (TMdcDedx*) G__getstructoffset();
   *dest = *(TMdcDedx*) libp->para[0].ref;
   const TMdcDedx& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TExtTrack */
static int G__RootEventData_rootcint_483_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TExtTrack* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TExtTrack[n];
     } else {
       p = new((void*) gvp) TExtTrack[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TExtTrack;
     } else {
       p = new((void*) gvp) TExtTrack;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTrackId((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof1PositionX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof1PositionY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof1PositionZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof1MomentumX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof1MomentumY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof1MomentumZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof1VolumeName(*((const TString*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof1VolumeNumber((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof1((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof1Path((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongT((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof1PosSigmaAlongY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TExtTrack*) G__getstructoffset())->SetTof1ErrorMatrix(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof2PositionX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof2PositionY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof2PositionZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof2MomentumX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof2MomentumY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof2MomentumZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof2VolumeName(*((const TString*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof2VolumeNumber((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof2((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof2Path((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongT((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetTof2PosSigmaAlongY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TExtTrack*) G__getstructoffset())->SetTof2ErrorMatrix(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetEmcPositionX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetEmcPositionY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetEmcPositionZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetEmcMomentumX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetEmcMomentumY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetEmcMomentumZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetEmcVolumeName(*((const TString*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetEmcVolumeNumber((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetEmcPosSigmaAlongTheta((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetEmcPosSigmaAlongPhi((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TExtTrack*) G__getstructoffset())->SetEmcErrorMatrix(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetEmcPath((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetMucPositionX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetMucPositionY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetMucPositionZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetMucMomentumX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetMucMomentumY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetMucMomentumZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetMucVolumeName(*((const TString*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetMucVolumeNumber((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongZ((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongT((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongX((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->SetMucPosSigmaAlongY((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][6]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TExtTrack*) G__getstructoffset())->SetMucErrorMatrix(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TExtTrack*) G__getstructoffset())->GetTrackId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1PositionX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1PositionY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1PositionZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1MomentumX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1MomentumY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1MomentumZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TExtTrack*) G__getstructoffset())->GetTof1VolumeName();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TExtTrack*) G__getstructoffset())->GetTof1VolumeNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1Path());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongT());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1PosSigmaAlongY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof1ErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2PositionX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2PositionY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2PositionZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2MomentumX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2MomentumY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2MomentumZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TExtTrack*) G__getstructoffset())->GetTof2VolumeName();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TExtTrack*) G__getstructoffset())->GetTof2VolumeNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2Path());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongT());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2PosSigmaAlongY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetTof2ErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcPositionX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcPositionY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcPositionZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcMomentumX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcMomentumY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcMomentumZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TExtTrack*) G__getstructoffset())->GetEmcVolumeName();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TExtTrack*) G__getstructoffset())->GetEmcVolumeNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcPosSigmaAlongTheta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcPosSigmaAlongPhi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetEmcErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->emcPath());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucPositionX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucPositionY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucPositionZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucMomentumX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucMomentumY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucMomentumZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TExtTrack*) G__getstructoffset())->GetMucVolumeName();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TExtTrack*) G__getstructoffset())->GetMucVolumeNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongT());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucPosSigmaAlongY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TExtTrack*) G__getstructoffset())->GetMucErrorMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TExtTrack::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TExtTrack::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TExtTrack::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TExtTrack::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExtTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TExtTrack::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TExtTrack::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TExtTrack::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_483_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TExtTrack::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_483_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TExtTrack* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TExtTrack(*(TExtTrack*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TExtTrack G__TTExtTrack;
static int G__RootEventData_rootcint_483_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TExtTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TExtTrack*) (soff+(sizeof(TExtTrack)*i)))->~G__TTExtTrack();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TExtTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TExtTrack*) (soff))->~G__TTExtTrack();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_483_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TExtTrack* dest = (TExtTrack*) G__getstructoffset();
   *dest = *(TExtTrack*) libp->para[0].ref;
   const TExtTrack& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMdcKalTrack */
static int G__RootEventData_rootcint_484_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMdcKalTrack* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMdcKalTrack[n];
     } else {
       p = new((void*) gvp) TMdcKalTrack[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMdcKalTrack;
     } else {
       p = new((void*) gvp) TMdcKalTrack;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMdcKalTrack*) G__getstructoffset())->getTrackId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMdcKalTrack*) G__getstructoffset())->getStat((const Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMdcKalTrack*) G__getstructoffset())->getStat2((const Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getChisq((const Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMdcKalTrack*) G__getstructoffset())->getNdf((const Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMdcKalTrack*) G__getstructoffset())->getNlayer((const Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZHelix((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZError((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZHelixE((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZErrorE((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZHelixMu((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZErrorMu((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZHelixK((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZErrorK((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZHelixP((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getZErrorP((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFHelix((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFError((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFHelixE((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFErrorE((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFHelixMu((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFErrorMu((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFHelixK((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFErrorK((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFHelixP((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcKalTrack*) G__getstructoffset())->getFErrorP((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcKalTrack*) G__getstructoffset())->setTrackId((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcKalTrack*) G__getstructoffset())->setStat((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcKalTrack*) G__getstructoffset())->setStat2((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcKalTrack*) G__getstructoffset())->setChisq((const Double_t) G__double(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcKalTrack*) G__getstructoffset())->setNdf((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcKalTrack*) G__getstructoffset())->setNlayer((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcKalTrack*) G__getstructoffset())->setZHelix((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TMdcKalTrack*) G__getstructoffset())->setZError(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcKalTrack*) G__getstructoffset())->setZHelixE((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TMdcKalTrack*) G__getstructoffset())->setZErrorE(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcKalTrack*) G__getstructoffset())->setZHelixMu((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TMdcKalTrack*) G__getstructoffset())->setZErrorMu(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcKalTrack*) G__getstructoffset())->setZHelixK((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TMdcKalTrack*) G__getstructoffset())->setZErrorK(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcKalTrack*) G__getstructoffset())->setZHelixP((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TMdcKalTrack*) G__getstructoffset())->setZErrorP(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcKalTrack*) G__getstructoffset())->setFHelix((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TMdcKalTrack*) G__getstructoffset())->setFError(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcKalTrack*) G__getstructoffset())->setFHelixE((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TMdcKalTrack*) G__getstructoffset())->setFErrorE(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcKalTrack*) G__getstructoffset())->setFHelixMu((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TMdcKalTrack*) G__getstructoffset())->setFErrorMu(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcKalTrack*) G__getstructoffset())->setFHelixK((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TMdcKalTrack*) G__getstructoffset())->setFErrorK(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcKalTrack*) G__getstructoffset())->setFHelixP((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Double_t a[1][5]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      ((TMdcKalTrack*) G__getstructoffset())->setFErrorP(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMdcKalTrack::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMdcKalTrack::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMdcKalTrack::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMdcKalTrack::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcKalTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMdcKalTrack::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMdcKalTrack::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMdcKalTrack::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_484_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMdcKalTrack::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_484_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMdcKalTrack* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMdcKalTrack(*(TMdcKalTrack*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMdcKalTrack G__TTMdcKalTrack;
static int G__RootEventData_rootcint_484_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMdcKalTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMdcKalTrack*) (soff+(sizeof(TMdcKalTrack)*i)))->~G__TTMdcKalTrack();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMdcKalTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMdcKalTrack*) (soff))->~G__TTMdcKalTrack();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_484_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMdcKalTrack* dest = (TMdcKalTrack*) G__getstructoffset();
   *dest = *(TMdcKalTrack*) libp->para[0].ref;
   const TMdcKalTrack& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TDstEvent */
static int G__RootEventData_rootcint_485_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDstEvent* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDstEvent[n];
     } else {
       p = new((void*) gvp) TDstEvent[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDstEvent;
     } else {
       p = new((void*) gvp) TDstEvent;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstEvent*) G__getstructoffset())->initialize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMdcTrackCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstEvent*) G__getstructoffset())->addMdcTrack((TMdcTrack*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMdcTrack((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstEvent*) G__getstructoffset())->clearMdcTrackCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getEmcTrackCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstEvent*) G__getstructoffset())->addEmcTrack((TEmcTrack*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getEmcTrack((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstEvent*) G__getstructoffset())->clearEmcTrackCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getTofTrackCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstEvent*) G__getstructoffset())->addTofTrack((TTofTrack*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getTofTrack((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstEvent*) G__getstructoffset())->clearTofTrackCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMucTrackCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstEvent*) G__getstructoffset())->addMucTrack((TMucTrack*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMucTrack((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstEvent*) G__getstructoffset())->clearMucTrackCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMdcDedxCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstEvent*) G__getstructoffset())->addMdcDedx((TMdcDedx*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMdcDedx((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstEvent*) G__getstructoffset())->clearMdcDedxCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getExtTrackCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstEvent*) G__getstructoffset())->addExtTrack((TExtTrack*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getExtTrack((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstEvent*) G__getstructoffset())->clearExtTrackCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMdcKalTrackCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstEvent*) G__getstructoffset())->addMdcKalTrack((TMdcKalTrack*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDstEvent*) G__getstructoffset())->getMdcKalTrack((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstEvent*) G__getstructoffset())->clearMdcKalTrackCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TDstEvent::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDstEvent::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TDstEvent::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TDstEvent::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDstEvent::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TDstEvent::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDstEvent::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_485_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TDstEvent::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_485_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TDstEvent* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TDstEvent(*(TDstEvent*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TDstEvent G__TTDstEvent;
static int G__RootEventData_rootcint_485_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TDstEvent*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TDstEvent*) (soff+(sizeof(TDstEvent)*i)))->~G__TTDstEvent();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TDstEvent*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TDstEvent*) (soff))->~G__TTDstEvent();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_485_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDstEvent* dest = (TDstEvent*) G__getstructoffset();
   *dest = *(TDstEvent*) libp->para[0].ref;
   const TDstEvent& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMdcMc */
static int G__RootEventData_rootcint_486_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMdcMc* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMdcMc[n];
     } else {
       p = new((void*) gvp) TMdcMc[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMdcMc;
     } else {
       p = new((void*) gvp) TMdcMc;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TMdcMc*) G__getstructoffset())->getId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TMdcMc*) G__getstructoffset())->getTrackIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcMc*) G__getstructoffset())->getPositionX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcMc*) G__getstructoffset())->getPositionY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcMc*) G__getstructoffset())->getPositionZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcMc*) G__getstructoffset())->getDriftDistance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMdcMc*) G__getstructoffset())->getDepositEnergy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMdcMc*) G__getstructoffset())->getPositionFlag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcMc*) G__getstructoffset())->setId((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcMc*) G__getstructoffset())->setTrackIndex((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcMc*) G__getstructoffset())->setPositionX((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcMc*) G__getstructoffset())->setPositionY((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcMc*) G__getstructoffset())->setPositionZ((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcMc*) G__getstructoffset())->setDriftDistance((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcMc*) G__getstructoffset())->setDepositEnergy((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcMc*) G__getstructoffset())->setPositionFlag((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMdcMc::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMdcMc::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMdcMc::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMdcMc::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMdcMc*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMdcMc::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMdcMc::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMdcMc::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_486_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMdcMc::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_486_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMdcMc* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMdcMc(*(TMdcMc*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMdcMc G__TTMdcMc;
static int G__RootEventData_rootcint_486_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMdcMc*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMdcMc*) (soff+(sizeof(TMdcMc)*i)))->~G__TTMdcMc();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMdcMc*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMdcMc*) (soff))->~G__TTMdcMc();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_486_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMdcMc* dest = (TMdcMc*) G__getstructoffset();
   *dest = *(TMdcMc*) libp->para[0].ref;
   const TMdcMc& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEmcMc */
static int G__RootEventData_rootcint_487_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEmcMc* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEmcMc[n];
     } else {
       p = new((void*) gvp) TEmcMc[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEmcMc;
     } else {
       p = new((void*) gvp) TEmcMc;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const map<Int_t,Double_t>* pobj;
         const map<Int_t,Double_t> xobj = ((const TEmcMc*) G__getstructoffset())->getHitMap();
         pobj = new map<Int_t,Double_t>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEmcMc*) G__getstructoffset())->getHitEmc());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEmcMc*) G__getstructoffset())->getPDGCode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getPDGCharge());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TEmcMc*) G__getstructoffset())->getId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TEmcMc*) G__getstructoffset())->getTrackIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getPositionX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getPositionY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getPositionZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getPx());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getPy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getPz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEmcMc*) G__getstructoffset())->getDepositEnergy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcMc*) G__getstructoffset())->setHitMap(*((map<Int_t,Double_t>*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcMc*) G__getstructoffset())->setHitEmc((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcMc*) G__getstructoffset())->setPDGCode((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcMc*) G__getstructoffset())->setPDGCharge((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcMc*) G__getstructoffset())->setTime((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcMc*) G__getstructoffset())->setId((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcMc*) G__getstructoffset())->setTrackIndex((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcMc*) G__getstructoffset())->setPositionX((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcMc*) G__getstructoffset())->setPositionY((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcMc*) G__getstructoffset())->setPositionZ((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcMc*) G__getstructoffset())->setPx((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcMc*) G__getstructoffset())->setPy((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcMc*) G__getstructoffset())->setPz((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcMc*) G__getstructoffset())->setDepositEnergy((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEmcMc::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEmcMc::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEmcMc::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEmcMc::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEmcMc*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEmcMc::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEmcMc::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEmcMc::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_487_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEmcMc::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_487_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEmcMc* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEmcMc(*(TEmcMc*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEmcMc G__TTEmcMc;
static int G__RootEventData_rootcint_487_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEmcMc*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEmcMc*) (soff+(sizeof(TEmcMc)*i)))->~G__TTEmcMc();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEmcMc*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEmcMc*) (soff))->~G__TTEmcMc();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_487_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEmcMc* dest = (TEmcMc*) G__getstructoffset();
   *dest = *(TEmcMc*) libp->para[0].ref;
   const TEmcMc& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TTofMc */
static int G__RootEventData_rootcint_488_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTofMc* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTofMc[n];
     } else {
       p = new((void*) gvp) TTofMc[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTofMc;
     } else {
       p = new((void*) gvp) TTofMc;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TTofMc*) G__getstructoffset())->getId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TTofMc*) G__getstructoffset())->getTrackIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getPositionX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getPositionY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getPositionZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getPx());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getPy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getPz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getTrackLength());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTofMc*) G__getstructoffset())->getFlightTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofMc*) G__getstructoffset())->setId((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofMc*) G__getstructoffset())->setTrackIndex((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofMc*) G__getstructoffset())->setPositionX((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofMc*) G__getstructoffset())->setPositionY((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofMc*) G__getstructoffset())->setPositionZ((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofMc*) G__getstructoffset())->setPx((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofMc*) G__getstructoffset())->setPy((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofMc*) G__getstructoffset())->setPz((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofMc*) G__getstructoffset())->setTrackLength((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofMc*) G__getstructoffset())->setFlightTime((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TTofMc::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTofMc::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TTofMc::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTofMc::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTofMc*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTofMc::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTofMc::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTofMc::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_488_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTofMc::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_488_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TTofMc* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TTofMc(*(TTofMc*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TTofMc G__TTTofMc;
static int G__RootEventData_rootcint_488_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TTofMc*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TTofMc*) (soff+(sizeof(TTofMc)*i)))->~G__TTTofMc();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TTofMc*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TTofMc*) (soff))->~G__TTTofMc();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_488_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTofMc* dest = (TTofMc*) G__getstructoffset();
   *dest = *(TTofMc*) libp->para[0].ref;
   const TTofMc& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMucMc */
static int G__RootEventData_rootcint_489_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMucMc* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMucMc[n];
     } else {
       p = new((void*) gvp) TMucMc[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMucMc;
     } else {
       p = new((void*) gvp) TMucMc;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TMucMc*) G__getstructoffset())->getId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TMucMc*) G__getstructoffset())->getTrackIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMucMc*) G__getstructoffset())->getPositionX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMucMc*) G__getstructoffset())->getPositionY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMucMc*) G__getstructoffset())->getPositionZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMucMc*) G__getstructoffset())->getPx());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMucMc*) G__getstructoffset())->getPy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMucMc*) G__getstructoffset())->getPz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucMc*) G__getstructoffset())->setId((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucMc*) G__getstructoffset())->setTrackIndex((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucMc*) G__getstructoffset())->setPositionX((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucMc*) G__getstructoffset())->setPositionY((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucMc*) G__getstructoffset())->setPositionZ((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucMc*) G__getstructoffset())->setPx((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucMc*) G__getstructoffset())->setPy((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucMc*) G__getstructoffset())->setPz((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMucMc::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMucMc::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMucMc::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMucMc::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMucMc*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMucMc::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMucMc::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMucMc::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_489_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMucMc::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_489_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMucMc* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMucMc(*(TMucMc*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMucMc G__TTMucMc;
static int G__RootEventData_rootcint_489_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMucMc*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMucMc*) (soff+(sizeof(TMucMc)*i)))->~G__TTMucMc();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMucMc*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMucMc*) (soff))->~G__TTMucMc();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_489_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMucMc* dest = (TMucMc*) G__getstructoffset();
   *dest = *(TMucMc*) libp->para[0].ref;
   const TMucMc& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMcParticle */
static int G__RootEventData_rootcint_490_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMcParticle* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMcParticle[n];
     } else {
       p = new((void*) gvp) TMcParticle[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMcParticle;
     } else {
       p = new((void*) gvp) TMcParticle;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMcParticle*) G__getstructoffset())->getParticleID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMcParticle*) G__getstructoffset())->getTrackIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMcParticle*) G__getstructoffset())->getVertexIndex0());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMcParticle*) G__getstructoffset())->getVertexIndex1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TMcParticle*) G__getstructoffset())->getStatusFlags());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialPositionX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialPositionY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialPositionZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialPositionT());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getFinalPositionX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getFinalPositionY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getFinalPositionZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getFinalPositionT());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialMomentumX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialMomentumY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialMomentumZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcParticle*) G__getstructoffset())->getInitialMomentumE());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMcParticle*) G__getstructoffset())->getMother());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Int_t>* pobj;
         const vector<Int_t> xobj = ((const TMcParticle*) G__getstructoffset())->getDaughters();
         pobj = new vector<Int_t>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMcParticle*) G__getstructoffset())->primaryParticle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMcParticle*) G__getstructoffset())->leafParticle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMcParticle*) G__getstructoffset())->decayFromGenerator());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMcParticle*) G__getstructoffset())->decayInFlight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcParticle*) G__getstructoffset())->setParticleID((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcParticle*) G__getstructoffset())->setTrackIndex((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcParticle*) G__getstructoffset())->setVertexIndex0((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcParticle*) G__getstructoffset())->setVertexIndex1((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcParticle*) G__getstructoffset())->setStatusFlags((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcParticle*) G__getstructoffset())->setInitialPositionX((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcParticle*) G__getstructoffset())->setInitialPositionY((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcParticle*) G__getstructoffset())->setInitialPositionZ((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcParticle*) G__getstructoffset())->setInitialPositionT((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcParticle*) G__getstructoffset())->setFinalPositionX((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcParticle*) G__getstructoffset())->setFinalPositionY((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcParticle*) G__getstructoffset())->setFinalPositionZ((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcParticle*) G__getstructoffset())->setFinalPositionT((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcParticle*) G__getstructoffset())->setInitialMomentumX((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcParticle*) G__getstructoffset())->setInitialMomentumY((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcParticle*) G__getstructoffset())->setInitialMomentumZ((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcParticle*) G__getstructoffset())->setInitialMomentumE((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcParticle*) G__getstructoffset())->setMother((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcParticle*) G__getstructoffset())->setDaughters(*(vector<Int_t>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMcParticle::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMcParticle::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMcParticle::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMcParticle::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcParticle*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMcParticle::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMcParticle::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMcParticle::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_490_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMcParticle::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_490_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMcParticle* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMcParticle(*(TMcParticle*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMcParticle G__TTMcParticle;
static int G__RootEventData_rootcint_490_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMcParticle*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMcParticle*) (soff+(sizeof(TMcParticle)*i)))->~G__TTMcParticle();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMcParticle*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMcParticle*) (soff))->~G__TTMcParticle();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_490_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMcParticle* dest = (TMcParticle*) G__getstructoffset();
   *dest = *(TMcParticle*) libp->para[0].ref;
   const TMcParticle& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMcEvent */
static int G__RootEventData_rootcint_492_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMcEvent* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMcEvent[n];
     } else {
       p = new((void*) gvp) TMcEvent[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMcEvent;
     } else {
       p = new((void*) gvp) TMcEvent;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcEvent*) G__getstructoffset())->initialize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getMdcMcHitCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcEvent*) G__getstructoffset())->addMdcMc((TMdcMc*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getMdcMc((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcEvent*) G__getstructoffset())->clearMdcMcHitCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getEmcMcHitCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcEvent*) G__getstructoffset())->addEmcMc((TEmcMc*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getEmcMc((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcEvent*) G__getstructoffset())->clearEmcMcHitCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getTofMcHitCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcEvent*) G__getstructoffset())->addTofMc((TTofMc*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getTofMc((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcEvent*) G__getstructoffset())->clearTofMcHitCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getMucMcHitCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcEvent*) G__getstructoffset())->addMucMc((TMucMc*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getMucMc((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcEvent*) G__getstructoffset())->clearMucMcHitCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getMcParticleCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcEvent*) G__getstructoffset())->addMcParticle((TMcParticle*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMcEvent*) G__getstructoffset())->getMcParticle((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcEvent*) G__getstructoffset())->clearMcParticleCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMcEvent::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMcEvent::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMcEvent::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMcEvent::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMcEvent::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMcEvent::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMcEvent::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_492_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMcEvent::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_492_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMcEvent* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMcEvent(*(TMcEvent*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMcEvent G__TTMcEvent;
static int G__RootEventData_rootcint_492_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMcEvent*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMcEvent*) (soff+(sizeof(TMcEvent)*i)))->~G__TTMcEvent();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMcEvent*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMcEvent*) (soff))->~G__TTMcEvent();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_492_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMcEvent* dest = (TMcEvent*) G__getstructoffset();
   *dest = *(TMcEvent*) libp->para[0].ref;
   const TMcEvent& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvtHeader */
static int G__RootEventData_rootcint_493_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvtHeader* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvtHeader[n];
     } else {
       p = new((void*) gvp) TEvtHeader[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvtHeader;
     } else {
       p = new((void*) gvp) TEvtHeader;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_493_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtHeader*) G__getstructoffset())->initialize((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_493_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEvtHeader*) G__getstructoffset())->getEventId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_493_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEvtHeader*) G__getstructoffset())->getRunId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_493_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TEvtHeader*) G__getstructoffset())->time());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_493_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtHeader*) G__getstructoffset())->setTime((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_493_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TEvtHeader*) G__getstructoffset())->getEventTag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_493_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtHeader*) G__getstructoffset())->setFlag1((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_493_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtHeader*) G__getstructoffset())->setFlag2((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_493_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TEvtHeader*) G__getstructoffset())->getFlag1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_493_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TEvtHeader*) G__getstructoffset())->getFlag2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_493_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvtHeader::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_493_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtHeader::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_493_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvtHeader::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_493_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvtHeader::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_493_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtHeader*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_493_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtHeader::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_493_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvtHeader::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_493_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtHeader::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_493_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvtHeader::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_493_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEvtHeader* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEvtHeader(*(TEvtHeader*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvtHeader G__TTEvtHeader;
static int G__RootEventData_rootcint_493_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEvtHeader*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvtHeader*) (soff+(sizeof(TEvtHeader)*i)))->~G__TTEvtHeader();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvtHeader*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvtHeader*) (soff))->~G__TTEvtHeader();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_493_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvtHeader* dest = (TEvtHeader*) G__getstructoffset();
   *dest = *(TEvtHeader*) libp->para[0].ref;
   const TEvtHeader& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvtNavigator */
static int G__RootEventData_rootcint_503_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvtNavigator* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvtNavigator[n];
     } else {
       p = new((void*) gvp) TEvtNavigator[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvtNavigator;
     } else {
       p = new((void*) gvp) TEvtNavigator;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtNavigator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_503_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtNavigator*) G__getstructoffset())->LoadMcMdcMcHits(*(multimap<int,int>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_503_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtNavigator*) G__getstructoffset())->LoadMcMdcTracks(*(multimap<int,int>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_503_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtNavigator*) G__getstructoffset())->LoadMcEmcMcHits(*(multimap<int,int>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_503_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtNavigator*) G__getstructoffset())->LoadMcEmcRecShowers(*(multimap<int,int>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_503_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvtNavigator::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_503_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtNavigator::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_503_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvtNavigator::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_503_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvtNavigator::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_503_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtNavigator*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_503_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtNavigator::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_503_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvtNavigator::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_503_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtNavigator::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_503_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvtNavigator::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_503_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEvtNavigator* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEvtNavigator(*(TEvtNavigator*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtNavigator));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvtNavigator G__TTEvtNavigator;
static int G__RootEventData_rootcint_503_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEvtNavigator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvtNavigator*) (soff+(sizeof(TEvtNavigator)*i)))->~G__TTEvtNavigator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvtNavigator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvtNavigator*) (soff))->~G__TTEvtNavigator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_503_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvtNavigator* dest = (TEvtNavigator*) G__getstructoffset();
   *dest = *(TEvtNavigator*) libp->para[0].ref;
   const TEvtNavigator& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TTrigData */
static int G__RootEventData_rootcint_507_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTrigData* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTrigData[n];
     } else {
       p = new((void*) gvp) TTrigData[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTrigData;
     } else {
       p = new((void*) gvp) TTrigData;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_507_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTrigData*) G__getstructoffset())->setTrigCondition((int) G__int(libp->para[0]), (int) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_507_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTrigData*) G__getstructoffset())->setTrigCondition((const int*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_507_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTrigData*) G__getstructoffset())->setTrigChannel((int) G__int(libp->para[0]), (int) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_507_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTrigData*) G__getstructoffset())->setTrigChannel((const int*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_507_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTrigData*) G__getstructoffset())->setTimeWindow((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_507_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTrigData*) G__getstructoffset())->setTimingType((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_507_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTrigData*) G__getstructoffset())->setPreScale((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_507_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TTrigData*) G__getstructoffset())->getTrigCondition((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_507_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TTrigData*) G__getstructoffset())->getTrigCondition());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_507_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TTrigData*) G__getstructoffset())->getTrigChannel((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_507_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TTrigData*) G__getstructoffset())->getTrigChannel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_507_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TTrigData*) G__getstructoffset())->getTimeWindow());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_507_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TTrigData*) G__getstructoffset())->getTimingType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_507_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TTrigData*) G__getstructoffset())->getPreScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_507_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TTrigData::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_507_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTrigData::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_507_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TTrigData::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_507_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTrigData::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_507_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTrigData*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_507_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTrigData::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_507_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTrigData::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_507_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTrigData::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_507_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTrigData::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_507_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TTrigData* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TTrigData(*(TTrigData*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TTrigData G__TTTrigData;
static int G__RootEventData_rootcint_507_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TTrigData*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TTrigData*) (soff+(sizeof(TTrigData)*i)))->~G__TTTrigData();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TTrigData*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TTrigData*) (soff))->~G__TTTrigData();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_507_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTrigData* dest = (TTrigData*) G__getstructoffset();
   *dest = *(TTrigData*) libp->para[0].ref;
   const TTrigData& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TTrigEvent */
static int G__RootEventData_rootcint_508_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTrigEvent* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTrigEvent[n];
     } else {
       p = new((void*) gvp) TTrigEvent[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTrigEvent;
     } else {
       p = new((void*) gvp) TTrigEvent;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_508_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTrigEvent*) G__getstructoffset())->initialize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_508_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTrigEvent*) G__getstructoffset())->addTrigData((TTrigData*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_508_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TTrigEvent*) G__getstructoffset())->getTrigData());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_508_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTrigEvent*) G__getstructoffset())->clearTrigData();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_508_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TTrigEvent::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_508_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTrigEvent::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_508_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TTrigEvent::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_508_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTrigEvent::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_508_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTrigEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_508_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTrigEvent::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_508_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTrigEvent::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_508_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTrigEvent::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_508_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTrigEvent::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_508_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TTrigEvent* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TTrigEvent(*(TTrigEvent*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TTrigEvent G__TTTrigEvent;
static int G__RootEventData_rootcint_508_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TTrigEvent*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TTrigEvent*) (soff+(sizeof(TTrigEvent)*i)))->~G__TTTrigEvent();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TTrigEvent*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TTrigEvent*) (soff))->~G__TTTrigEvent();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_508_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTrigEvent* dest = (TTrigEvent*) G__getstructoffset();
   *dest = *(TTrigEvent*) libp->para[0].ref;
   const TTrigEvent& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THltRaw */
static int G__RootEventData_rootcint_509_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THltRaw* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THltRaw[n];
     } else {
       p = new((void*) gvp) THltRaw[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THltRaw;
     } else {
       p = new((void*) gvp) THltRaw;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_509_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THltRaw::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_509_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THltRaw::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_509_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THltRaw::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_509_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THltRaw::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_509_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THltRaw*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_509_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THltRaw::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_509_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THltRaw::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_509_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THltRaw::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_509_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THltRaw::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_509_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   THltRaw* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new THltRaw(*(THltRaw*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THltRaw G__TTHltRaw;
static int G__RootEventData_rootcint_509_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (THltRaw*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THltRaw*) (soff+(sizeof(THltRaw)*i)))->~G__TTHltRaw();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THltRaw*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THltRaw*) (soff))->~G__TTHltRaw();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_509_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THltRaw* dest = (THltRaw*) G__getstructoffset();
   *dest = *(THltRaw*) libp->para[0].ref;
   const THltRaw& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THltInf */
static int G__RootEventData_rootcint_510_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THltInf* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THltInf[n];
     } else {
       p = new((void*) gvp) THltInf[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THltInf;
     } else {
       p = new((void*) gvp) THltInf;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THltInf*) G__getstructoffset())->setEventType((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THltInf*) G__getstructoffset())->setAlgProcess((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THltInf*) G__getstructoffset())->setCriteriaTable((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THltInf*) G__getstructoffset())->setVersion((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THltInf*) G__getstructoffset())->setTotalEnergy((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THltInf*) G__getstructoffset())->setNumber((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THltInf*) G__getstructoffset())->setNCON((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THltInf*) G__getstructoffset())->setMdcData(*(vector<Int_t>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THltInf*) G__getstructoffset())->setTofData(*(vector<Int_t>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THltInf*) G__getstructoffset())->setEmcData(*(vector<Int_t>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THltInf*) G__getstructoffset())->setMucData(*(vector<Int_t>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THltInf*) G__getstructoffset())->setConData(*(vector<Int_t>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const THltInf*) G__getstructoffset())->getEventType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const THltInf*) G__getstructoffset())->getAlgProcess());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const THltInf*) G__getstructoffset())->getCriteriaTable());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const THltInf*) G__getstructoffset())->getVersion());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const THltInf*) G__getstructoffset())->getTotalEnergy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const THltInf*) G__getstructoffset())->getNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const THltInf*) G__getstructoffset())->getNCON());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Int_t>* pobj;
         const vector<Int_t> xobj = ((const THltInf*) G__getstructoffset())->getMdcData();
         pobj = new vector<Int_t>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Int_t>* pobj;
         const vector<Int_t> xobj = ((const THltInf*) G__getstructoffset())->getTofData();
         pobj = new vector<Int_t>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Int_t>* pobj;
         const vector<Int_t> xobj = ((const THltInf*) G__getstructoffset())->getEmcData();
         pobj = new vector<Int_t>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Int_t>* pobj;
         const vector<Int_t> xobj = ((const THltInf*) G__getstructoffset())->getMucData();
         pobj = new vector<Int_t>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Int_t>* pobj;
         const vector<Int_t> xobj = ((const THltInf*) G__getstructoffset())->getConData();
         pobj = new vector<Int_t>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THltInf::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THltInf::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THltInf::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THltInf::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THltInf*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THltInf::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THltInf::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THltInf::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_510_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THltInf::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_510_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   THltInf* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new THltInf(*(THltInf*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THltInf G__TTHltInf;
static int G__RootEventData_rootcint_510_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (THltInf*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THltInf*) (soff+(sizeof(THltInf)*i)))->~G__TTHltInf();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THltInf*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THltInf*) (soff))->~G__TTHltInf();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_510_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THltInf* dest = (THltInf*) G__getstructoffset();
   *dest = *(THltInf*) libp->para[0].ref;
   const THltInf& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TDstHltInf */
static int G__RootEventData_rootcint_511_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDstHltInf* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDstHltInf[n];
     } else {
       p = new((void*) gvp) TDstHltInf[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDstHltInf;
     } else {
       p = new((void*) gvp) TDstHltInf;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_511_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstHltInf*) G__getstructoffset())->setEventType((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_511_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstHltInf*) G__getstructoffset())->setAlgProcess((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_511_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstHltInf*) G__getstructoffset())->setCriteriaTable((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_511_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstHltInf*) G__getstructoffset())->setVersion((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_511_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstHltInf*) G__getstructoffset())->setTotalEnergy((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_511_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstHltInf*) G__getstructoffset())->setNumber((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_511_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstHltInf*) G__getstructoffset())->setNCON((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_511_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TDstHltInf*) G__getstructoffset())->getEventType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_511_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TDstHltInf*) G__getstructoffset())->getAlgProcess());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_511_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TDstHltInf*) G__getstructoffset())->getCriteriaTable());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_511_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TDstHltInf*) G__getstructoffset())->getVersion());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_511_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TDstHltInf*) G__getstructoffset())->getTotalEnergy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_511_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TDstHltInf*) G__getstructoffset())->getNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_511_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TDstHltInf*) G__getstructoffset())->getNCON());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_511_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TDstHltInf::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_511_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDstHltInf::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_511_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TDstHltInf::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_511_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TDstHltInf::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_511_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDstHltInf*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_511_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDstHltInf::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_511_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TDstHltInf::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_511_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDstHltInf::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_511_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TDstHltInf::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_511_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TDstHltInf* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TDstHltInf(*(TDstHltInf*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TDstHltInf G__TTDstHltInf;
static int G__RootEventData_rootcint_511_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TDstHltInf*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TDstHltInf*) (soff+(sizeof(TDstHltInf)*i)))->~G__TTDstHltInf();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TDstHltInf*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TDstHltInf*) (soff))->~G__TTDstHltInf();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_511_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDstHltInf* dest = (TDstHltInf*) G__getstructoffset();
   *dest = *(TDstHltInf*) libp->para[0].ref;
   const TDstHltInf& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THltEvent */
static int G__RootEventData_rootcint_512_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THltEvent* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THltEvent[n];
     } else {
       p = new((void*) gvp) THltEvent[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THltEvent;
     } else {
       p = new((void*) gvp) THltEvent;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_512_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THltEvent*) G__getstructoffset())->initialize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_512_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THltEvent*) G__getstructoffset())->addHltRaw((THltRaw*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_512_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const THltEvent*) G__getstructoffset())->getHltRaw((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_512_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const THltEvent*) G__getstructoffset())->getHltRawCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_512_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THltEvent*) G__getstructoffset())->clearHltRawCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_512_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THltEvent*) G__getstructoffset())->addHltInf((THltInf*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_512_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const THltEvent*) G__getstructoffset())->getHltInf());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_512_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THltEvent*) G__getstructoffset())->clearHltInf();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_512_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THltEvent*) G__getstructoffset())->addDstHltInf((TDstHltInf*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_512_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const THltEvent*) G__getstructoffset())->getDstHltInf());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_512_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THltEvent*) G__getstructoffset())->clearDstHltInf();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_512_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THltEvent::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_512_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THltEvent::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_512_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THltEvent::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_512_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THltEvent::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_512_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THltEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_512_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THltEvent::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_512_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THltEvent::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_512_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THltEvent::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_512_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THltEvent::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_512_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   THltEvent* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new THltEvent(*(THltEvent*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THltEvent G__TTHltEvent;
static int G__RootEventData_rootcint_512_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (THltEvent*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THltEvent*) (soff+(sizeof(THltEvent)*i)))->~G__TTHltEvent();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THltEvent*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THltEvent*) (soff))->~G__TTHltEvent();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_512_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THltEvent* dest = (THltEvent*) G__getstructoffset();
   *dest = *(THltEvent*) libp->para[0].ref;
   const THltEvent& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TDisTrack */
static int G__RootEventData_rootcint_513_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDisTrack* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDisTrack[n];
     } else {
       p = new((void*) gvp) TDisTrack[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDisTrack;
     } else {
       p = new((void*) gvp) TDisTrack;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDisTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDisTrack*) G__getstructoffset())->initialize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getRecMdcTrackCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDisTrack*) G__getstructoffset())->addRecMdcTrack((TRecMdcTrack*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getRecMdcTrack((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDisTrack*) G__getstructoffset())->clearRecMdcTrackCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getRecMdcHitCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDisTrack*) G__getstructoffset())->addRecMdcHit((TRecMdcHit*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getRecMdcHit((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDisTrack*) G__getstructoffset())->clearRecMdcHitCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getTofTrackCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDisTrack*) G__getstructoffset())->addTofTrack((TRecTofTrack*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getTofTrack((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDisTrack*) G__getstructoffset())->clearTofTrackCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getMucTrackCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDisTrack*) G__getstructoffset())->addMucTrack((TRecMucTrack*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getMucTrack((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDisTrack*) G__getstructoffset())->clearMucTrackCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TDisTrack*) G__getstructoffset())->getMdcTrackNum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TDisTrack*) G__getstructoffset())->getTofTrackNum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TDisTrack*) G__getstructoffset())->getEmcShowerNum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TDisTrack*) G__getstructoffset())->getMucTrackNum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TDisTrack*) G__getstructoffset())->getMdcHitNum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getEmcShowerCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDisTrack*) G__getstructoffset())->addEmcShower((TRecEmcShower*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TDisTrack*) G__getstructoffset())->getEmcShower((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDisTrack*) G__getstructoffset())->clearEmcShowerCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TDisTrack::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDisTrack::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TDisTrack::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TDisTrack::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDisTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDisTrack::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TDisTrack::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDisTrack::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_513_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TDisTrack::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_513_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TDisTrack* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TDisTrack(*(TDisTrack*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDisTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TDisTrack G__TTDisTrack;
static int G__RootEventData_rootcint_513_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TDisTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TDisTrack*) (soff+(sizeof(TDisTrack)*i)))->~G__TTDisTrack();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TDisTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TDisTrack*) (soff))->~G__TTDisTrack();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_513_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDisTrack* dest = (TDisTrack*) G__getstructoffset();
   *dest = *(TDisTrack*) libp->para[0].ref;
   const TDisTrack& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvtRecEvent */
static int G__RootEventData_rootcint_514_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvtRecEvent* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvtRecEvent[n];
     } else {
       p = new((void*) gvp) TEvtRecEvent[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvtRecEvent;
     } else {
       p = new((void*) gvp) TEvtRecEvent;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecEvent*) G__getstructoffset())->initialize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecEvent*) G__getstructoffset())->totalTracks());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecEvent*) G__getstructoffset())->totalCharged());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecEvent*) G__getstructoffset())->totalNeutral());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecEvent*) G__getstructoffset())->numberOfVee());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecEvent*) G__getstructoffset())->numberOfPi0());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecEvent*) G__getstructoffset())->numberOfEtaToGG());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecEvent*) G__getstructoffset())->numberOfDTag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecEvent*) G__getstructoffset())->setTotalTracks((const int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecEvent*) G__getstructoffset())->setTotalCharged((const int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecEvent*) G__getstructoffset())->setTotalNeutral((const int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecEvent*) G__getstructoffset())->setNumberOfVee((const int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecEvent*) G__getstructoffset())->setNumberOfPi0((const int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecEvent*) G__getstructoffset())->setNumberOfEtaToGG((const int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecEvent*) G__getstructoffset())->setNumberOfDTag((const int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvtRecEvent::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecEvent::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvtRecEvent::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvtRecEvent::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecEvent::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvtRecEvent::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecEvent::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_514_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvtRecEvent::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_514_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEvtRecEvent* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEvtRecEvent(*(TEvtRecEvent*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvtRecEvent G__TTEvtRecEvent;
static int G__RootEventData_rootcint_514_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEvtRecEvent*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvtRecEvent*) (soff+(sizeof(TEvtRecEvent)*i)))->~G__TTEvtRecEvent();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvtRecEvent*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvtRecEvent*) (soff))->~G__TTEvtRecEvent();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_514_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvtRecEvent* dest = (TEvtRecEvent*) G__getstructoffset();
   *dest = *(TEvtRecEvent*) libp->para[0].ref;
   const TEvtRecEvent& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvtRecTrack */
static int G__RootEventData_rootcint_515_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvtRecTrack* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvtRecTrack[n];
     } else {
       p = new((void*) gvp) TEvtRecTrack[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvtRecTrack;
     } else {
       p = new((void*) gvp) TEvtRecTrack;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->trackId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->partId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->quality());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->mdcTrackId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->mdcKalTrackId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->mdcDedxId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->extTrackId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->emcShowerId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecTrack*) G__getstructoffset())->mucTrackId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Int_t>& obj = ((const TEvtRecTrack*) G__getstructoffset())->tofTrackIds();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecTrack*) G__getstructoffset())->setTrackId((const int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecTrack*) G__getstructoffset())->setPartId((const int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecTrack*) G__getstructoffset())->setQuality((const int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecTrack*) G__getstructoffset())->setMdcTrackId((const int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecTrack*) G__getstructoffset())->setMdcKalTrackId((const int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecTrack*) G__getstructoffset())->setMdcDedxId((const int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecTrack*) G__getstructoffset())->setExtTrackId((const int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecTrack*) G__getstructoffset())->setEmcShowerId((const int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecTrack*) G__getstructoffset())->setMucTrackId((const int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecTrack*) G__getstructoffset())->setTofTrackIds(*(vector<Int_t>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecTrack*) G__getstructoffset())->addTofTrackId((const int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvtRecTrack::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecTrack::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvtRecTrack::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvtRecTrack::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecTrack::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvtRecTrack::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecTrack::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_515_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvtRecTrack::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_515_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEvtRecTrack* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEvtRecTrack(*(TEvtRecTrack*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvtRecTrack G__TTEvtRecTrack;
static int G__RootEventData_rootcint_515_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEvtRecTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvtRecTrack*) (soff+(sizeof(TEvtRecTrack)*i)))->~G__TTEvtRecTrack();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvtRecTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvtRecTrack*) (soff))->~G__TTEvtRecTrack();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_515_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvtRecTrack* dest = (TEvtRecTrack*) G__getstructoffset();
   *dest = *(TEvtRecTrack*) libp->para[0].ref;
   const TEvtRecTrack& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvtRecPrimaryVertex */
static int G__RootEventData_rootcint_516_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvtRecPrimaryVertex* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvtRecPrimaryVertex[n];
     } else {
       p = new((void*) gvp) TEvtRecPrimaryVertex[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvtRecPrimaryVertex;
     } else {
       p = new((void*) gvp) TEvtRecPrimaryVertex;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEvtRecPrimaryVertex*) G__getstructoffset())->isValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecPrimaryVertex*) G__getstructoffset())->nTracks());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Int_t>& obj = ((const TEvtRecPrimaryVertex*) G__getstructoffset())->trackIdList();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecPrimaryVertex*) G__getstructoffset())->chi2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecPrimaryVertex*) G__getstructoffset())->ndof());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecPrimaryVertex*) G__getstructoffset())->fitMethod());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecPrimaryVertex*) G__getstructoffset())->vertex((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecPrimaryVertex*) G__getstructoffset())->errorVertex((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecPrimaryVertex*) G__getstructoffset())->setIsValid((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecPrimaryVertex*) G__getstructoffset())->setNTracks((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecPrimaryVertex*) G__getstructoffset())->setTrackIdList(*(vector<Int_t>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecPrimaryVertex*) G__getstructoffset())->setChi2((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecPrimaryVertex*) G__getstructoffset())->setNdof((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecPrimaryVertex*) G__getstructoffset())->setFitMethod((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecPrimaryVertex*) G__getstructoffset())->setVertex((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecPrimaryVertex*) G__getstructoffset())->setErrorVertex((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvtRecPrimaryVertex::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecPrimaryVertex::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvtRecPrimaryVertex::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvtRecPrimaryVertex::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecPrimaryVertex*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecPrimaryVertex::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvtRecPrimaryVertex::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecPrimaryVertex::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_516_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvtRecPrimaryVertex::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_516_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEvtRecPrimaryVertex* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEvtRecPrimaryVertex(*(TEvtRecPrimaryVertex*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvtRecPrimaryVertex G__TTEvtRecPrimaryVertex;
static int G__RootEventData_rootcint_516_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEvtRecPrimaryVertex*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvtRecPrimaryVertex*) (soff+(sizeof(TEvtRecPrimaryVertex)*i)))->~G__TTEvtRecPrimaryVertex();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvtRecPrimaryVertex*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvtRecPrimaryVertex*) (soff))->~G__TTEvtRecPrimaryVertex();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_516_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvtRecPrimaryVertex* dest = (TEvtRecPrimaryVertex*) G__getstructoffset();
   *dest = *(TEvtRecPrimaryVertex*) libp->para[0].ref;
   const TEvtRecPrimaryVertex& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvtRecVeeVertex */
static int G__RootEventData_rootcint_517_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvtRecVeeVertex* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvtRecVeeVertex[n];
     } else {
       p = new((void*) gvp) TEvtRecVeeVertex[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvtRecVeeVertex;
     } else {
       p = new((void*) gvp) TEvtRecVeeVertex;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecVeeVertex*) G__getstructoffset())->vertexId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecVeeVertex*) G__getstructoffset())->vertexType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecVeeVertex*) G__getstructoffset())->chi2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecVeeVertex*) G__getstructoffset())->ndof());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecVeeVertex*) G__getstructoffset())->mass());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecVeeVertex*) G__getstructoffset())->w((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecVeeVertex*) G__getstructoffset())->Ew((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecVeeVertex*) G__getstructoffset())->pair((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecVeeVertex*) G__getstructoffset())->nCharge());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecVeeVertex*) G__getstructoffset())->nTracks());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecVeeVertex*) G__getstructoffset())->daughter((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecVeeVertex*) G__getstructoffset())->setVertexId((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecVeeVertex*) G__getstructoffset())->setVertexType((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecVeeVertex*) G__getstructoffset())->setChi2((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecVeeVertex*) G__getstructoffset())->setNdof((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecVeeVertex*) G__getstructoffset())->setMass((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecVeeVertex*) G__getstructoffset())->setW((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecVeeVertex*) G__getstructoffset())->setEw((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecVeeVertex*) G__getstructoffset())->setPair((Int_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecVeeVertex*) G__getstructoffset())->setNCharge((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecVeeVertex*) G__getstructoffset())->setNTracks((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecVeeVertex*) G__getstructoffset())->setDaughter((Int_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvtRecVeeVertex::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecVeeVertex::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvtRecVeeVertex::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvtRecVeeVertex::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecVeeVertex*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecVeeVertex::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvtRecVeeVertex::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecVeeVertex::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_517_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvtRecVeeVertex::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_517_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEvtRecVeeVertex* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEvtRecVeeVertex(*(TEvtRecVeeVertex*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvtRecVeeVertex G__TTEvtRecVeeVertex;
static int G__RootEventData_rootcint_517_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEvtRecVeeVertex*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvtRecVeeVertex*) (soff+(sizeof(TEvtRecVeeVertex)*i)))->~G__TTEvtRecVeeVertex();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvtRecVeeVertex*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvtRecVeeVertex*) (soff))->~G__TTEvtRecVeeVertex();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_517_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvtRecVeeVertex* dest = (TEvtRecVeeVertex*) G__getstructoffset();
   *dest = *(TEvtRecVeeVertex*) libp->para[0].ref;
   const TEvtRecVeeVertex& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvtRecPi0 */
static int G__RootEventData_rootcint_518_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvtRecPi0* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvtRecPi0[n];
     } else {
       p = new((void*) gvp) TEvtRecPi0[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvtRecPi0;
     } else {
       p = new((void*) gvp) TEvtRecPi0;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->unconMass());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->chisq());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->hiPxfit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->hiPyfit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->hiPzfit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->hiPefit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->loPxfit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->loPyfit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->loPzfit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecPi0*) G__getstructoffset())->loPefit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecPi0*) G__getstructoffset())->hiEnGamma());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecPi0*) G__getstructoffset())->loEnGamma());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecPi0*) G__getstructoffset())->setUnconMass((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecPi0*) G__getstructoffset())->setChisq((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecPi0*) G__getstructoffset())->setHiPxfit((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecPi0*) G__getstructoffset())->setHiPyfit((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecPi0*) G__getstructoffset())->setHiPzfit((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecPi0*) G__getstructoffset())->setHiPefit((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecPi0*) G__getstructoffset())->setLoPxfit((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecPi0*) G__getstructoffset())->setLoPyfit((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecPi0*) G__getstructoffset())->setLoPzfit((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecPi0*) G__getstructoffset())->setLoPefit((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecPi0*) G__getstructoffset())->setHiEnGamma((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecPi0*) G__getstructoffset())->setLoEnGamma((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvtRecPi0::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecPi0::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvtRecPi0::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvtRecPi0::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecPi0*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecPi0::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvtRecPi0::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecPi0::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_518_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvtRecPi0::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_518_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEvtRecPi0* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEvtRecPi0(*(TEvtRecPi0*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvtRecPi0 G__TTEvtRecPi0;
static int G__RootEventData_rootcint_518_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEvtRecPi0*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvtRecPi0*) (soff+(sizeof(TEvtRecPi0)*i)))->~G__TTEvtRecPi0();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvtRecPi0*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvtRecPi0*) (soff))->~G__TTEvtRecPi0();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_518_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvtRecPi0* dest = (TEvtRecPi0*) G__getstructoffset();
   *dest = *(TEvtRecPi0*) libp->para[0].ref;
   const TEvtRecPi0& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvtRecEtaToGG */
static int G__RootEventData_rootcint_519_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvtRecEtaToGG* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvtRecEtaToGG[n];
     } else {
       p = new((void*) gvp) TEvtRecEtaToGG[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvtRecEtaToGG;
     } else {
       p = new((void*) gvp) TEvtRecEtaToGG;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->unconMass());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->chisq());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->hiPxfit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->hiPyfit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->hiPzfit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->hiPefit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->loPxfit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->loPyfit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->loPzfit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecEtaToGG*) G__getstructoffset())->loPefit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecEtaToGG*) G__getstructoffset())->hiEnGamma());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecEtaToGG*) G__getstructoffset())->loEnGamma());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecEtaToGG*) G__getstructoffset())->setUnconMass((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecEtaToGG*) G__getstructoffset())->setChisq((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecEtaToGG*) G__getstructoffset())->setHiPxfit((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecEtaToGG*) G__getstructoffset())->setHiPyfit((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecEtaToGG*) G__getstructoffset())->setHiPzfit((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecEtaToGG*) G__getstructoffset())->setHiPefit((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecEtaToGG*) G__getstructoffset())->setLoPxfit((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecEtaToGG*) G__getstructoffset())->setLoPyfit((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecEtaToGG*) G__getstructoffset())->setLoPzfit((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecEtaToGG*) G__getstructoffset())->setLoPefit((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecEtaToGG*) G__getstructoffset())->setHiEnGamma((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecEtaToGG*) G__getstructoffset())->setLoEnGamma((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvtRecEtaToGG::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecEtaToGG::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvtRecEtaToGG::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvtRecEtaToGG::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecEtaToGG*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecEtaToGG::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvtRecEtaToGG::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecEtaToGG::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_519_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvtRecEtaToGG::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_519_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEvtRecEtaToGG* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEvtRecEtaToGG(*(TEvtRecEtaToGG*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvtRecEtaToGG G__TTEvtRecEtaToGG;
static int G__RootEventData_rootcint_519_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEvtRecEtaToGG*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvtRecEtaToGG*) (soff+(sizeof(TEvtRecEtaToGG)*i)))->~G__TTEvtRecEtaToGG();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvtRecEtaToGG*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvtRecEtaToGG*) (soff))->~G__TTEvtRecEtaToGG();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_519_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvtRecEtaToGG* dest = (TEvtRecEtaToGG*) G__getstructoffset();
   *dest = *(TEvtRecEtaToGG*) libp->para[0].ref;
   const TEvtRecEtaToGG& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvtRecDTag */
static int G__RootEventData_rootcint_520_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvtRecDTag* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvtRecDTag[n];
     } else {
       p = new((void*) gvp) TEvtRecDTag[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvtRecDTag;
     } else {
       p = new((void*) gvp) TEvtRecDTag;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecDTag*) G__getstructoffset())->decayMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecDTag*) G__getstructoffset())->type());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->beamE());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->mass());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->mBC());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->deltaE());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecDTag*) G__getstructoffset())->charge());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecDTag*) G__getstructoffset())->charm());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvtRecDTag*) G__getstructoffset())->numOfChildren());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->px());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->py());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->pz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvtRecDTag*) G__getstructoffset())->pe());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Int_t>& obj = ((const TEvtRecDTag*) G__getstructoffset())->tracks();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Int_t>& obj = ((const TEvtRecDTag*) G__getstructoffset())->showers();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Int_t>& obj = ((const TEvtRecDTag*) G__getstructoffset())->otherTracks();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Int_t>& obj = ((const TEvtRecDTag*) G__getstructoffset())->otherShowers();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Int_t>& obj = ((const TEvtRecDTag*) G__getstructoffset())->pionId();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Int_t>& obj = ((const TEvtRecDTag*) G__getstructoffset())->kaonId();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->setdecayMode((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->settype((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->setbeamE((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->setmass((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->setmBC((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->setdeltaE((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->setcharge((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->setcharm((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->setnumOfChildren((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->setpx((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->setpy((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->setpz((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->setpe((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->setTracks(*(vector<Int_t>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->setShowers(*(vector<Int_t>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->setOtherTracks(*(vector<Int_t>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->setOtherShowers(*(vector<Int_t>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->setPionId(*(vector<Int_t>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->setKaonId(*(vector<Int_t>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->addTrack((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->addShower((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->addOtherTrack((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->addOtherShower((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->addPionId((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->addKaonId((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvtRecDTag::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecDTag::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvtRecDTag::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvtRecDTag::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecDTag*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecDTag::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvtRecDTag::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecDTag::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_520_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvtRecDTag::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_520_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEvtRecDTag* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEvtRecDTag(*(TEvtRecDTag*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvtRecDTag G__TTEvtRecDTag;
static int G__RootEventData_rootcint_520_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEvtRecDTag*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvtRecDTag*) (soff+(sizeof(TEvtRecDTag)*i)))->~G__TTEvtRecDTag();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvtRecDTag*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvtRecDTag*) (soff))->~G__TTEvtRecDTag();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_520_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvtRecDTag* dest = (TEvtRecDTag*) G__getstructoffset();
   *dest = *(TEvtRecDTag*) libp->para[0].ref;
   const TEvtRecDTag& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvtRecObject */
static int G__RootEventData_rootcint_521_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvtRecObject* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvtRecObject[n];
     } else {
       p = new((void*) gvp) TEvtRecObject[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvtRecObject;
     } else {
       p = new((void*) gvp) TEvtRecObject;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecObject*) G__getstructoffset())->initialize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecEvent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecObject*) G__getstructoffset())->setEvtRecEvent((TEvtRecEvent*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecTrackCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecObject*) G__getstructoffset())->addEvtRecTrack((TEvtRecTrack*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecTrack((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecObject*) G__getstructoffset())->clearEvtRecTrackCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecPrimaryVertex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecObject*) G__getstructoffset())->setEvtRecPrimaryVertex((TEvtRecPrimaryVertex*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecVeeVertexCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecObject*) G__getstructoffset())->addEvtRecVeeVertex((TEvtRecVeeVertex*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecVeeVertex((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecObject*) G__getstructoffset())->clearEvtRecVeeVertexCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecPi0Col());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecObject*) G__getstructoffset())->addEvtRecPi0((TEvtRecPi0*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecPi0((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecObject*) G__getstructoffset())->clearEvtRecPi0Col();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecEtaToGGCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecObject*) G__getstructoffset())->addEvtRecEtaToGG((TEvtRecEtaToGG*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecEtaToGG((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecObject*) G__getstructoffset())->clearEvtRecEtaToGGCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecDTagCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecObject*) G__getstructoffset())->addEvtRecDTag((TEvtRecDTag*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEvtRecObject*) G__getstructoffset())->getEvtRecDTag((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecObject*) G__getstructoffset())->clearEvtRecDTagCol();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvtRecObject::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecObject::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvtRecObject::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvtRecObject::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvtRecObject*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecObject::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvtRecObject::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvtRecObject::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_521_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvtRecObject::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_521_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEvtRecObject* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEvtRecObject(*(TEvtRecObject*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvtRecObject G__TTEvtRecObject;
static int G__RootEventData_rootcint_521_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEvtRecObject*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvtRecObject*) (soff+(sizeof(TEvtRecObject)*i)))->~G__TTEvtRecObject();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvtRecObject*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvtRecObject*) (soff))->~G__TTEvtRecObject();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_521_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvtRecObject* dest = (TEvtRecObject*) G__getstructoffset();
   *dest = *(TEvtRecObject*) libp->para[0].ref;
   const TEvtRecObject& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMcHitTof */
static int G__RootEventData_rootcint_559_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMcHitTof* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMcHitTof[n];
     } else {
       p = new((void*) gvp) TMcHitTof[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMcHitTof;
     } else {
       p = new((void*) gvp) TMcHitTof;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitTof*) G__getstructoffset())->SetTrackIndex((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitTof*) G__getstructoffset())->SetG4Index((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitTof*) G__getstructoffset())->SetPartId((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitTof*) G__getstructoffset())->SetScinNb((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitTof*) G__getstructoffset())->SetEdep((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitTof*) G__getstructoffset())->SetStepL((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitTof*) G__getstructoffset())->SetTrackL((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitTof*) G__getstructoffset())->SetPos(*((TVector3*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitTof*) G__getstructoffset())->SetTime((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitTof*) G__getstructoffset())->SetDeltaT((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitTof*) G__getstructoffset())->SetPDirection(*((TVector3*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitTof*) G__getstructoffset())->SetMomentum(*((TVector3*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitTof*) G__getstructoffset())->SetCharge((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMcHitTof*) G__getstructoffset())->GetTrackIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMcHitTof*) G__getstructoffset())->GetG4Index());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMcHitTof*) G__getstructoffset())->GetPartId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMcHitTof*) G__getstructoffset())->GetScinNb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcHitTof*) G__getstructoffset())->GetEdep());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcHitTof*) G__getstructoffset())->GetStepL());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcHitTof*) G__getstructoffset())->GetTrackL());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const TMcHitTof*) G__getstructoffset())->GetPos();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcHitTof*) G__getstructoffset())->GetTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcHitTof*) G__getstructoffset())->GetDeltaT());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const TMcHitTof*) G__getstructoffset())->GetPDirection();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const TMcHitTof*) G__getstructoffset())->GetMomentum();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMcHitTof*) G__getstructoffset())->GetCharge());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMcHitTof::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMcHitTof::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMcHitTof::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMcHitTof::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitTof*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMcHitTof::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMcHitTof::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMcHitTof::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_559_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMcHitTof::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_559_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMcHitTof* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMcHitTof(*(TMcHitTof*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMcHitTof G__TTMcHitTof;
static int G__RootEventData_rootcint_559_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMcHitTof*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMcHitTof*) (soff+(sizeof(TMcHitTof)*i)))->~G__TTMcHitTof();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMcHitTof*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMcHitTof*) (soff))->~G__TTMcHitTof();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_559_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMcHitTof* dest = (TMcHitTof*) G__getstructoffset();
   *dest = *(TMcHitTof*) libp->para[0].ref;
   const TMcHitTof& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMcHitMdc */
static int G__RootEventData_rootcint_560_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMcHitMdc* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMcHitMdc[n];
     } else {
       p = new((void*) gvp) TMcHitMdc[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMcHitMdc;
     } else {
       p = new((void*) gvp) TMcHitMdc;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitMdc*) G__getstructoffset())->SetTrackID((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitMdc*) G__getstructoffset())->SetLayerNo((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitMdc*) G__getstructoffset())->SetCellNo((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitMdc*) G__getstructoffset())->SetEdep((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitMdc*) G__getstructoffset())->SetPos(*((TVector3*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitMdc*) G__getstructoffset())->SetDriftD((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitMdc*) G__getstructoffset())->SetDriftT((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitMdc*) G__getstructoffset())->SetGlobalT((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitMdc*) G__getstructoffset())->SetTheta((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitMdc*) G__getstructoffset())->SetEnterAngle((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitMdc*) G__getstructoffset())->SetPosFlag((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMcHitMdc*) G__getstructoffset())->GetTrackID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMcHitMdc*) G__getstructoffset())->GetLayerNo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMcHitMdc*) G__getstructoffset())->GetCellNo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcHitMdc*) G__getstructoffset())->GetEdep());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const TMcHitMdc*) G__getstructoffset())->GetPos();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcHitMdc*) G__getstructoffset())->GetDriftD());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcHitMdc*) G__getstructoffset())->GetDriftT());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcHitMdc*) G__getstructoffset())->GetGlobalT());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcHitMdc*) G__getstructoffset())->GetTheta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcHitMdc*) G__getstructoffset())->GetEnterAngle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMcHitMdc*) G__getstructoffset())->GetPosFlag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMcHitMdc::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMcHitMdc::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMcHitMdc::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMcHitMdc::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitMdc*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMcHitMdc::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMcHitMdc::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMcHitMdc::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_560_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMcHitMdc::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_560_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMcHitMdc* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMcHitMdc(*(TMcHitMdc*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMcHitMdc G__TTMcHitMdc;
static int G__RootEventData_rootcint_560_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMcHitMdc*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMcHitMdc*) (soff+(sizeof(TMcHitMdc)*i)))->~G__TTMcHitMdc();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMcHitMdc*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMcHitMdc*) (soff))->~G__TTMcHitMdc();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_560_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMcHitMdc* dest = (TMcHitMdc*) G__getstructoffset();
   *dest = *(TMcHitMdc*) libp->para[0].ref;
   const TMcHitMdc& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMcDigiEmc */
static int G__RootEventData_rootcint_561_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMcDigiEmc* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMcDigiEmc[n];
     } else {
       p = new((void*) gvp) TMcDigiEmc[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMcDigiEmc;
     } else {
       p = new((void*) gvp) TMcDigiEmc;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_561_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcDigiEmc*) G__getstructoffset())->SetPartId((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_561_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcDigiEmc*) G__getstructoffset())->SetThetaNb((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_561_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcDigiEmc*) G__getstructoffset())->SetPhiNb((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_561_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcDigiEmc*) G__getstructoffset())->SetEnergy((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_561_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcDigiEmc*) G__getstructoffset())->SetTime((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_561_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcDigiEmc*) G__getstructoffset())->SetTrackIndex((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_561_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMcDigiEmc*) G__getstructoffset())->GetPartId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_561_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMcDigiEmc*) G__getstructoffset())->GetThetaNb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_561_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMcDigiEmc*) G__getstructoffset())->GetPhiNb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_561_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcDigiEmc*) G__getstructoffset())->GetEnergy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_561_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcDigiEmc*) G__getstructoffset())->GetTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_561_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMcDigiEmc*) G__getstructoffset())->GetTrackIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_561_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMcDigiEmc::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_561_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMcDigiEmc::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_561_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMcDigiEmc::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_561_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMcDigiEmc::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_561_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcDigiEmc*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_561_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMcDigiEmc::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_561_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMcDigiEmc::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_561_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMcDigiEmc::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_561_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMcDigiEmc::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_561_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMcDigiEmc* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMcDigiEmc(*(TMcDigiEmc*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMcDigiEmc G__TTMcDigiEmc;
static int G__RootEventData_rootcint_561_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMcDigiEmc*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMcDigiEmc*) (soff+(sizeof(TMcDigiEmc)*i)))->~G__TTMcDigiEmc();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMcDigiEmc*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMcDigiEmc*) (soff))->~G__TTMcDigiEmc();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_561_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMcDigiEmc* dest = (TMcDigiEmc*) G__getstructoffset();
   *dest = *(TMcDigiEmc*) libp->para[0].ref;
   const TMcDigiEmc& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMcHitEvent */
static int G__RootEventData_rootcint_562_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMcHitEvent* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMcHitEvent[n];
     } else {
       p = new((void*) gvp) TMcHitEvent[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMcHitEvent;
     } else {
       p = new((void*) gvp) TMcHitEvent;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_562_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMcHitEvent*) G__getstructoffset())->getMcHitTofCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_562_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitEvent*) G__getstructoffset())->addMcHitTof((TMcHitTof*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_562_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMcHitEvent*) G__getstructoffset())->getMcHitTof((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_562_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMcHitEvent*) G__getstructoffset())->getMcHitMdcCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_562_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitEvent*) G__getstructoffset())->addMcHitMdc((TMcHitMdc*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_562_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMcHitEvent*) G__getstructoffset())->getMcHitMdc((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_562_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMcHitEvent*) G__getstructoffset())->getMcDigiEmcCol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_562_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitEvent*) G__getstructoffset())->addMcDigiEmc((TMcDigiEmc*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_562_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMcHitEvent*) G__getstructoffset())->getMcDigiEmc((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_562_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitEvent*) G__getstructoffset())->setBeamTime((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_562_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMcHitEvent*) G__getstructoffset())->getBeamTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_562_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMcHitEvent::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_562_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMcHitEvent::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_562_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMcHitEvent::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_562_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMcHitEvent::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_562_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMcHitEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_562_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMcHitEvent::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_562_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMcHitEvent::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_562_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMcHitEvent::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_562_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMcHitEvent::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_562_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMcHitEvent* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMcHitEvent(*(TMcHitEvent*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMcHitEvent G__TTMcHitEvent;
static int G__RootEventData_rootcint_562_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMcHitEvent*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMcHitEvent*) (soff+(sizeof(TMcHitEvent)*i)))->~G__TTMcHitEvent();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMcHitEvent*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMcHitEvent*) (soff))->~G__TTMcHitEvent();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_562_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMcHitEvent* dest = (TMcHitEvent*) G__getstructoffset();
   *dest = *(TMcHitEvent*) libp->para[0].ref;
   const TMcHitEvent& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TBossFullEvent */
static int G__RootEventData_rootcint_563_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBossFullEvent* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBossFullEvent[n];
     } else {
       p = new((void*) gvp) TBossFullEvent[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBossFullEvent;
     } else {
       p = new((void*) gvp) TBossFullEvent;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBossFullEvent*) G__getstructoffset())->copy((TBossFullEvent*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBossFullEvent*) G__getstructoffset())->reset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBossFullEvent*) G__getstructoffset())->setEvtHeader((TEvtHeader*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBossFullEvent*) G__getstructoffset())->setDigiEvent((TDigiEvent*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBossFullEvent*) G__getstructoffset())->setDstEvent((TDstEvent*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBossFullEvent*) G__getstructoffset())->setMcEvent((TMcEvent*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBossFullEvent*) G__getstructoffset())->setTrigEvent((TTrigEvent*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBossFullEvent*) G__getstructoffset())->setHltEvent((THltEvent*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBossFullEvent*) G__getstructoffset())->setRecTrackEvent((TRecTrackEvent*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBossFullEvent*) G__getstructoffset())->setEvtRecObject((TEvtRecObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getEvtHeader());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getDigiEvent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getDstEvent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getMcEvent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getTrigEvent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getHltEvent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getRecTrackEvent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TBossFullEvent*) G__getstructoffset())->getEvtRecObject());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TBossFullEvent::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TBossFullEvent::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TBossFullEvent::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TBossFullEvent::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBossFullEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TBossFullEvent::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TBossFullEvent::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TBossFullEvent::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RootEventData_rootcint_563_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TBossFullEvent::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RootEventData_rootcint_563_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TBossFullEvent* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TBossFullEvent(*(TBossFullEvent*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TBossFullEvent G__TTBossFullEvent;
static int G__RootEventData_rootcint_563_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TBossFullEvent*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TBossFullEvent*) (soff+(sizeof(TBossFullEvent)*i)))->~G__TTBossFullEvent();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TBossFullEvent*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TBossFullEvent*) (soff))->~G__TTBossFullEvent();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RootEventData_rootcint_563_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBossFullEvent* dest = (TBossFullEvent*) G__getstructoffset();
   *dest = *(TBossFullEvent*) libp->para[0].ref;
   const TBossFullEvent& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */

/*********************************************************
* Member function Stub
*********************************************************/

/* TJobInfo */

/* TRawData */

/* TMdcDigi */

/* TEmcDigi */

/* TTofDigi */

/* TMucDigi */

/* TLumiDigi */

/* TDigiEvent */

/* TRecMdcTrack */

/* TRecMdcKalTrack */

/* TRecMdcHit */

/* TTofTrack */

/* TRecTofTrack */

/* TRecEmcHit */

/* TRecEmcCluster */

/* TRecEmcShower */

/* TRecMucTrack */

/* TRecMdcDedx */

/* TRecMdcDedxHit */

/* TRecExtTrack */

/* TRecEvTime */

/* TRecMdcKalHelixSeg */

/* TRecZddChannel */

/* TRecTrackEvent */

/* TMdcTrack */

/* TEmcTrack */

/* TMucTrack */

/* TMdcDedx */

/* TExtTrack */

/* TMdcKalTrack */

/* TDstEvent */

/* TMdcMc */

/* TEmcMc */

/* TTofMc */

/* TMucMc */

/* TMcParticle */

/* TMcEvent */

/* TEvtHeader */

/* TEvtNavigator */

/* TTrigData */

/* TTrigEvent */

/* THltRaw */

/* THltInf */

/* TDstHltInf */

/* THltEvent */

/* TDisTrack */

/* TEvtRecEvent */

/* TEvtRecTrack */

/* TEvtRecPrimaryVertex */

/* TEvtRecVeeVertex */

/* TEvtRecPi0 */

/* TEvtRecEtaToGG */

/* TEvtRecDTag */

/* TEvtRecObject */

/* TMcHitTof */

/* TMcHitMdc */

/* TMcDigiEmc */

/* TMcHitEvent */

/* TBossFullEvent */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncRootEventData_rootcint {
 public:
  G__Sizep2memfuncRootEventData_rootcint(): p(&G__Sizep2memfuncRootEventData_rootcint::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncRootEventData_rootcint::*p)();
};

size_t G__get_sizep2memfuncRootEventData_rootcint()
{
  G__Sizep2memfuncRootEventData_rootcint a;
  G__setsizep2memfunc((int)a.sizep2memfunc());
  return((size_t)a.sizep2memfunc());
}


/*********************************************************
* virtual base class offset calculation interface
*********************************************************/

   /* Setting up class inheritance */

/*********************************************************
* Inheritance information setup/
*********************************************************/
extern "C" void G__cpp_setup_inheritanceRootEventData_rootcint() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TJobInfo))) {
     TJobInfo *G__Lderived;
     G__Lderived=(TJobInfo*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TJobInfo),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData))) {
     TRawData *G__Lderived;
     G__Lderived=(TRawData*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi))) {
     TMdcDigi *G__Lderived;
     G__Lderived=(TMdcDigi*)0x1000;
     {
       TRawData *G__Lpbase=(TRawData*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi))) {
     TEmcDigi *G__Lderived;
     G__Lderived=(TEmcDigi*)0x1000;
     {
       TRawData *G__Lpbase=(TRawData*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi))) {
     TTofDigi *G__Lderived;
     G__Lderived=(TTofDigi*)0x1000;
     {
       TRawData *G__Lpbase=(TRawData*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi))) {
     TMucDigi *G__Lderived;
     G__Lderived=(TMucDigi*)0x1000;
     {
       TRawData *G__Lpbase=(TRawData*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi))) {
     TLumiDigi *G__Lderived;
     G__Lderived=(TLumiDigi*)0x1000;
     {
       TRawData *G__Lpbase=(TRawData*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent))) {
     TDigiEvent *G__Lderived;
     G__Lderived=(TDigiEvent*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack))) {
     TRecMdcTrack *G__Lderived;
     G__Lderived=(TRecMdcTrack*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalTrack))) {
     TRecMdcKalTrack *G__Lderived;
     G__Lderived=(TRecMdcKalTrack*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit))) {
     TRecMdcHit *G__Lderived;
     G__Lderived=(TRecMdcHit*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofTrack))) {
     TTofTrack *G__Lderived;
     G__Lderived=(TTofTrack*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack))) {
     TRecTofTrack *G__Lderived;
     G__Lderived=(TRecTofTrack*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcHit))) {
     TRecEmcHit *G__Lderived;
     G__Lderived=(TRecEmcHit*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcHit),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcCluster))) {
     TRecEmcCluster *G__Lderived;
     G__Lderived=(TRecEmcCluster*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcCluster),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower))) {
     TRecEmcShower *G__Lderived;
     G__Lderived=(TRecEmcShower*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack))) {
     TRecMucTrack *G__Lderived;
     G__Lderived=(TRecMucTrack*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedx))) {
     TRecMdcDedx *G__Lderived;
     G__Lderived=(TRecMdcDedx*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedx),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedxHit))) {
     TRecMdcDedxHit *G__Lderived;
     G__Lderived=(TRecMdcDedxHit*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedxHit),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecExtTrack))) {
     TRecExtTrack *G__Lderived;
     G__Lderived=(TRecExtTrack*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecExtTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEvTime))) {
     TRecEvTime *G__Lderived;
     G__Lderived=(TRecEvTime*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEvTime),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg))) {
     TRecMdcKalHelixSeg *G__Lderived;
     G__Lderived=(TRecMdcKalHelixSeg*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel))) {
     TRecZddChannel *G__Lderived;
     G__Lderived=(TRecZddChannel*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent))) {
     TRecTrackEvent *G__Lderived;
     G__Lderived=(TRecTrackEvent*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack))) {
     TMdcTrack *G__Lderived;
     G__Lderived=(TMdcTrack*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack))) {
     TEmcTrack *G__Lderived;
     G__Lderived=(TEmcTrack*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack))) {
     TMucTrack *G__Lderived;
     G__Lderived=(TMucTrack*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx))) {
     TMdcDedx *G__Lderived;
     G__Lderived=(TMdcDedx*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack))) {
     TExtTrack *G__Lderived;
     G__Lderived=(TExtTrack*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack))) {
     TMdcKalTrack *G__Lderived;
     G__Lderived=(TMdcKalTrack*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent))) {
     TDstEvent *G__Lderived;
     G__Lderived=(TDstEvent*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc))) {
     TMdcMc *G__Lderived;
     G__Lderived=(TMdcMc*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc))) {
     TEmcMc *G__Lderived;
     G__Lderived=(TEmcMc*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc))) {
     TTofMc *G__Lderived;
     G__Lderived=(TTofMc*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc))) {
     TMucMc *G__Lderived;
     G__Lderived=(TMucMc*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle))) {
     TMcParticle *G__Lderived;
     G__Lderived=(TMcParticle*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent))) {
     TMcEvent *G__Lderived;
     G__Lderived=(TMcEvent*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader))) {
     TEvtHeader *G__Lderived;
     G__Lderived=(TEvtHeader*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtNavigator))) {
     TEvtNavigator *G__Lderived;
     G__Lderived=(TEvtNavigator*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtNavigator),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData))) {
     TTrigData *G__Lderived;
     G__Lderived=(TTrigData*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent))) {
     TTrigEvent *G__Lderived;
     G__Lderived=(TTrigEvent*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw))) {
     THltRaw *G__Lderived;
     G__Lderived=(THltRaw*)0x1000;
     {
       TRawData *G__Lpbase=(TRawData*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf))) {
     THltInf *G__Lderived;
     G__Lderived=(THltInf*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf))) {
     TDstHltInf *G__Lderived;
     G__Lderived=(TDstHltInf*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent))) {
     THltEvent *G__Lderived;
     G__Lderived=(THltEvent*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDisTrack))) {
     TDisTrack *G__Lderived;
     G__Lderived=(TDisTrack*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDisTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent))) {
     TEvtRecEvent *G__Lderived;
     G__Lderived=(TEvtRecEvent*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack))) {
     TEvtRecTrack *G__Lderived;
     G__Lderived=(TEvtRecTrack*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex))) {
     TEvtRecPrimaryVertex *G__Lderived;
     G__Lderived=(TEvtRecPrimaryVertex*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex))) {
     TEvtRecVeeVertex *G__Lderived;
     G__Lderived=(TEvtRecVeeVertex*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0))) {
     TEvtRecPi0 *G__Lderived;
     G__Lderived=(TEvtRecPi0*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG))) {
     TEvtRecEtaToGG *G__Lderived;
     G__Lderived=(TEvtRecEtaToGG*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag))) {
     TEvtRecDTag *G__Lderived;
     G__Lderived=(TEvtRecDTag*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject))) {
     TEvtRecObject *G__Lderived;
     G__Lderived=(TEvtRecObject*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof))) {
     TMcHitTof *G__Lderived;
     G__Lderived=(TMcHitTof*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc))) {
     TMcHitMdc *G__Lderived;
     G__Lderived=(TMcHitMdc*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc))) {
     TMcDigiEmc *G__Lderived;
     G__Lderived=(TMcDigiEmc*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitEvent))) {
     TMcHitEvent *G__Lderived;
     G__Lderived=(TMcHitEvent*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitEvent),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEvent))) {
     TBossFullEvent *G__Lderived;
     G__Lderived=(TBossFullEvent*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEvent),G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableRootEventData_rootcint() {

   /* Setting up typedef entry */
   G__search_typename2("Int_t",105,-1,0,-1);
   G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
   G__search_typename2("UInt_t",104,-1,0,-1);
   G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
   G__search_typename2("Double_t",100,-1,0,-1);
   G__setnewtype(-1,"Double 8 bytes",0);
   G__search_typename2("Bool_t",103,-1,0,-1);
   G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
   G__search_typename2("Version_t",115,-1,0,-1);
   G__setnewtype(-1,"Class version identifier (short)",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<string>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<int>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Int_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<Int_t,Double_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,double>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,double,less<int> >",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Double_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TString>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<Double_t> >",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<double,allocator<double> > >",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Int_t,Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_pairlEintcOfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::pair<Int_t,Float_t> >",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<Int_t,Float_t> >",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<int,float> >",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Fragments",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR),0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("multimap<int,int>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("multimap<int,int,less<int> >",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTBaselEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTBaselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixT<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow_const<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTRow_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn_const<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTColumn_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag_const<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTDiag_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat_const<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTFlat_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub_const<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTSub_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow_const<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTSparseRow_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag_const<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTSparseDiag_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTRowlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTColumnlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTDiaglEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTFlatlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTSublEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTSparseRowlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMatrixTSparseDiaglEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementActionT<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TElementActionTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementPosActionT<Float_t>",117,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TElementPosActionTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* TJobInfo */
static void G__setup_memvarTJobInfo(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TJobInfo));
   { TJobInfo *p; p=(TJobInfo*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_string),-1,-1,4,"m_decayOptions=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_string),-1,-1,4,"m_bossVer=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR),G__defined_typename("vector<string>"),-1,4,"m_jobOptions=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<int>"),-1,4,"m_totEvtNo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRawData */
static void G__setup_memvarTRawData(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData));
   { TRawData *p; p=(TRawData*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_intId=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_timeChannel=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_chargeChannel=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMdcDigi */
static void G__setup_memvarTMdcDigi(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi));
   { TMdcDigi *p; p=(TMdcDigi*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_overflow=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEmcDigi */
static void G__setup_memvarTEmcDigi(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi));
   { TEmcDigi *p; p=(TEmcDigi*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_measure=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTofDigi */
static void G__setup_memvarTTofDigi(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi));
   { TTofDigi *p; p=(TTofDigi*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_overflow=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMucDigi */
static void G__setup_memvarTMucDigi(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi));
   { TMucDigi *p; p=(TMucDigi*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TLumiDigi */
static void G__setup_memvarTLumiDigi(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi));
   { TLumiDigi *p; p=(TLumiDigi*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_overflow=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TDigiEvent */
static void G__setup_memvarTDigiEvent(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent));
   { TDigiEvent *p; p=(TDigiEvent*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"m_fromMc=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMdcDigiCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mdcDigiCol=",0,"-> ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEmcDigiCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_emcDigiCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticTofDigiCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_tofDigiCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMucDigiCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mucDigiCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticLumiDigiCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_lumiDigiCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRecMdcTrack */
static void G__setup_memvarTRecMdcTrack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack));
   { TRecMdcTrack *p; p=(TRecMdcTrack*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,"Track Id Wensp add 2005-10-19 ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_helix[5]=",0,"5 track parameters");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_stat=",0,"Track Fit Quality");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chi2=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ndof=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_err[15]=",0,"Error  Matrix");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nhits=",0,"number of  total hits contained");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nster=",0,"number of  stereo hits contained");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nlayer=",0,"number of  layer hits contained");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_vx0=",0,"The coordinate of pivot(cm)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_vy0=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_vz0=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fiTerm=",0,"phi angle value at track terminated point");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRecMdcKalTrack */
static void G__setup_memvarTRecMdcKalTrack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalTrack));
   { TRecMdcKalTrack *p; p=(TRecMdcKalTrack*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,"Track Id wensp Add 2005-10-19 ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_mass[5]=",0,"mass assumption during the fit ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_length[5]=",0,"track path length from closest point to coord. origin to the last hit");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_tof[5]=",0,"time of flight correspond to length; ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fiTerm[5]=",0,"terminal phi ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pathSM[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nhits[5]=",0,"number of total hits contained ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nlayer[5]=",0,"number of layer that track passed");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_stat[2][5]=",0,"status flag ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chisq[2][5]=",0,"chi square of fit 0:filter 1:smoother ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ndf[2][5]=",0,"degree of freedom for the fit 0:filter 1:smoother ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nSegs[5]=",0,"number of segments");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_poca[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_poca_e[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_poca_mu[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_poca_k[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_poca_p[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpoint[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpoint_e[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpoint_mu[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpoint_k[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpoint_p[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpivot[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpivot_e[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpivot_mu[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpivot_k[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lpivot_p[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhelix[5]=",0,"5 track parameters at zero point for pi   ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zerror[5][5]=",0,"error matrix at zero point for pion       ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhelix_e[5]=",0,"5 track parameters at zero point for el   ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zerror_e[5][5]=",0,"error matrix at zero point for electron   ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhelix_mu[5]=",0,"5 track parameters at zero point for mu   ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zerror_mu[5][5]=",0,"error matrix at zero point  for muon   ;  ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhelix_k[5]=",0,"5 track parameters at zero point for ka   ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zerror_k[5][5]=",0,"error matrix at zero point for kaon       ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhelix_p[5]=",0,"5 track parameters at zero point for pr   ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zerror_p[5][5]=",0,"error matrix at zero point for proton     ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix[5]=",0,"5 track parameters at zero point for pi   ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror[5][5]=",0,"error matrix at zero point for pion       ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix_e[5]=",0,"5 track parameters at zero point for el   ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror_e[5][5]=",0,"error matrix at zero point for electron   ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix_mu[5]=",0,"5 track parameters at zero point for mu   ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror_mu[5][5]=",0,"error matrix at zero point  for muon   ;  ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix_k[5]=",0,"5 track parameters at zero point for ka   ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror_k[5][5]=",0,"error matrix at zero point for kaon       ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix_p[5]=",0,"5 track parameters at zero point for pr   ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror_p[5][5]=",0,"error matrix at zero point for proton     ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lhelix[5]=",0,"5 track parameters at zero point for pi    ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lerror[5][5]=",0,"error matrix at zero point for pion        ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lhelix_e[5]=",0,"5 track parameters at zero point for el    ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lerror_e[5][5]=",0,"error matrix at zero point for electron    ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lhelix_mu[5]=",0,"5 track parameters at zero point for mu    ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lerror_mu[5][5]=",0,"error matrix at zero point  for muon   ;   ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lhelix_k[5]=",0,"5 track parameters at zero point for ka    ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lerror_k[5][5]=",0,"error matrix at zero point for kaon        ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lhelix_p[5]=",0,"5 track parameters at zero point for pr    ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_lerror_p[5][5]=",0,"error matrix at zero point for proton      ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_thelix[5]=",0,"5 track parameters of track finding    ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_terror[15]=",0,"error matrix of track finding    ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRecMdcHit */
static void G__setup_memvarTRecMdcHit(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit));
   { TRecMdcHit *p; p=(TRecMdcHit*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"m_isGrouped=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_id=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trkid=",0,"id of track containing this hit,if this hit ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ddl=",0,"drift distance left");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ddr=",0,"drift distance right");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_erddl=",0,"error of drift distance left");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_erddr=",0,"error of drift distance right");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pChisq=",0,"contribution to chisquare");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_lr=",0,"flag indicating left or right 0:left 1:right 2:ambig");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_stat=",0,"status flag");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_mdcid=",0,"MDC identifier");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_tdc=",0,"corrected TDC");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_adc=",0,"corrected ADC");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_driftT=",0,"drift time");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_doca=",0,"distance of closesest approach for helix in the cell");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_entra=",0,"entrance angle in azimuth");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhit=",0,"z coordinate of the hit");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fltLen=",0,"flight length of this hit");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTofTrack */
static void G__setup_memvarTTofTrack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofTrack));
   { TTofTrack *p; p=(TTofTrack*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_tofTrackID=",0,"The ID of Tof Cluster reconstruction");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackID=",0,"Track ID from MDC / Shower ID from EMC.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_tofID=",0,"Tof Counter ID.");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_status=",0,"Status.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_path=",0,"Distance of flight.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zrhit=",0,"Track extrapolate Z or R Hit position.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ph=",0,"Pulse height.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_tof=",0,"Time of flight.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_beta=",0,"Beta value of the track.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_texp[5]=",0,"Expected time of flight of 5 sorts of particle.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_toffset[6]=",0,"Time offset of e, mu, pi, k and p and pbar.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_sigma[6]=",0,"Time resolution of 5+1 sorts of particle.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_quality=",0,"Data quality of reconstruction.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_t0=",0,"t0 from data set calibration.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errt0=",0,"t0 sigma from tof calibration.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errz=",0,"Error of zTDC(m_zrhit) for neutral track.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_phi=",0,"Angle of phi used for neutral track.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errphi=",0,"Error of angle of phi.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_energy=",0,"Energy deposit for neutral track.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errenergy=",0,"Error of energy deposit for neutral track. ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRecTofTrack */
static void G__setup_memvarTRecTofTrack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack));
   { TRecTofTrack *p; p=(TRecTofTrack*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_tofTrackID=",0,"The ID of Tof Cluster reconstruction");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackID=",0,"Track ID from MDC / Shower ID from EMC.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_tofID=",0,"Tof Counter ID.");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_status=",0,"Status.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_path=",0,"Distance of flight.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zrhit=",0,"Track extrapolate Z or R Hit position.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ph=",0,"Pulse height.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_tof=",0,"Time of flight.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_beta=",0,"Beta value of the track.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_texp[5]=",0,"Expected time of flight of 5 sorts of particle.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_toffset[6]=",0,"Time offset of e, mu, pi, k and p and pbar.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_sigma[6]=",0,"Time resolution of 5+1 sorts of particle.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_quality=",0,"Data quality of reconstruction.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_t0=",0,"t0 from data set calibration.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errt0=",0,"t0 sigma from tof calibration.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errz=",0,"Error of zTDC(m_zrhit) for neutral track.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_phi=",0,"Angle of phi used for neutral track.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errphi=",0,"Error of angle of phi.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_energy=",0,"Energy deposit for neutral track");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errenergy=",0,"Error of energy deposit for neutral track. ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRecEmcHit */
static void G__setup_memvarTRecEmcHit(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcHit));
   { TRecEmcHit *p; p=(TRecEmcHit*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_cellId=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_energy=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_time=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRecEmcCluster */
static void G__setup_memvarTRecEmcCluster(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcCluster));
   { TRecEmcCluster *p; p=(TRecEmcCluster*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_clusterId=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_vecHits=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_vecSeeds=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_vecShowers=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRecEmcShower */
static void G__setup_memvarTRecEmcShower(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower));
   { TRecEmcShower *p; p=(TRecEmcShower*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,"Track Id wensp Add 2005-10-19  ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numHits=",0,"Total number of hits");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_status=",0,"Status");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_cellId=",0,"Cell ID");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_module=",0,"Module");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_x=",0,"Shower coordinates and errors");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_y=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_z=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_theta=",0,"Shower Counter angles and errors");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dTheta=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_phi=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dPhi=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_energy=",0,"Total energy observed in Emc");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dE=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_eSeed=",0,"// Energy of seed, only one");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_e3x3=",0,"Energy of 3x3 crystals, totally 9 ones");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_e5x5=",0,"Energy of 5x5 crystals, totally 25 ones");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_eall=",0,"Energy of all crystals in the shower");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_elepton=",0,"Energy of all various number of crystals");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_time=",0,"Time");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_secondMoment=",0,"add 2006-07-03");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_latMoment=",0,"Lateral moment");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_a20Moment=",0,"Zernike moment");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_a42Moment=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_err[6]=",0,"Error Matrix: 0:dxx, 1:dyy, 2:dzz");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),G__defined_typename("map<Int_t,Double_t>"),-1,4,"m_cellIdMap=",0,"Hit list and its fraction");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_cellId3x3=",0,"Cell ID 3x3");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_cellId5x5=",0,"Cell ID 5x5");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_clusterId=",0,"Cluster ID");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRecMucTrack */
static void G__setup_memvarTRecMucTrack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack));
   { TRecMucTrack *p; p=(TRecMucTrack*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,"Track ID wensp Add 2005-10-19");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_id=",0,"Muc Identifier");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_status=",0,"Muc Status");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_type=",0,"Method of judge?");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_startPart=",0,"In which part does the start position of track locate");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_endPart=",0,"In which part does the end   position of track locate");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_brLastLayer=",0,"Last layer with hits in barrel ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ecLastLayer=",0,"Last layer with hits in endcap ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numHits=",0,"Number of hits on track");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numLayers=",0,"Number of layer with  hits");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_maxHitsInLayer=",0,"Max number of hits in a layer");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_depth=",0,"Depth of iron penetrated");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chi2=",0,"Fit parameters");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_dof=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_rms=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xPos=",0,"x position of muc track vertex");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yPos=",0,"y position of muc track vertex");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zPos=",0,"z position of muc track vertex");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xPosSigma=",0,"Sigma of x position of muc track vertex");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yPosSigma=",0,"Sigma of y position of muc track vertex");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zPosSigma=",0,"Sigma of z position of muc track vertex");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_px=",0,"px on muc track vertex");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_py=",0,"py on muc track vertex");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pz=",0,"pz on muc track vertex");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_distance=",0,"distance match of ext track with inner layer of Muc");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_deltaPhi=",0,"delta phi of mdc track and Muc hit in first layer");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_vecHits=",0,"// hit list of the track wensp Add 2005-10-20");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_expHits=",0,"// expected hit list of the track ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"m_distHits=",0,"// distance between attached hit and track ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_kalrechi2=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_kaldof=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_kaldepth=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_kalbrLastLayer=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_kalecLastLayer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRecMdcDedx */
static void G__setup_memvarTRecMdcDedx(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedx));
   { TRecMdcDedx *p; p=(TRecMdcDedx*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dedx_hit=",0,"double trucation mean of hit-level calib");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dedx_esat=",0,"double trucation mean of hit-level+electron saturation calib");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dedx_norun=",0,"double trucation mean of no run gain calib");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dedx_momentum=",0,"dE/dx calib used momentum");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,"Track Id wensp Add 2005-10-19");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mdcTrackId=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mdcKalTrackId=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_particleId=",0,"Particle ID from De/Dx fit");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_status=",0,"Status");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trunc_alg=",0,"truncate method");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiE=",0,"Number of sigama from e");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiMu=",0,"Number of sigama from muon");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiPi=",0,"Number of sigama from pion");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiK=",0,"Number of sigama from k");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiP=",0,"Number of sigama from p");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numGoodHits=",0,"No. of good de/dx hits(exclude overflow)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numTotalHits=",0,"No. of good de/dx hits(include overflow)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_probPH=",0,"Most probable pulse height from truncated mean");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_normPH=",0,"normalizd pulse height // Changed on Oct. 10 following by Wangdy");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errorPH=",0,"resolution of truncated mean ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_twentyPH=",0,"de/dx value of bitrunction rate equal to 20% ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chi[5]=",0,"Number of Chi_dEdx for different particles");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dedx_exp[5]=",0,"expected value of dE/dx for 5 particle hypotheses");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_sigma_dedx[5]=",0,"sigma value of dE/dx for 5 particle hypotheses");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pid_prob[5]=",0,"probability for each of  the 5 particle hypotheses");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRecMdcDedxHit */
static void G__setup_memvarTRecMdcDedxHit(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedxHit));
   { TRecMdcDedxHit *p; p=(TRecMdcDedxHit*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"m_isGrouped=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trkid=",0,"id of track containing this hit,if this hit belongs to no track, set as -1;");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mdcHitId=",0,"dE/dx hit reference to MdcHit;");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mdcKalHelixSegId=",0,"dE/dx hit reference to MdcKalHelixSeg;");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_lr=",0,"flag indicating left or right 0:left 1:right 2:ambig");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_mdcid=",0,"MDC identifier");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pathlength=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"m_dedx=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRecExtTrack */
static void G__setup_memvarTRecExtTrack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecExtTrack));
   { TRecExtTrack *p; p=(TRecExtTrack*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,"Track Id wensp Add 2005-10-19");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PositionX[5]=",0,"Position when the particle enters the TOF layer1.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PositionY[5]=",0,"Position when the particle enters the TOF layer1");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PositionZ[5]=",0,"Position when the particle enters the TOF layer1");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1MomentumX[5]=",0,"Momentum when the particle enters the TOF layer1.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1MomentumY[5]=",0,"Momentum when the particle enters the TOF layer1.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1MomentumZ[5]=",0,"Momentum when the particle enters the TOF layer1.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString),-1,-1,4,"myTof1VolumeName[5]=",0,"Scintillator volume name");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myTof1VolumeNumber[5]=",0,"Scintillator volume number");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1[5]=",0,"Time of flight");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1Path[5]=",0,"Path of flight");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongZ[5]=",0,"Sigma Z");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongT[5]=",0,"Sigma along Z x R");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongX[5]=",0,"Sigma X");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongY[5]=",0,"Sigma Y");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1ErrorMatrix[5][6][6]=",0,"Error matrix 6x6 (x,p)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PositionX[5]=",0,"Position when the particle enters the TOF layer2.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PositionY[5]=",0,"Position when the particle enters the TOF layer2");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PositionZ[5]=",0,"Position when the particle enters the TOF layer2");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2MomentumX[5]=",0,"Momentum when the particle enters the TOF layer2");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2MomentumY[5]=",0,"Momentum when the particle enters the TOF layer2");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2MomentumZ[5]=",0,"Momentum when the particle enters the TOF layer2");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString),-1,-1,4,"myTof2VolumeName[5]=",0,"Scintillator volume name");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myTof2VolumeNumber[5]=",0,"Scintillator volume number");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2[5]=",0,"Time of flight");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2Path[5]=",0,"Path of flight");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongZ[5]=",0,"Sigma Z");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongT[5]=",0,"Sigma along Z x R");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongX[5]=",0,"Sigma X");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongY[5]=",0,"Sigma Y");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2ErrorMatrix[5][6][6]=",0,"Error matrix 6x6 (x,p)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPositionX[5]=",0,"Position 2.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPositionY[5]=",0,"Position 2");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPositionZ[5]=",0,"Position 2");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcMomentumX[5]=",0,"Momentum ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcMomentumY[5]=",0,"Momentum ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcMomentumZ[5]=",0,"Momentum ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString),-1,-1,4,"myEmcVolumeName[5]=",0,"Scintillator volume name");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myEmcVolumeNumber[5]=",0,"Scintillator volume number");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPosSigmaAlongTheta[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPosSigmaAlongPhi[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcErrorMatrix[5][6][6]=",0,"Error matrix 6x6 (x,p)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPath[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPositionX[5]=",0,"Position 2.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPositionY[5]=",0,"Position 2");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPositionZ[5]=",0,"Position 2");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucMomentumX[5]=",0,"Momentum ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucMomentumY[5]=",0,"Momentum ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucMomentumZ[5]=",0,"Momentum ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString),-1,-1,4,"myMucVolumeName[5]=",0,"Scintillator volume name");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myMucVolumeNumber[5]=",0,"Scintillator volume number");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongZ[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongT[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongX[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongY[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucErrorMatrix[5][6][6]=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"mySize[5]=",0,"size of the vector ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"myPositionX[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"myPositionY[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"myPositionZ[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"myMomentumX[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"myMomentumY[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"myMomentumZ[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR),G__defined_typename("vector<TString>"),-1,4,"myVolumeName[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"myVolumeNumber[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"myPosSigmaAlongZ[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"myPosSigmaAlongT[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"myPosSigmaAlongX[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"myPosSigmaAlongY[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),G__defined_typename("vector<vector<Double_t> >"),-1,4,"myErrorMatrix[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRecEvTime */
static void G__setup_memvarTRecEvTime(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEvTime));
   { TRecEvTime *p; p=(TRecEvTime*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_status=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_estime=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_quality=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRecMdcKalHelixSeg */
static void G__setup_memvarTRecMdcKalHelixSeg(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg));
   { TRecMdcKalHelixSeg *p; p=(TRecMdcKalHelixSeg*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackid=",0,"id of track containing this hit,if this hit ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_lr=",0,"flag indicating left or right 0:left 1:right 2:ambig");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_mdcid=",0,"MDC identifier");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_tdc=",0,"corrected TDC");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_adc=",0,"corrected ADC");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhit=",0,"z coordinate of the hit");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_tof=",0,"time of flight ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_docaincl=",0,"distance of closesest approach for helix in the cell");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_docaexcl=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dd=",0,"drift distance ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_entra=",0,"entrance angle in azimuth");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_driftT=",0,"drift time");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_helixincl[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_helixexcl[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRecZddChannel */
static void G__setup_memvarTRecZddChannel(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel));
   { TRecZddChannel *p; p=(TRecZddChannel*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_chId=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_scanCode=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_baseLine=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_phase=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR),G__defined_typename("vector<std::pair<Int_t,Float_t> >"),-1,4,"m_frags=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRecTrackEvent */
static void G__setup_memvarTRecTrackEvent(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent));
   { TRecTrackEvent *p; p=(TRecTrackEvent*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticRecMdcTrackCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcTrackCol=",0,"->  ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticRecMdcHitCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcHitCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEmcHitCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recEmcHitCol=",0,"-> ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEmcClusterCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recEmcClusterCol=",0,"-> ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEmcShowerCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recEmcShowerCol=",0,"-> ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticTofTrackCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recTofTrackCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMucTrackCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMucTrackCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticRecMdcDedxCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcDedxCol=",0,"-> ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticRecMdcDedxHitCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcDedxHitCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticExtTrackCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recExtTrackCol=",0,"-> ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticRecMdcKalTrackCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcKalTrackCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticRecMdcKalHelixSegCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcKalHelixSegCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEvTimeCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recEvTimeCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticRecZddChannelCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recZddChannelCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMdcTrack */
static void G__setup_memvarTMdcTrack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack));
   { TMdcTrack *p; p=(TMdcTrack*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,"Track Id Wensp add 2005-10-19 ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_helix[5]=",0,"5 track parameters");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_err[15]=",0,"Error  Matrix");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_stat=",0,"Track Fit Quality");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chi2=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ndof=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nster=",0,"number of  stereo hits contained");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nlayer=",0,"number of  layer track passed");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_firstLayer=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_lastLayer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEmcTrack */
static void G__setup_memvarTEmcTrack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack));
   { TEmcTrack *p; p=(TEmcTrack*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,"Track Id wensp Add 2005-10-19  ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numHits=",0,"Total number of hits");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_status=",0,"Status");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_cellId=",0,"Cell ID");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_module=",0,"Module");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_x=",0,"Shower coordinates and errors");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_y=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_z=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dTheta=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dPhi=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_energy=",0,"Total energy observed in Emc");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_dE=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_eSeed=",0,"// Energy of seed, only one");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_e3x3=",0,"Energy of 3x3 crystals, totally 9 ones");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_e5x5=",0,"Energy of 5x5 crystals, totally 25 ones");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_time=",0,"Time measurement");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_secondMoment=",0,"add 2006-07-03");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_latMoment=",0,"Lateral moment");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_a20Moment=",0,"Zernike moment");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_a42Moment=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_err[6]=",0,"Error Matrix: 0:dxx, 1:dyy, 2:dzz");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMucTrack */
static void G__setup_memvarTMucTrack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack));
   { TMucTrack *p; p=(TMucTrack*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,"Track ID wensp Add 2005-10-19");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_id=",0,"Muc Identifier");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_status=",0,"Muc Status");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_type=",0,"Method of judge?");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_startPart=",0,"In which part does the start position of track locate");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_endPart=",0,"In which part does the end   position of track locate");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_brLastLayer=",0,"Last layer with hits in barrel ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ecLastLayer=",0,"Last layer with hits in endcap ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numHits=",0,"Number of hits on track");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numLayers=",0,"Number of layer with  hits");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_maxHitsInLayer=",0,"Max number of hits in a layer");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_depth=",0,"Depth of iron penetrated");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chi2=",0,"Fit parameters");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_dof=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_rms=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xPos=",0,"x position of muc track vertex");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yPos=",0,"y position of muc track vertex");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zPos=",0,"z position of muc track vertex");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xPosSigma=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yPosSigma=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zPosSigma=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_px=",0,"px on muc track vertex");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_py=",0,"py on muc track vertex");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pz=",0,"pz on muc track vertex");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_distance=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_deltaPhi=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_kalrechi2=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_kaldof=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_kaldepth=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_kalbrLastLayer=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_kalecLastLayer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMdcDedx */
static void G__setup_memvarTMdcDedx(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx));
   { TMdcDedx *p; p=(TMdcDedx*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,"Track Id wensp Add 2005-10-19");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_particleId=",0,"Particle ID from De/Dx fit");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_status=",0,"Status");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trunc_alg=",0,"truncate method");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiE=",0,"Number of sigama from e");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiMu=",0,"Number of sigama from muon");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiPi=",0,"Number of sigama from pion");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiK=",0,"Number of sigama from k");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chiP=",0,"Number of sigama from p");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numGoodHits=",0,"No. of good de/dx hits(exclude overflow)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_numTotalHits=",0,"No. of good de/dx hits(include overflow)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_probPH=",0,"Most probable pulse height from truncated mean");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_normPH=",0,"normalizd pulse height // Changed on Oct. 10 following by Wangdy");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_errorPH=",0,"resolution of truncated mean ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_twentyPH=",0,"de/dx value of bitrunction rate equal to 20% ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TExtTrack */
static void G__setup_memvarTExtTrack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack));
   { TExtTrack *p; p=(TExtTrack*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,"Track Id wensp Add 2005-10-19");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PositionX=",0,"Position when the particle enters the TOF layer1.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PositionY=",0,"Position when the particle enters the TOF layer1");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PositionZ=",0,"Position when the particle enters the TOF layer1");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1MomentumX=",0,"Momentum when the particle enters the TOF layer1.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1MomentumY=",0,"Momentum when the particle enters the TOF layer1.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1MomentumZ=",0,"Momentum when the particle enters the TOF layer1.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString),-1,-1,4,"myTof1VolumeName=",0,"Scintillator volume name");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myTof1VolumeNumber=",0,"Scintillator volume number");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1=",0,"Time of flight");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1Path=",0,"Path of flight");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongZ=",0,"Sigma Z");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongT=",0,"Sigma along Z x R");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongX=",0,"Sigma X");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1PosSigmaAlongY=",0,"Sigma Y");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof1ErrorMatrix[21]=",0,"Error matrix 6x6 (x,p)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PositionX=",0,"Position when the particle enters the TOF layer2.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PositionY=",0,"Position when the particle enters the TOF layer2");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PositionZ=",0,"Position when the particle enters the TOF layer2");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2MomentumX=",0,"Momentum when the particle enters the TOF layer2");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2MomentumY=",0,"Momentum when the particle enters the TOF layer2");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2MomentumZ=",0,"Momentum when the particle enters the TOF layer2");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString),-1,-1,4,"myTof2VolumeName=",0,"Scintillator volume name");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myTof2VolumeNumber=",0,"Scintillator volume number");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2=",0,"Time of flight");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2Path=",0,"Path of flight");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongZ=",0,"Sigma Z");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongT=",0,"Sigma along Z x R");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongX=",0,"Sigma X");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2PosSigmaAlongY=",0,"Sigma Y");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myTof2ErrorMatrix[21]=",0,"Error matrix 6x6 (x,p)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPositionX=",0,"Position 2.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPositionY=",0,"Position 2");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPositionZ=",0,"Position 2");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcMomentumX=",0,"Momentum ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcMomentumY=",0,"Momentum ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcMomentumZ=",0,"Momentum ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString),-1,-1,4,"myEmcVolumeName=",0,"Scintillator volume name");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myEmcVolumeNumber=",0,"Scintillator volume number");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPosSigmaAlongTheta=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPosSigmaAlongPhi=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcErrorMatrix[21]=",0,"Error matrix 6x6 (x,p)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myEmcPath=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPositionX=",0,"Position 2.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPositionY=",0,"Position 2");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPositionZ=",0,"Position 2");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucMomentumX=",0,"Momentum ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucMomentumY=",0,"Momentum ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucMomentumZ=",0,"Momentum ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString),-1,-1,4,"myMucVolumeName=",0,"Scintillator volume name");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"myMucVolumeNumber=",0,"Scintillator volume number");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongZ=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongT=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongX=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucPosSigmaAlongY=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"myMucErrorMatrix[21]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMdcKalTrack */
static void G__setup_memvarTMdcKalTrack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack));
   { TMdcKalTrack *p; p=(TMdcKalTrack*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_stat[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_stat2[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chisq[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ndf[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nlayer[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhelix[5]=",0,"5 track parameters at zero point for pi   ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zerror[15]=",0,"error matrix at zero point for pion       ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhelix_e[5]=",0,"5 track parameters at zero point for el   ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zerror_e[15]=",0,"error matrix at zero point for electron   ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhelix_mu[5]=",0,"5 track parameters at zero point for mu   ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zerror_mu[15]=",0,"error matrix at zero point  for muon   ;  ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhelix_k[5]=",0,"5 track parameters at zero point for ka   ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zerror_k[15]=",0,"error matrix at zero point for kaon       ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zhelix_p[5]=",0,"5 track parameters at zero point for pr   ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zerror_p[15]=",0,"error matrix at zero point for proton     ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix[5]=",0,"5 track parameters at first Mdchit  for pi   ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror[15]=",0,"error matrix at first Mdc hit for pion    ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix_e[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror_e[15]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix_mu[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror_mu[15]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix_k[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror_k[15]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_fhelix_p[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_ferror_p[15]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TDstEvent */
static void G__setup_memvarTDstEvent(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent));
   { TDstEvent *p; p=(TDstEvent*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEmcTrackCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_emcTrackCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMdcTrackCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mdcTrackCol=",0,"-> ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticTofTrackCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_tofTrackCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMucTrackCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mucTrackCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMdcDedxCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mdcDedxCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticExtTrackCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_extTrackCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMdcKalTrackCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mdcKalTrackCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMdcMc */
static void G__setup_memvarTMdcMc(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc));
   { TMdcMc *p; p=(TMdcMc*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_id=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xPosition=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yPosition=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zPosition=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_driftDistance=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_depositEnergy=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_posFlag=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEmcMc */
static void G__setup_memvarTEmcMc(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc));
   { TEmcMc *p; p=(TEmcMc*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_hitEmc=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_PDGCode=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_PDGCharge=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_time=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_id=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xPosition=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yPosition=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zPosition=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_px=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_py=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pz=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_depositEnergy=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),G__defined_typename("map<Int_t,Double_t>"),-1,4,"m_hitMap=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTofMc */
static void G__setup_memvarTTofMc(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc));
   { TTofMc *p; p=(TTofMc*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_id=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xPosition=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yPosition=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zPosition=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_px=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_py=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pz=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_trackLength=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_flightTime=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMucMc */
static void G__setup_memvarTMucMc(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc));
   { TMucMc *p; p=(TMucMc*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_id=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xPosition=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yPosition=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zPosition=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_px=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_py=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pz=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_depositEnergy=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMcParticle */
static void G__setup_memvarTMcParticle(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle));
   { TMcParticle *p; p=(TMcParticle*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticlecLcLStatusBits),-1,-2,1,G__FastAllocString(4096).Format("DECAYED=%lldLL",(long long)TMcParticle::DECAYED).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticlecLcLStatusBits),-1,-2,1,G__FastAllocString(4096).Format("DECAYFLT=%lldLL",(long long)TMcParticle::DECAYFLT).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticlecLcLStatusBits),-1,-2,1,G__FastAllocString(4096).Format("PRIMARY=%lldLL",(long long)TMcParticle::PRIMARY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticlecLcLStatusBits),-1,-2,1,G__FastAllocString(4096).Format("LEAF=%lldLL",(long long)TMcParticle::LEAF).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticlecLcLStatusBits),-1,-2,1,G__FastAllocString(4096).Format("ERROR=%lldLL",(long long)TMcParticle::ERROR).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_particleID=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_vertexIndex0=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_vertexIndex1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_statusFlags=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xInitialPosition=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yInitialPosition=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zInitialPosition=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_tInitialPosition=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xFinalPosition=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yFinalPosition=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zFinalPosition=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_tFinalPosition=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_xInitialMomentum=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_yInitialMomentum=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_zInitialMomentum=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_eInitialMomentum=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mother=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_daughters=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMcEvent */
static void G__setup_memvarTMcEvent(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent));
   { TMcEvent *p; p=(TMcEvent*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMdcMcHitCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mdcMcHitCol=",0,"-> ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEmcMcHitCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_emcMcHitCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticTofMcHitCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_tofMcHitCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMucMcHitCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mucMcHitCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticMcParticleCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_mcParticleCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvtHeader */
static void G__setup_memvarTEvtHeader(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader));
   { TEvtHeader *p; p=(TEvtHeader*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_eventId=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_runId=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_time=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_eventTag=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_flag1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_flag2=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvtNavigator */
static void G__setup_memvarTEvtNavigator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtNavigator));
   { TEvtNavigator *p; p=(TEvtNavigator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR),G__defined_typename("multimap<int,int>"),-1,4,"m_mcMdcMcHits=",0,"auxillary list McParticle id <-> MdcMcHit (=MdcRecHit) id");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR),G__defined_typename("multimap<int,int>"),-1,4,"m_mcMdcTracks=",0,"McParticle id <-> RecMdcTrack (RecMdcKalTrack) id");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR),G__defined_typename("multimap<int,int>"),-1,4,"m_mcEmcMcHits=",0,"auxiallry list McParticle id <-> EmcMcHit (=EmcRecHit) id");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR),G__defined_typename("multimap<int,int>"),-1,4,"m_mcEmcRecShowers=",0,"McParticle id <-> EmcRecShower id");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTrigData */
static void G__setup_memvarTTrigData(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData));
   { TTrigData *p; p=(TTrigData*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"m_preScale=",0,"PreScale for bhabha events");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trigcond[48]=",0,"Trigger conditions from 0 to 47");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trigChan[16]=",0,"Trigger channel from 0 to 15");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_timeWindow=",0,"The time window of trigger system");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_Timing=",0,"Time type, 0: No timing 1: TOF 2: MDC 3: EMC");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTrigEvent */
static void G__setup_memvarTTrigEvent(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent));
   { TTrigEvent *p; p=(TTrigEvent*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData),-1,-2,4,"s_staticTrigData=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData),-1,-1,4,"m_trigData=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THltRaw */
static void G__setup_memvarTHltRaw(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw));
   { THltRaw *p; p=(THltRaw*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THltInf */
static void G__setup_memvarTHltInf(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf));
   { THltInf *p; p=(THltInf*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_evtType=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_algProcess=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_criTable=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_verNumber=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_eTotal=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_subNumber=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_conNumber=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_mdcData=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_tofData=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_emcData=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_mucData=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_conData=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TDstHltInf */
static void G__setup_memvarTDstHltInf(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf));
   { TDstHltInf *p; p=(TDstHltInf*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_evtType=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_algProcess=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_criTable=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_verNumber=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_eTotal=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_subNumber=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_conNumber=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THltEvent */
static void G__setup_memvarTHltEvent(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent));
   { THltEvent *p; p=(THltEvent*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticHltRawCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_hltRawCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf),-1,-2,4,"s_staticHltInf=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf),-1,-1,4,"m_hltInf=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf),-1,-2,4,"s_staticDstHltInf=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf),-1,-1,4,"m_dstHltInf=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TDisTrack */
static void G__setup_memvarTDisTrack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDisTrack));
   { TDisTrack *p; p=(TDisTrack*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcTrackCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recTofTrackCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMdcHitCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recMucTrackCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_recEmcShowerCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvtRecEvent */
static void G__setup_memvarTEvtRecEvent(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent));
   { TEvtRecEvent *p; p=(TEvtRecEvent*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_tottks=",0,"total tracks");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nchrg=",0,"total charged tracks");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nneu=",0,"total neutral tracks");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nvee=",0,"number of VEEs: Ks, Lambda, gamma conversion");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_npi0=",0,"number of pi0'");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_neta=",0,"number of eta'");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ndtag=",0,"number of dtags'");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvtRecTrack */
static void G__setup_memvarTEvtRecTrack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack));
   { TEvtRecTrack *p; p=(TEvtRecTrack*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackId=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_partId=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_quality=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mdcTrackId=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mdcKalTrackId=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mdcDedxId=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_extTrackId=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_emcShowerId=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_mucTrackId=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_tofTrackIds=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvtRecPrimaryVertex */
static void G__setup_memvarTEvtRecPrimaryVertex(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex));
   { TEvtRecPrimaryVertex *p; p=(TEvtRecPrimaryVertex*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"m_isValid=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nTracks=",0,"number of tracks contributing to vertex fitting");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_trackIdList=",0,"id list of tracks contributing to vertex fitting");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chi2=",0,"chi square of vertex fitting");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ndof=",0,"degree of freedom ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_fitMethod=",0,"vertex fitting algorithm ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_vtx[3]=",0,"primary vertex position : (Vx, Vy, Vz)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_Evtx[6]=",0,"error matrix of primary vertex ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvtRecVeeVertex */
static void G__setup_memvarTEvtRecVeeVertex(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex));
   { TEvtRecVeeVertex *p; p=(TEvtRecVeeVertex*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_vertexId=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_vertexType=",0,"0 : Ks;  1 : Lambda; 2 : gamma conversion");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chi2=",0,"chi square of vertex fitting");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_ndof=",0,"degree of freedom");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_mass=",0,"mass of \"V\" type decay particle");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_w[7]=",0,"(px, py, pz, E, x, y, z) of \"V\" type decay particle");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_Ew[28]=",0,"error matrix");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_pair[2]=",0,"identification of daughter particles");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nCharge=",0,"total charges of daughter particles ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nTracks=",0,"total tracks of daughter particles");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_daughter[2]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvtRecPi0 */
static void G__setup_memvarTEvtRecPi0(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0));
   { TEvtRecPi0 *p; p=(TEvtRecPi0*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_unconMass=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chisq=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPx=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPy=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPz=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPe=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPx=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPy=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPz=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPe=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_hiEnGamma=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_loEnGamma=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvtRecEtaToGG */
static void G__setup_memvarTEvtRecEtaToGG(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG));
   { TEvtRecEtaToGG *p; p=(TEvtRecEtaToGG*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_unconMass=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_chisq=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPx=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPy=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPz=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_hiPe=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPx=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPy=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPz=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_loPe=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_hiEnGamma=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_loEnGamma=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvtRecDTag */
static void G__setup_memvarTEvtRecDTag(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag));
   { TEvtRecDTag *p; p=(TEvtRecDTag*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_decayMode=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_type=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_beamE=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_mass=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_mBC=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_deltaE=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_charge=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_charm=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_numOfChildren=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_px=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_py=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pz=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_pe=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_tracks=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_showers=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_otherTracks=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_otherShowers=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_pionId=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"m_kaonId=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvtRecObject */
static void G__setup_memvarTEvtRecObject(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject));
   { TEvtRecObject *p; p=(TEvtRecObject*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent),-1,-2,4,"s_staticEvtRecEvent=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent),-1,-1,4,"m_evtRecEvent=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEvtRecTrackCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_evtRecTrackCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex),-1,-2,4,"s_staticEvtRecPrimaryVertex=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex),-1,-1,4,"m_evtRecPrimaryVertex=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEvtRecVeeVertexCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_evtRecVeeVertexCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEvtRecPi0Col=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_evtRecPi0Col=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEvtRecEtaToGGCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_evtRecEtaToGGCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-2,4,"s_staticEvtRecDTagCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_evtRecDTagCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMcHitTof */
static void G__setup_memvarTMcHitTof(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof));
   { TMcHitTof *p; p=(TMcHitTof*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_g4Index=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_partId=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_scinNb=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_edep=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_stepL=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_trackL=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVector3),-1,-1,4,"m_pos=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_time=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_deltaT=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVector3),-1,-1,4,"m_pDirection=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVector3),-1,-1,4,"m_momentum=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_charge=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMcHitMdc */
static void G__setup_memvarTMcHitMdc(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc));
   { TMcHitMdc *p; p=(TMcHitMdc*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"trackID=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"layerNo=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"cellNo=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"edep=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVector3),-1,-1,4,"pos=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"driftD=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"driftT=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"globalT=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"theta=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"enterAngle=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"posFlag=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMcDigiEmc */
static void G__setup_memvarTMcDigiEmc(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc));
   { TMcDigiEmc *p; p=(TMcDigiEmc*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_partId=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nTheta=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_nPhi=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_energy=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_time=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"m_trackIndex=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMcHitEvent */
static void G__setup_memvarTMcHitEvent(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitEvent));
   { TMcHitEvent *p; p=(TMcHitEvent*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_tTofMcHitCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_tMdcMcHitCol=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray),-1,-1,4,"m_tEmcMcDigiCol=",0,"->");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"m_beamTime=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TBossFullEvent */
static void G__setup_memvarTBossFullEvent(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEvent));
   { TBossFullEvent *p; p=(TBossFullEvent*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEventcLcLdA),-1,-2,4,"hasEvtHeader=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEventcLcLdA),-1,-2,4,"hasDigiEvent=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEventcLcLdA),-1,-2,4,"hasDstEvent=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEventcLcLdA),-1,-2,4,"hasMcEvent=8LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEventcLcLdA),-1,-2,4,"hasTrigEvent=16LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEventcLcLdA),-1,-2,4,"hasHltEvent=32LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEventcLcLdA),-1,-2,4,"hasRecTrackEvent=64LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEventcLcLdA),-1,-2,4,"hasEvtRecObject=128LL",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"m_mask=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->m_EvtHeader)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader),-1,-1,1,"m_EvtHeader=",0,"->");
   G__memvar_setup((void*)((long)(&p->m_digiEvt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent),-1,-1,1,"m_digiEvt=",0,"->");
   G__memvar_setup((void*)((long)(&p->m_dstEvt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent),-1,-1,1,"m_dstEvt=",0,"->");
   G__memvar_setup((void*)((long)(&p->m_mcEvt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent),-1,-1,1,"m_mcEvt=",0,"->");
   G__memvar_setup((void*)((long)(&p->m_trigEvt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent),-1,-1,1,"m_trigEvt=",0,"->");
   G__memvar_setup((void*)((long)(&p->m_hltEvt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent),-1,-1,1,"m_hltEvt=",0,"->");
   G__memvar_setup((void*)((long)(&p->m_rectrackEvt)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent),-1,-1,1,"m_rectrackEvt=",0,"->");
   G__memvar_setup((void*)((long)(&p->m_evtRecObject)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject),-1,-1,1,"m_evtRecObject=",0,"->");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarRootEventData_rootcint() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTJobInfo(void) {
   /* TJobInfo */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TJobInfo));
   G__memfunc_setup("TJobInfo",763,G__RootEventData_rootcint_168_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TJobInfo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getBossVer",1028,G__RootEventData_rootcint_168_0_2, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getJobOptions",1351,G__RootEventData_rootcint_168_0_3, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR), G__defined_typename("vector<string>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getDecayOptions",1554,G__RootEventData_rootcint_168_0_4, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTotEvtNo",1123,G__RootEventData_rootcint_168_0_5, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<int>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setBossVer",1040,G__RootEventData_rootcint_168_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 0 - ver", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addJobOptions",1328,G__RootEventData_rootcint_168_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 0 - opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setJobOptions",1363,G__RootEventData_rootcint_168_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<string,allocator<string> >' 'vector<string>' 0 - opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDecayOptions",1566,G__RootEventData_rootcint_168_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 0 - opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTotEvtNo",1135,G__RootEventData_rootcint_168_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<int>' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_168_0_11, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TJobInfo::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_168_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TJobInfo::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_168_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TJobInfo::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_168_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TJobInfo::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_168_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_168_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TJobInfo::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_168_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TJobInfo::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_168_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TJobInfo::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_168_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TJobInfo::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TJobInfo", 763, G__RootEventData_rootcint_168_0_23, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TJobInfo), -1, 0, 1, 1, 1, 0, "u 'TJobInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TJobInfo", 889, G__RootEventData_rootcint_168_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_168_0_25, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TJobInfo), -1, 1, 1, 1, 1, 0, "u 'TJobInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRawData(void) {
   /* TRawData */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData));
   G__memfunc_setup("TRawData",760,G__RootEventData_rootcint_200_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_200_0_2, 121, -1, -1, 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 - id h - 'UInt_t' 0 '0' time "
"h - 'UInt_t' 0 '0' charge", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("setTrackIndex",1337,G__RootEventData_rootcint_200_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - trackIndex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getIntId",792,G__RootEventData_rootcint_200_0_6, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTimeChannel",1416,G__RootEventData_rootcint_200_0_7, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getChargeChannel",1603,G__RootEventData_rootcint_200_0_8, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTrackIndex",1325,G__RootEventData_rootcint_200_0_9, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_200_0_10, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRawData::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_200_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRawData::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_200_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRawData::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_200_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRawData::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_200_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_200_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRawData::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_200_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRawData::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_200_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRawData::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_200_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRawData::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TRawData", 760, G__RootEventData_rootcint_200_0_22, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData), -1, 0, 1, 1, 1, 0, "u 'TRawData' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TRawData", 886, G__RootEventData_rootcint_200_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_200_0_24, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRawData), -1, 1, 1, 1, 1, 0, "u 'TRawData' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMdcDigi(void) {
   /* TMdcDigi */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi));
   G__memfunc_setup("TMdcDigi",741,G__RootEventData_rootcint_201_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setOverflow",1184,G__RootEventData_rootcint_201_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - overflow", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getOverflow",1172,G__RootEventData_rootcint_201_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_201_0_4, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMdcDigi::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_201_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcDigi::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_201_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMdcDigi::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_201_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMdcDigi::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_201_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_201_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcDigi::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_201_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMdcDigi::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_201_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcDigi::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_201_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMdcDigi::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TMdcDigi", 741, G__RootEventData_rootcint_201_0_16, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi), -1, 0, 1, 1, 1, 0, "u 'TMdcDigi' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TMdcDigi", 867, G__RootEventData_rootcint_201_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_201_0_18, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi), -1, 1, 1, 1, 1, 0, "u 'TMdcDigi' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEmcDigi(void) {
   /* TEmcDigi */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi));
   G__memfunc_setup("TEmcDigi",742,G__RootEventData_rootcint_202_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setMeasure",1054,G__RootEventData_rootcint_202_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - measure", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMeasure",1042,G__RootEventData_rootcint_202_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_202_0_4, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEmcDigi::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_202_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEmcDigi::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_202_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEmcDigi::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_202_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEmcDigi::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_202_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_202_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEmcDigi::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_202_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEmcDigi::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_202_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEmcDigi::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_202_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEmcDigi::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEmcDigi", 742, G__RootEventData_rootcint_202_0_16, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi), -1, 0, 1, 1, 1, 0, "u 'TEmcDigi' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEmcDigi", 868, G__RootEventData_rootcint_202_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_202_0_18, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi), -1, 1, 1, 1, 1, 0, "u 'TEmcDigi' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTofDigi(void) {
   /* TTofDigi */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi));
   G__memfunc_setup("TTofDigi",762,G__RootEventData_rootcint_203_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setOverflow",1184,G__RootEventData_rootcint_203_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - overflow", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getOverflow",1172,G__RootEventData_rootcint_203_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_203_0_4, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTofDigi::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_203_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTofDigi::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_203_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTofDigi::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_203_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTofDigi::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_203_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_203_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTofDigi::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_203_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTofDigi::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_203_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTofDigi::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_203_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTofDigi::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TTofDigi", 762, G__RootEventData_rootcint_203_0_16, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi), -1, 0, 1, 1, 1, 0, "u 'TTofDigi' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TTofDigi", 888, G__RootEventData_rootcint_203_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_203_0_18, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi), -1, 1, 1, 1, 1, 0, "u 'TTofDigi' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMucDigi(void) {
   /* TMucDigi */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi));
   G__memfunc_setup("TMucDigi",758,G__RootEventData_rootcint_204_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_204_0_2, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMucDigi::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_204_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMucDigi::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_204_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMucDigi::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_204_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMucDigi::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_204_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_204_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMucDigi::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_204_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMucDigi::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_204_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMucDigi::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_204_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMucDigi::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TMucDigi", 758, G__RootEventData_rootcint_204_0_14, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi), -1, 0, 1, 1, 1, 0, "u 'TMucDigi' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TMucDigi", 884, G__RootEventData_rootcint_204_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_204_0_16, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi), -1, 1, 1, 1, 1, 0, "u 'TMucDigi' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTLumiDigi(void) {
   /* TLumiDigi */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi));
   G__memfunc_setup("TLumiDigi",872,G__RootEventData_rootcint_205_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setOverflow",1184,G__RootEventData_rootcint_205_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - overflow", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getOverflow",1172,G__RootEventData_rootcint_205_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_205_0_4, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TLumiDigi::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_205_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLumiDigi::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_205_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TLumiDigi::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_205_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TLumiDigi::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_205_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_205_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLumiDigi::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_205_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLumiDigi::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_205_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLumiDigi::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_205_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLumiDigi::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TLumiDigi", 872, G__RootEventData_rootcint_205_0_16, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi), -1, 0, 1, 1, 1, 0, "u 'TLumiDigi' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TLumiDigi", 998, G__RootEventData_rootcint_205_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_205_0_18, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi), -1, 1, 1, 1, 1, 0, "u 'TLumiDigi' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTDigiEvent(void) {
   /* TDigiEvent */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent));
   G__memfunc_setup("TDigiEvent",979,G__RootEventData_rootcint_206_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_206_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'true' fromMc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("getFromMc",900,G__RootEventData_rootcint_206_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMdcDigiCol",1263,G__RootEventData_rootcint_206_0_6, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addMdcDigi",954,G__RootEventData_rootcint_206_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMdcDigi' - 0 - digi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMdcDigi",977,G__RootEventData_rootcint_206_0_8, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDigi), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearMdcDigiCol",1462,G__RootEventData_rootcint_206_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEmcDigiCol",1264,G__RootEventData_rootcint_206_0_10, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addEmcDigi",955,G__RootEventData_rootcint_206_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEmcDigi' - 0 - digi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEmcDigi",978,G__RootEventData_rootcint_206_0_12, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcDigi), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearEmcDigiCol",1463,G__RootEventData_rootcint_206_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTofDigiCol",1284,G__RootEventData_rootcint_206_0_14, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addTofDigi",975,G__RootEventData_rootcint_206_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTofDigi' - 0 - digi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTofDigi",998,G__RootEventData_rootcint_206_0_16, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofDigi), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearTofDigiCol",1483,G__RootEventData_rootcint_206_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMucDigiCol",1280,G__RootEventData_rootcint_206_0_18, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addMucDigi",971,G__RootEventData_rootcint_206_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMucDigi' - 0 - digi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMucDigi",994,G__RootEventData_rootcint_206_0_20, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucDigi), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearMucDigiCol",1479,G__RootEventData_rootcint_206_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLumiDigiCol",1394,G__RootEventData_rootcint_206_0_22, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addLumiDigi",1085,G__RootEventData_rootcint_206_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TLumiDigi' - 0 - digi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLumiDigi",1108,G__RootEventData_rootcint_206_0_24, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TLumiDigi), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearLumiDigiCol",1593,G__RootEventData_rootcint_206_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_206_0_26, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDigiEvent::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_206_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDigiEvent::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_206_0_28, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDigiEvent::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_206_0_29, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDigiEvent::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_206_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_206_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDigiEvent::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_206_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDigiEvent::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_206_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDigiEvent::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_206_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDigiEvent::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TDigiEvent", 979, G__RootEventData_rootcint_206_0_38, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent), -1, 0, 1, 1, 1, 0, "u 'TDigiEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TDigiEvent", 1105, G__RootEventData_rootcint_206_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_206_0_40, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent), -1, 1, 1, 1, 1, 0, "u 'TDigiEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRecMdcTrack(void) {
   /* TRecMdcTrack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack));
   G__memfunc_setup("TRecMdcTrack",1143,G__RootEventData_rootcint_207_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("trackId",706,G__RootEventData_rootcint_207_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("helix",538,G__RootEventData_rootcint_207_0_3, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("charge",618,G__RootEventData_rootcint_207_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pxy",353,G__RootEventData_rootcint_207_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("px",232,G__RootEventData_rootcint_207_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("py",233,G__RootEventData_rootcint_207_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pz",234,G__RootEventData_rootcint_207_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("p",112,G__RootEventData_rootcint_207_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("theta",534,G__RootEventData_rootcint_207_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("phi",321,G__RootEventData_rootcint_207_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("x",120,G__RootEventData_rootcint_207_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("y",121,G__RootEventData_rootcint_207_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("z",122,G__RootEventData_rootcint_207_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("r",114,G__RootEventData_rootcint_207_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("stat",444,G__RootEventData_rootcint_207_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("chi2",358,G__RootEventData_rootcint_207_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ndof",423,G__RootEventData_rootcint_207_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("err",329,G__RootEventData_rootcint_207_0_19, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("nhits",550,G__RootEventData_rootcint_207_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("nster",556,G__RootEventData_rootcint_207_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("nlayer",651,G__RootEventData_rootcint_207_0_22, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vx0",286,G__RootEventData_rootcint_207_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vy0",287,G__RootEventData_rootcint_207_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vz0",288,G__RootEventData_rootcint_207_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("fiTerm",615,G__RootEventData_rootcint_207_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_207_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trackId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setHelix",838,G__RootEventData_rootcint_207_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - helix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setStat",744,G__RootEventData_rootcint_207_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - stat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setChi2",658,G__RootEventData_rootcint_207_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNdof",723,G__RootEventData_rootcint_207_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - ndof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setErr",629,G__RootEventData_rootcint_207_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - er", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNhits",850,G__RootEventData_rootcint_207_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - nh", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNster",856,G__RootEventData_rootcint_207_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - ns", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNlayer",951,G__RootEventData_rootcint_207_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - nlayer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setVX0",554,G__RootEventData_rootcint_207_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - vx0", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setVY0",555,G__RootEventData_rootcint_207_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - vy0", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setVZ0",556,G__RootEventData_rootcint_207_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - vz0", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFiTerm",915,G__RootEventData_rootcint_207_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - fiterm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTRecMdcTrack",1475,G__RootEventData_rootcint_207_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMdcTrack' - 10 - mdcTrk", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_207_0_41, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecMdcTrack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_207_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcTrack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_207_0_43, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecMdcTrack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_207_0_44, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecMdcTrack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_207_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_207_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcTrack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_207_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcTrack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_207_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcTrack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_207_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcTrack::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TRecMdcTrack", 1143, G__RootEventData_rootcint_207_0_53, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack), -1, 0, 1, 1, 1, 0, "u 'TRecMdcTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TRecMdcTrack", 1269, G__RootEventData_rootcint_207_0_54, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_207_0_55, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack), -1, 1, 1, 1, 1, 0, "u 'TRecMdcTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRecMdcKalTrack(void) {
   /* TRecMdcKalTrack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalTrack));
   G__memfunc_setup("TRecMdcKalTrack",1423,G__RootEventData_rootcint_208_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTrackId",994,G__RootEventData_rootcint_208_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMass",724,G__RootEventData_rootcint_208_0_3, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLength",930,G__RootEventData_rootcint_208_0_4, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTof",617,G__RootEventData_rootcint_208_0_5, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getfiTerm",935,G__RootEventData_rootcint_208_0_6, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPathSM",877,G__RootEventData_rootcint_208_0_7, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getNhits",838,G__RootEventData_rootcint_208_0_8, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getNlayer",939,G__RootEventData_rootcint_208_0_9, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getStat",732,G__RootEventData_rootcint_208_0_10, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 9, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getChisq",824,G__RootEventData_rootcint_208_0_11, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getNdf",600,G__RootEventData_rootcint_208_0_12, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 9, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getNseg",717,G__RootEventData_rootcint_208_0_13, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getZHelix",916,G__RootEventData_rootcint_208_0_14, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getZError",932,G__RootEventData_rootcint_208_0_15, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getZHelixE",985,G__RootEventData_rootcint_208_0_16, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getZErrorE",1001,G__RootEventData_rootcint_208_0_17, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getZHelixMu",1110,G__RootEventData_rootcint_208_0_18, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getZErrorMu",1126,G__RootEventData_rootcint_208_0_19, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getZHelixK",991,G__RootEventData_rootcint_208_0_20, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getZErrorK",1007,G__RootEventData_rootcint_208_0_21, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getZHelixP",996,G__RootEventData_rootcint_208_0_22, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getZErrorP",1012,G__RootEventData_rootcint_208_0_23, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFHelix",896,G__RootEventData_rootcint_208_0_24, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFError",912,G__RootEventData_rootcint_208_0_25, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFHelixE",965,G__RootEventData_rootcint_208_0_26, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFErrorE",981,G__RootEventData_rootcint_208_0_27, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFHelixMu",1090,G__RootEventData_rootcint_208_0_28, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFErrorMu",1106,G__RootEventData_rootcint_208_0_29, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFHelixK",971,G__RootEventData_rootcint_208_0_30, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFErrorK",987,G__RootEventData_rootcint_208_0_31, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFHelixP",976,G__RootEventData_rootcint_208_0_32, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFErrorP",992,G__RootEventData_rootcint_208_0_33, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLHelix",902,G__RootEventData_rootcint_208_0_34, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLError",918,G__RootEventData_rootcint_208_0_35, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLHelixE",971,G__RootEventData_rootcint_208_0_36, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLErrorE",987,G__RootEventData_rootcint_208_0_37, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLHelixMu",1096,G__RootEventData_rootcint_208_0_38, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLErrorMu",1112,G__RootEventData_rootcint_208_0_39, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLHelixK",977,G__RootEventData_rootcint_208_0_40, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLErrorK",993,G__RootEventData_rootcint_208_0_41, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLHelixP",982,G__RootEventData_rootcint_208_0_42, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLErrorP",998,G__RootEventData_rootcint_208_0_43, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 9, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTHelix",910,G__RootEventData_rootcint_208_0_44, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTError",926,G__RootEventData_rootcint_208_0_45, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPocaE",776,G__RootEventData_rootcint_208_0_46, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPocaMu",901,G__RootEventData_rootcint_208_0_47, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPoca",707,G__RootEventData_rootcint_208_0_48, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPocaK",782,G__RootEventData_rootcint_208_0_49, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPocaP",787,G__RootEventData_rootcint_208_0_50, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLPointE",987,G__RootEventData_rootcint_208_0_51, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLPointMu",1112,G__RootEventData_rootcint_208_0_52, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLPoint",918,G__RootEventData_rootcint_208_0_53, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLPointK",993,G__RootEventData_rootcint_208_0_54, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLPointP",998,G__RootEventData_rootcint_208_0_55, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLPivotE",995,G__RootEventData_rootcint_208_0_56, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLPivotMu",1120,G__RootEventData_rootcint_208_0_57, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLPivot",926,G__RootEventData_rootcint_208_0_58, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLPivotK",1001,G__RootEventData_rootcint_208_0_59, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLPivotP",1006,G__RootEventData_rootcint_208_0_60, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_208_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trackId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setMass",736,G__RootEventData_rootcint_208_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - mass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLength",942,G__RootEventData_rootcint_208_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFiTerm",915,G__RootEventData_rootcint_208_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - fiTerm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPathSM",889,G__RootEventData_rootcint_208_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - pathSM", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTof",629,G__RootEventData_rootcint_208_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - tof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNhits",850,G__RootEventData_rootcint_208_0_67, 121, -1, -1, 0, 1, 1, 1, 0, "I - 'Int_t' 10 - nhits", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setStat",744,G__RootEventData_rootcint_208_0_68, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 10 - stat i - 'Int_t' 0 - i "
"i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setChisq",836,G__RootEventData_rootcint_208_0_69, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 10 - chisq i - 'Int_t' 0 - i "
"i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNdf",612,G__RootEventData_rootcint_208_0_70, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 10 - ndf i - 'Int_t' 0 - i "
"i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNseg",729,G__RootEventData_rootcint_208_0_71, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 10 - nSeg i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNlayer",951,G__RootEventData_rootcint_208_0_72, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 10 - nlayer i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZHelix",928,G__RootEventData_rootcint_208_0_73, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - zhelix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZError",944,G__RootEventData_rootcint_208_0_74, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - zerror", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZHelixE",997,G__RootEventData_rootcint_208_0_75, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - zhelix_e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZErrorE",1013,G__RootEventData_rootcint_208_0_76, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - zerror_e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZHelixMu",1122,G__RootEventData_rootcint_208_0_77, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - zhelix_mu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZErrorMu",1138,G__RootEventData_rootcint_208_0_78, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - zerror_mu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZHelixK",1003,G__RootEventData_rootcint_208_0_79, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - zhelix_k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZErrorK",1019,G__RootEventData_rootcint_208_0_80, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - zerror_k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZHelixP",1008,G__RootEventData_rootcint_208_0_81, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - zhelix_p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZErrorP",1024,G__RootEventData_rootcint_208_0_82, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - zerror_p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFHelix",908,G__RootEventData_rootcint_208_0_83, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - fhelix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFError",924,G__RootEventData_rootcint_208_0_84, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - ferror", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFHelixE",977,G__RootEventData_rootcint_208_0_85, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - fhelix_e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFErrorE",993,G__RootEventData_rootcint_208_0_86, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - ferror_e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFHelixMu",1102,G__RootEventData_rootcint_208_0_87, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - fhelix_mu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFErrorMu",1118,G__RootEventData_rootcint_208_0_88, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - ferror_mu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFHelixK",983,G__RootEventData_rootcint_208_0_89, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - fhelix_k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFErrorK",999,G__RootEventData_rootcint_208_0_90, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - ferror_k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFHelixP",988,G__RootEventData_rootcint_208_0_91, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - fhelix_p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFErrorP",1004,G__RootEventData_rootcint_208_0_92, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - ferror_p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLHelix",914,G__RootEventData_rootcint_208_0_93, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lhelix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLError",930,G__RootEventData_rootcint_208_0_94, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - lerror", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLHelixE",983,G__RootEventData_rootcint_208_0_95, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lhelix_e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLErrorE",999,G__RootEventData_rootcint_208_0_96, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - lerror_e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLHelixMu",1108,G__RootEventData_rootcint_208_0_97, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lhelix_mu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLErrorMu",1124,G__RootEventData_rootcint_208_0_98, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - lerror_mu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLHelixK",989,G__RootEventData_rootcint_208_0_99, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lhelix_k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLErrorK",1005,G__RootEventData_rootcint_208_0_100, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - lerror_k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLHelixP",994,G__RootEventData_rootcint_208_0_101, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lhelix_p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLErrorP",1010,G__RootEventData_rootcint_208_0_102, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - lerror_p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTHelix",922,G__RootEventData_rootcint_208_0_103, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - thelix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTError",938,G__RootEventData_rootcint_208_0_104, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - terror", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPocaE",788,G__RootEventData_rootcint_208_0_105, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - poca_e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPocaMu",913,G__RootEventData_rootcint_208_0_106, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - poca_mu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPoca",719,G__RootEventData_rootcint_208_0_107, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - poca", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPocaK",794,G__RootEventData_rootcint_208_0_108, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - poca_k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPocaP",799,G__RootEventData_rootcint_208_0_109, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - poca_p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLPointE",999,G__RootEventData_rootcint_208_0_110, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lpoint_e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLPointMu",1124,G__RootEventData_rootcint_208_0_111, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lpoint_mu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLPoint",930,G__RootEventData_rootcint_208_0_112, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lpoint", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLPointK",1005,G__RootEventData_rootcint_208_0_113, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lpoint_k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLPointP",1010,G__RootEventData_rootcint_208_0_114, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lpoint_p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLPivotE",1007,G__RootEventData_rootcint_208_0_115, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lpivot_e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLPivotMu",1132,G__RootEventData_rootcint_208_0_116, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lpivot_mu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLPivot",938,G__RootEventData_rootcint_208_0_117, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lpivot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLPivotK",1013,G__RootEventData_rootcint_208_0_118, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lpivot_k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLPivotP",1018,G__RootEventData_rootcint_208_0_119, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - lpivot_p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_208_0_120, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecMdcKalTrack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_208_0_121, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcKalTrack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_208_0_122, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecMdcKalTrack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_208_0_123, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecMdcKalTrack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_208_0_127, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_208_0_128, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcKalTrack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_208_0_129, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcKalTrack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_208_0_130, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcKalTrack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_208_0_131, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcKalTrack::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TRecMdcKalTrack", 1423, G__RootEventData_rootcint_208_0_132, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalTrack), -1, 0, 1, 1, 1, 0, "u 'TRecMdcKalTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TRecMdcKalTrack", 1549, G__RootEventData_rootcint_208_0_133, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_208_0_134, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalTrack), -1, 1, 1, 1, 1, 0, "u 'TRecMdcKalTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRecMdcHit(void) {
   /* TRecMdcHit */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit));
   G__memfunc_setup("TRecMdcHit",935,G__RootEventData_rootcint_209_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("isGrouped",946,G__RootEventData_rootcint_209_0_2, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getId",493,G__RootEventData_rootcint_209_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTrkId",798,G__RootEventData_rootcint_209_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getDriftDistLeft",1624,G__RootEventData_rootcint_209_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getDriftDistRight",1739,G__RootEventData_rootcint_209_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getErrDriftDistLeft",1921,G__RootEventData_rootcint_209_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getErrDriftDistRight",2036,G__RootEventData_rootcint_209_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getChisqAdd",1089,G__RootEventData_rootcint_209_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFlagLR",856,G__RootEventData_rootcint_209_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getStat",732,G__RootEventData_rootcint_209_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMdcId",769,G__RootEventData_rootcint_209_0_12, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTdc",603,G__RootEventData_rootcint_209_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getAdc",584,G__RootEventData_rootcint_209_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getDriftT",909,G__RootEventData_rootcint_209_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getDoca",695,G__RootEventData_rootcint_209_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEntra",826,G__RootEventData_rootcint_209_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getZhit",735,G__RootEventData_rootcint_209_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFltLen",901,G__RootEventData_rootcint_209_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setIsGrouped",1246,G__RootEventData_rootcint_209_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - isGrouped", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setId",505,G__RootEventData_rootcint_209_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrkId",810,G__RootEventData_rootcint_209_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trkid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDriftDistLeft",1636,G__RootEventData_rootcint_209_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - ddl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDriftDistRight",1751,G__RootEventData_rootcint_209_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - ddr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setErrDriftDistLeft",1933,G__RootEventData_rootcint_209_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - erddl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setErrDriftDistRight",2048,G__RootEventData_rootcint_209_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - erddr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setChisqAdd",1101,G__RootEventData_rootcint_209_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - pChisq", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFlagLR",868,G__RootEventData_rootcint_209_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - lr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setStat",744,G__RootEventData_rootcint_209_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - stat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setMdcId",781,G__RootEventData_rootcint_209_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - mdcid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTdc",615,G__RootEventData_rootcint_209_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tdc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setAdc",596,G__RootEventData_rootcint_209_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - adc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDriftT",921,G__RootEventData_rootcint_209_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - driftT", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDoca",707,G__RootEventData_rootcint_209_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - doca", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setEntra",838,G__RootEventData_rootcint_209_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - entra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZhit",747,G__RootEventData_rootcint_209_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - zhit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFltLen",913,G__RootEventData_rootcint_209_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - fltLen", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTRecMdcHit",1267,G__RootEventData_rootcint_209_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMdcHit' - 10 - mdchit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_209_0_39, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecMdcHit::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_209_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcHit::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_209_0_41, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecMdcHit::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_209_0_42, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecMdcHit::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_209_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_209_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcHit::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_209_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcHit::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_209_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcHit::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_209_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcHit::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TRecMdcHit", 935, G__RootEventData_rootcint_209_0_51, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit), -1, 0, 1, 1, 1, 0, "u 'TRecMdcHit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TRecMdcHit", 1061, G__RootEventData_rootcint_209_0_52, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_209_0_53, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit), -1, 1, 1, 1, 1, 0, "u 'TRecMdcHit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTofTrack(void) {
   /* TTofTrack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofTrack));
   G__memfunc_setup("TTofTrack",882,G__RootEventData_rootcint_210_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTofTrackID",1271,G__RootEventData_rootcint_210_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - tofTrackID", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrackID",974,G__RootEventData_rootcint_210_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trackID", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTofID",770,G__RootEventData_rootcint_210_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - tofID", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setStatus",976,G__RootEventData_rootcint_210_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - status", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPath",729,G__RootEventData_rootcint_210_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZrHit",829,G__RootEventData_rootcint_210_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - zrhit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPh",516,G__RootEventData_rootcint_210_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - ph", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTof",629,G__RootEventData_rootcint_210_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setErrTof",926,G__RootEventData_rootcint_210_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - etof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setBeta",712,G__RootEventData_rootcint_210_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - beta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTexp",749,G__RootEventData_rootcint_210_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - texp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTexpElectron",1577,G__RootEventData_rootcint_210_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - texpe", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTexpMuon",1164,G__RootEventData_rootcint_210_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - texpmu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTexpPion",1155,G__RootEventData_rootcint_210_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - texppi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTexpKaon",1142,G__RootEventData_rootcint_210_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - texpk", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTexpProton",1391,G__RootEventData_rootcint_210_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - texpp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setToffset",1063,G__RootEventData_rootcint_210_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - toffset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setToffsetElectron",1891,G__RootEventData_rootcint_210_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - toe", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setToffsetMuon",1478,G__RootEventData_rootcint_210_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tomu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setToffsetPion",1469,G__RootEventData_rootcint_210_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - topi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setToffsetKaon",1456,G__RootEventData_rootcint_210_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tok", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setToffsetProton",1705,G__RootEventData_rootcint_210_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - top", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setToffsetAntiProton",2101,G__RootEventData_rootcint_210_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - topb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setSigma",829,G__RootEventData_rootcint_210_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - sigma", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setSigmaElectron",1657,G__RootEventData_rootcint_210_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - se", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setSigmaMuon",1244,G__RootEventData_rootcint_210_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - smu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setSigmaPion",1235,G__RootEventData_rootcint_210_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - spi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setSigmaKaon",1222,G__RootEventData_rootcint_210_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - sk", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setSigmaProton",1471,G__RootEventData_rootcint_210_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - sp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setSigmaAntiProton",1867,G__RootEventData_rootcint_210_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - spb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setQuality",1077,G__RootEventData_rootcint_210_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - quality", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setT0",464,G__RootEventData_rootcint_210_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - t0", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setErrT0",761,G__RootEventData_rootcint_210_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - errt0", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setErrZ",719,G__RootEventData_rootcint_210_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - errz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPhi",621,G__RootEventData_rootcint_210_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - phi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setErrPhi",918,G__RootEventData_rootcint_210_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - errphi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setEnergy",950,G__RootEventData_rootcint_210_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - energy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setErrEnergy",1247,G__RootEventData_rootcint_210_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - errenergy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("tofTrackID",971,G__RootEventData_rootcint_210_0_40, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("trackID",674,G__RootEventData_rootcint_210_0_41, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("tofID",470,G__RootEventData_rootcint_210_0_42, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("status",676,G__RootEventData_rootcint_210_0_43, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("path",429,G__RootEventData_rootcint_210_0_44, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("zrhit",561,G__RootEventData_rootcint_210_0_45, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ph",216,G__RootEventData_rootcint_210_0_46, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("tof",329,G__RootEventData_rootcint_210_0_47, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("errtof",658,G__RootEventData_rootcint_210_0_48, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("beta",412,G__RootEventData_rootcint_210_0_49, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("texp",449,G__RootEventData_rootcint_210_0_50, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("texpElectron",1277,G__RootEventData_rootcint_210_0_51, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("texpMuon",864,G__RootEventData_rootcint_210_0_52, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("texpPion",855,G__RootEventData_rootcint_210_0_53, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("texpKaon",842,G__RootEventData_rootcint_210_0_54, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("texpProton",1091,G__RootEventData_rootcint_210_0_55, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("toffset",763,G__RootEventData_rootcint_210_0_56, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("toffsetElectron",1591,G__RootEventData_rootcint_210_0_57, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("toffsetMuon",1178,G__RootEventData_rootcint_210_0_58, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("toffsetPion",1169,G__RootEventData_rootcint_210_0_59, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("toffsetKaon",1156,G__RootEventData_rootcint_210_0_60, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("toffsetProton",1405,G__RootEventData_rootcint_210_0_61, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("toffsetAntiProton",1801,G__RootEventData_rootcint_210_0_62, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("sigma",529,G__RootEventData_rootcint_210_0_63, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("sigmaElectron",1357,G__RootEventData_rootcint_210_0_64, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("sigmaMuon",944,G__RootEventData_rootcint_210_0_65, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("sigmaPion",935,G__RootEventData_rootcint_210_0_66, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("sigmaKaon",922,G__RootEventData_rootcint_210_0_67, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("sigmaProton",1171,G__RootEventData_rootcint_210_0_68, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("sigmaAntiProton",1567,G__RootEventData_rootcint_210_0_69, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("quality",777,G__RootEventData_rootcint_210_0_70, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("t0",164,G__RootEventData_rootcint_210_0_71, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("errt0",493,G__RootEventData_rootcint_210_0_72, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("errz",451,G__RootEventData_rootcint_210_0_73, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("phi",321,G__RootEventData_rootcint_210_0_74, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("errphi",650,G__RootEventData_rootcint_210_0_75, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("energy",650,G__RootEventData_rootcint_210_0_76, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("errenergy",979,G__RootEventData_rootcint_210_0_77, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_210_0_78, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTofTrack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_210_0_79, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTofTrack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_210_0_80, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTofTrack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_210_0_81, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTofTrack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_210_0_85, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_210_0_86, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTofTrack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_210_0_87, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTofTrack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_210_0_88, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTofTrack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_210_0_89, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTofTrack::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TTofTrack", 882, G__RootEventData_rootcint_210_0_90, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofTrack), -1, 0, 1, 1, 1, 0, "u 'TTofTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TTofTrack", 1008, G__RootEventData_rootcint_210_0_91, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_210_0_92, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofTrack), -1, 1, 1, 1, 1, 0, "u 'TTofTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRecTofTrack(void) {
   /* TRecTofTrack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack));
   G__memfunc_setup("TRecTofTrack",1164,G__RootEventData_rootcint_211_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("tofTrackID",971,G__RootEventData_rootcint_211_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("trackID",674,G__RootEventData_rootcint_211_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("tofID",470,G__RootEventData_rootcint_211_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("status",676,G__RootEventData_rootcint_211_0_5, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("path",429,G__RootEventData_rootcint_211_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("zrhit",561,G__RootEventData_rootcint_211_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ph",216,G__RootEventData_rootcint_211_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("tof",329,G__RootEventData_rootcint_211_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("errtof",658,G__RootEventData_rootcint_211_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("beta",412,G__RootEventData_rootcint_211_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("texp",449,G__RootEventData_rootcint_211_0_12, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("texpElectron",1277,G__RootEventData_rootcint_211_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("texpMuon",864,G__RootEventData_rootcint_211_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("texpPion",855,G__RootEventData_rootcint_211_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("texpKaon",842,G__RootEventData_rootcint_211_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("texpProton",1091,G__RootEventData_rootcint_211_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("toffset",763,G__RootEventData_rootcint_211_0_18, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("toffsetElectron",1591,G__RootEventData_rootcint_211_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("toffsetMuon",1178,G__RootEventData_rootcint_211_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("toffsetPion",1169,G__RootEventData_rootcint_211_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("toffsetKaon",1156,G__RootEventData_rootcint_211_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("toffsetProton",1405,G__RootEventData_rootcint_211_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("toffsetAntiProton",1801,G__RootEventData_rootcint_211_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("sigma",529,G__RootEventData_rootcint_211_0_25, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("sigmaElectron",1357,G__RootEventData_rootcint_211_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("sigmaMuon",944,G__RootEventData_rootcint_211_0_27, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("sigmaPion",935,G__RootEventData_rootcint_211_0_28, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("sigmaKaon",922,G__RootEventData_rootcint_211_0_29, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("sigmaProton",1171,G__RootEventData_rootcint_211_0_30, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("sigmaAntiProton",1567,G__RootEventData_rootcint_211_0_31, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("quality",777,G__RootEventData_rootcint_211_0_32, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("t0",164,G__RootEventData_rootcint_211_0_33, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("errt0",493,G__RootEventData_rootcint_211_0_34, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("errz",451,G__RootEventData_rootcint_211_0_35, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("phi",321,G__RootEventData_rootcint_211_0_36, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("errphi",650,G__RootEventData_rootcint_211_0_37, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("energy",650,G__RootEventData_rootcint_211_0_38, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("errenergy",979,G__RootEventData_rootcint_211_0_39, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTofTrackID",1271,G__RootEventData_rootcint_211_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - tofTrackID", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrackID",974,G__RootEventData_rootcint_211_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trackID", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTofID",770,G__RootEventData_rootcint_211_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - tofID", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setStatus",976,G__RootEventData_rootcint_211_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - status", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPath",729,G__RootEventData_rootcint_211_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZrHit",829,G__RootEventData_rootcint_211_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - zrhit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPh",516,G__RootEventData_rootcint_211_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - ph", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTof",629,G__RootEventData_rootcint_211_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setErrTof",926,G__RootEventData_rootcint_211_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - etof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setBeta",712,G__RootEventData_rootcint_211_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - beta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTexp",749,G__RootEventData_rootcint_211_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - texp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTexpElectron",1577,G__RootEventData_rootcint_211_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - texpe", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTexpMuon",1164,G__RootEventData_rootcint_211_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - texpmu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTexpPion",1155,G__RootEventData_rootcint_211_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - texppi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTexpKaon",1142,G__RootEventData_rootcint_211_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - texpk", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTexpProton",1391,G__RootEventData_rootcint_211_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - texpp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setToffset",1063,G__RootEventData_rootcint_211_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - toffset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setToffsetElectron",1891,G__RootEventData_rootcint_211_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - toe", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setToffsetMuon",1478,G__RootEventData_rootcint_211_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tomu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setToffsetPion",1469,G__RootEventData_rootcint_211_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - topi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setToffsetKaon",1456,G__RootEventData_rootcint_211_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tok", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setToffsetProton",1705,G__RootEventData_rootcint_211_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - top", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setToffsetAntiProton",2101,G__RootEventData_rootcint_211_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - topb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setSigma",829,G__RootEventData_rootcint_211_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - sigma", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setSigmaElectron",1657,G__RootEventData_rootcint_211_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - se", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setSigmaMuon",1244,G__RootEventData_rootcint_211_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - smu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setSigmaPion",1235,G__RootEventData_rootcint_211_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - spi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setSigmaKaon",1222,G__RootEventData_rootcint_211_0_67, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - sk", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setSigmaProton",1471,G__RootEventData_rootcint_211_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - sp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setSigmaAntiProton",1867,G__RootEventData_rootcint_211_0_69, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - spb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setQuality",1077,G__RootEventData_rootcint_211_0_70, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - quality", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setT0",464,G__RootEventData_rootcint_211_0_71, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - t0", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setErrT0",761,G__RootEventData_rootcint_211_0_72, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - errt0", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setErrZ",719,G__RootEventData_rootcint_211_0_73, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - errz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPhi",621,G__RootEventData_rootcint_211_0_74, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - phi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setErrPhi",918,G__RootEventData_rootcint_211_0_75, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - errphi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setEnergy",950,G__RootEventData_rootcint_211_0_76, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - energy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setErrEnergy",1247,G__RootEventData_rootcint_211_0_77, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - errenergy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTRecTofTrack",1496,G__RootEventData_rootcint_211_0_78, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecTofTrack' - 10 - toftrk", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_211_0_79, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecTofTrack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_211_0_80, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecTofTrack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_211_0_81, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecTofTrack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_211_0_82, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecTofTrack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_211_0_86, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_211_0_87, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecTofTrack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_211_0_88, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecTofTrack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_211_0_89, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecTofTrack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_211_0_90, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecTofTrack::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TRecTofTrack", 1164, G__RootEventData_rootcint_211_0_91, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack), -1, 0, 1, 1, 1, 0, "u 'TRecTofTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TRecTofTrack", 1290, G__RootEventData_rootcint_211_0_92, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_211_0_93, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack), -1, 1, 1, 1, 1, 0, "u 'TRecTofTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRecEmcHit(void) {
   /* TRecEmcHit */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcHit));
   G__memfunc_setup("TRecEmcHit",936,G__RootEventData_rootcint_212_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcHit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("cellId",589,G__RootEventData_rootcint_212_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("energy",650,G__RootEventData_rootcint_212_0_3, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("time",431,G__RootEventData_rootcint_212_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setCellId",889,G__RootEventData_rootcint_212_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setEnergy",950,G__RootEventData_rootcint_212_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTime",731,G__RootEventData_rootcint_212_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_212_0_8, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecEmcHit::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_212_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEmcHit::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_212_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecEmcHit::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_212_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecEmcHit::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_212_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_212_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEmcHit::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_212_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecEmcHit::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_212_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEmcHit::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_212_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecEmcHit::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TRecEmcHit", 936, G__RootEventData_rootcint_212_0_20, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcHit), -1, 0, 1, 1, 1, 0, "u 'TRecEmcHit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TRecEmcHit", 1062, G__RootEventData_rootcint_212_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_212_0_22, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcHit), -1, 1, 1, 1, 1, 0, "u 'TRecEmcHit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRecEmcCluster(void) {
   /* TRecEmcCluster */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcCluster));
   G__memfunc_setup("TRecEmcCluster",1381,G__RootEventData_rootcint_213_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcCluster), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clusterId",943,G__RootEventData_rootcint_213_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vecHits",726,G__RootEventData_rootcint_213_0_3, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vecSeeds",818,G__RootEventData_rootcint_213_0_4, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vecShowers",1065,G__RootEventData_rootcint_213_0_5, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setClusterId",1243,G__RootEventData_rootcint_213_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setVecHits",1026,G__RootEventData_rootcint_213_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - vecHits", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setVecSeeds",1118,G__RootEventData_rootcint_213_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - vecSeeds", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setVecShowers",1365,G__RootEventData_rootcint_213_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - vecShowers", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_213_0_10, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecEmcCluster::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_213_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEmcCluster::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_213_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecEmcCluster::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_213_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecEmcCluster::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_213_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_213_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEmcCluster::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_213_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecEmcCluster::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_213_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEmcCluster::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_213_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecEmcCluster::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TRecEmcCluster", 1381, G__RootEventData_rootcint_213_0_22, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcCluster), -1, 0, 1, 1, 1, 0, "u 'TRecEmcCluster' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TRecEmcCluster", 1507, G__RootEventData_rootcint_213_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_213_0_24, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcCluster), -1, 1, 1, 1, 1, 0, "u 'TRecEmcCluster' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRecEmcShower(void) {
   /* TRecEmcShower */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower));
   G__memfunc_setup("TRecEmcShower",1275,G__RootEventData_rootcint_449_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("trackId",706,G__RootEventData_rootcint_449_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("numHits",744,G__RootEventData_rootcint_449_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("status",676,G__RootEventData_rootcint_449_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("cellId",589,G__RootEventData_rootcint_449_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("module",646,G__RootEventData_rootcint_449_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("x",120,G__RootEventData_rootcint_449_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("y",121,G__RootEventData_rootcint_449_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("z",122,G__RootEventData_rootcint_449_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("theta",534,G__RootEventData_rootcint_449_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("dtheta",634,G__RootEventData_rootcint_449_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("phi",321,G__RootEventData_rootcint_449_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("dphi",421,G__RootEventData_rootcint_449_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("energy",650,G__RootEventData_rootcint_449_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("dE",169,G__RootEventData_rootcint_449_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("eSeed",486,G__RootEventData_rootcint_449_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("e3x3",323,G__RootEventData_rootcint_449_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("e5x5",327,G__RootEventData_rootcint_449_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("eAll",382,G__RootEventData_rootcint_449_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("eLepton",727,G__RootEventData_rootcint_449_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("time",431,G__RootEventData_rootcint_449_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("secondMoment",1260,G__RootEventData_rootcint_449_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("latMoment",945,G__RootEventData_rootcint_449_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("a20Moment",819,G__RootEventData_rootcint_449_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("a42Moment",823,G__RootEventData_rootcint_449_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("err",329,G__RootEventData_rootcint_449_0_26, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("cellIdMap",875,G__RootEventData_rootcint_449_0_27, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR), G__defined_typename("map<Int_t,Double_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("cellId3x3",811,G__RootEventData_rootcint_449_0_28, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("cellId5x5",815,G__RootEventData_rootcint_449_0_29, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clusterId",943,G__RootEventData_rootcint_449_0_30, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_449_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trackId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNumHits",1044,G__RootEventData_rootcint_449_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - hit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setStatus",976,G__RootEventData_rootcint_449_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - st", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setCellId",889,G__RootEventData_rootcint_449_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setModule",946,G__RootEventData_rootcint_449_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - mod", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setX",420,G__RootEventData_rootcint_449_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setY",421,G__RootEventData_rootcint_449_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZ",422,G__RootEventData_rootcint_449_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setEnergy",950,G__RootEventData_rootcint_449_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDE",469,G__RootEventData_rootcint_449_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - de", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTheta",834,G__RootEventData_rootcint_449_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - theta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDtheta",934,G__RootEventData_rootcint_449_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - dt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPhi",621,G__RootEventData_rootcint_449_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - pi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDphi",721,G__RootEventData_rootcint_449_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - dpi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setESeed",786,G__RootEventData_rootcint_449_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - eSeed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setE3x3",623,G__RootEventData_rootcint_449_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - e3x3", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setE5x5",627,G__RootEventData_rootcint_449_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - e5x5", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setEAll",682,G__RootEventData_rootcint_449_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - eall", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setELepton",1027,G__RootEventData_rootcint_449_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - elepton", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTime",731,G__RootEventData_rootcint_449_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setSecondMoment",1560,G__RootEventData_rootcint_449_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - secondMoment", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLatMoment",1245,G__RootEventData_rootcint_449_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - latMoment", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setA20Moment",1119,G__RootEventData_rootcint_449_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - a20Moment", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setA42Moment",1123,G__RootEventData_rootcint_449_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - a42Moment", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setErr",629,G__RootEventData_rootcint_449_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - err", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setCellIdMap",1175,G__RootEventData_rootcint_449_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "u 'map<int,double,less<int>,allocator<pair<const int,double> > >' 'map<Int_t,Double_t>' 11 - cellIdMap", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setCellId3x3",1111,G__RootEventData_rootcint_449_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - cellId3x3", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setCellId5x5",1115,G__RootEventData_rootcint_449_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - cellId5x5", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setClusterId",1243,G__RootEventData_rootcint_449_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - clusterId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTRecEmcShower",1607,G__RootEventData_rootcint_449_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecEmcShower' - 10 - emcshower", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_449_0_61, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecEmcShower::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_449_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEmcShower::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_449_0_63, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecEmcShower::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_449_0_64, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecEmcShower::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_449_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_449_0_69, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEmcShower::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_449_0_70, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecEmcShower::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_449_0_71, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEmcShower::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_449_0_72, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecEmcShower::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TRecEmcShower", 1275, G__RootEventData_rootcint_449_0_73, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower), -1, 0, 1, 1, 1, 0, "u 'TRecEmcShower' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TRecEmcShower", 1401, G__RootEventData_rootcint_449_0_74, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_449_0_75, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower), -1, 1, 1, 1, 1, 0, "u 'TRecEmcShower' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRecMucTrack(void) {
   /* TRecMucTrack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack));
   G__memfunc_setup("TRecMucTrack",1160,G__RootEventData_rootcint_457_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("trackId",706,G__RootEventData_rootcint_457_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("id",205,G__RootEventData_rootcint_457_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("status",676,G__RootEventData_rootcint_457_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("type",450,G__RootEventData_rootcint_457_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("startPart",965,G__RootEventData_rootcint_457_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "start position of track locates in which part", (void*) NULL, 0);
   G__memfunc_setup("endPart",718,G__RootEventData_rootcint_457_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "end   position of track locates in which part", (void*) NULL, 0);
   G__memfunc_setup("brLastLayer",1125,G__RootEventData_rootcint_457_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "last layer with hits in barrel ", (void*) NULL, 0);
   G__memfunc_setup("ecLastLayer",1113,G__RootEventData_rootcint_457_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "last layer with hits in end cap", (void*) NULL, 0);
   G__memfunc_setup("numHits",744,G__RootEventData_rootcint_457_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "total hits on the track   ", (void*) NULL, 0);
   G__memfunc_setup("numLayers",960,G__RootEventData_rootcint_457_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "number of layers with hits ", (void*) NULL, 0);
   G__memfunc_setup("maxHitsInLayer",1426,G__RootEventData_rootcint_457_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("depth",533,G__RootEventData_rootcint_457_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "depth of the track transport in iron", (void*) NULL, 0);
   G__memfunc_setup("chi2",358,G__RootEventData_rootcint_457_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("dof",313,G__RootEventData_rootcint_457_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rms",338,G__RootEventData_rootcint_457_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("distance",843,G__RootEventData_rootcint_457_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("deltaPhi",811,G__RootEventData_rootcint_457_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("xPos",426,G__RootEventData_rootcint_457_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "position on the start of track in muc (vertex) ", (void*) NULL, 0);
   G__memfunc_setup("yPos",427,G__RootEventData_rootcint_457_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("zPos",428,G__RootEventData_rootcint_457_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("xPosSigma",923,G__RootEventData_rootcint_457_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "position on the start of track in muc (vertex) ", (void*) NULL, 0);
   G__memfunc_setup("yPosSigma",924,G__RootEventData_rootcint_457_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("zPosSigma",925,G__RootEventData_rootcint_457_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("px",232,G__RootEventData_rootcint_457_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "momentum on the start of track in muc", (void*) NULL, 0);
   G__memfunc_setup("py",233,G__RootEventData_rootcint_457_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pz",234,G__RootEventData_rootcint_457_0_27, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vecHits",726,G__RootEventData_rootcint_457_0_28, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("expHits",741,G__RootEventData_rootcint_457_0_29, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("distHits",844,G__RootEventData_rootcint_457_0_30, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("kalRechi2",853,G__RootEventData_rootcint_457_0_31, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("kaldof",625,G__RootEventData_rootcint_457_0_32, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("kaldepth",845,G__RootEventData_rootcint_457_0_33, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("kalbrLastLayer",1437,G__RootEventData_rootcint_457_0_34, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("kalecLastLayer",1425,G__RootEventData_rootcint_457_0_35, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_457_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trackId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setId",505,G__RootEventData_rootcint_457_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setStatus",976,G__RootEventData_rootcint_457_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - st", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setType",750,G__RootEventData_rootcint_457_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setStartPart",1265,G__RootEventData_rootcint_457_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - part", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setEndPart",1018,G__RootEventData_rootcint_457_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - part", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setBrLastLayer",1425,G__RootEventData_rootcint_457_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - layer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setEcLastLayer",1413,G__RootEventData_rootcint_457_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - layer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNumHits",1044,G__RootEventData_rootcint_457_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - numHits", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNumLayers",1260,G__RootEventData_rootcint_457_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - numLayers", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setMaxHitsInLayer",1726,G__RootEventData_rootcint_457_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - maxHits", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDepth",833,G__RootEventData_rootcint_457_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - depth", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setChi2",658,G__RootEventData_rootcint_457_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - chi2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDof",613,G__RootEventData_rootcint_457_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - dof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setRms",638,G__RootEventData_rootcint_457_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - rms", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDistance",1143,G__RootEventData_rootcint_457_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - dist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDeltaPhi",1111,G__RootEventData_rootcint_457_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - dphi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setXPos",726,G__RootEventData_rootcint_457_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setYPos",727,G__RootEventData_rootcint_457_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZPos",728,G__RootEventData_rootcint_457_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setXPosSigma",1223,G__RootEventData_rootcint_457_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setYPosSigma",1224,G__RootEventData_rootcint_457_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZPosSigma",1225,G__RootEventData_rootcint_457_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPx",532,G__RootEventData_rootcint_457_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - px", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPy",533,G__RootEventData_rootcint_457_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - py", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPz",534,G__RootEventData_rootcint_457_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - pz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setVecHits",1026,G__RootEventData_rootcint_457_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 1 - vecHits", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setExpHits",1041,G__RootEventData_rootcint_457_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 1 - expHits", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDistHits",1144,G__RootEventData_rootcint_457_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - distHits", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setkalRechi2",1185,G__RootEventData_rootcint_457_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - ch", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setkalDof",925,G__RootEventData_rootcint_457_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setkalDepth",1145,G__RootEventData_rootcint_457_0_67, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - de", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setkalbrLastLayer",1769,G__RootEventData_rootcint_457_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - br", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setkalecLastLayer",1757,G__RootEventData_rootcint_457_0_69, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTRecMucTrack",1492,G__RootEventData_rootcint_457_0_70, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMucTrack' - 10 - muctrk", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_457_0_71, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecMucTrack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_457_0_72, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMucTrack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_457_0_73, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecMucTrack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_457_0_74, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecMucTrack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_457_0_78, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_457_0_79, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMucTrack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_457_0_80, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMucTrack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_457_0_81, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMucTrack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_457_0_82, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMucTrack::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TRecMucTrack", 1160, G__RootEventData_rootcint_457_0_83, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack), -1, 0, 1, 1, 1, 0, "u 'TRecMucTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TRecMucTrack", 1286, G__RootEventData_rootcint_457_0_84, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_457_0_85, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack), -1, 1, 1, 1, 1, 0, "u 'TRecMucTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRecMdcDedx(void) {
   /* TRecMdcDedx */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedx));
   G__memfunc_setup("TRecMdcDedx",1031,G__RootEventData_rootcint_458_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedx), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("mdcTrackId",982,G__RootEventData_rootcint_458_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("mdcKalTrackId",1262,G__RootEventData_rootcint_458_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("trackId",706,G__RootEventData_rootcint_458_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("particleId",1025,G__RootEventData_rootcint_458_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("status",676,G__RootEventData_rootcint_458_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("truncAlg",832,G__RootEventData_rootcint_458_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("chi",308,G__RootEventData_rootcint_458_0_8, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("chiE",377,G__RootEventData_rootcint_458_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("chiMu",502,G__RootEventData_rootcint_458_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("chiPi",493,G__RootEventData_rootcint_458_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("chiK",383,G__RootEventData_rootcint_458_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("chiP",388,G__RootEventData_rootcint_458_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("numGoodHits",1137,G__RootEventData_rootcint_458_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("numTotalHits",1260,G__RootEventData_rootcint_458_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("probPH",587,G__RootEventData_rootcint_458_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("normPH",596,G__RootEventData_rootcint_458_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("errorPH",706,G__RootEventData_rootcint_458_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("twentyPH",835,G__RootEventData_rootcint_458_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("dedxExpect",1038,G__RootEventData_rootcint_458_0_20, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - - 0 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("sigmaDedx",918,G__RootEventData_rootcint_458_0_21, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - - 0 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pidProb",720,G__RootEventData_rootcint_458_0_22, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - - 0 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("dedxHit",714,G__RootEventData_rootcint_458_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("dedxEsat",818,G__RootEventData_rootcint_458_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("dedxNoRun",919,G__RootEventData_rootcint_458_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("dedxMoment",1045,G__RootEventData_rootcint_458_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDedxHit",1014,G__RootEventData_rootcint_458_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - dedx_hit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDedxEsat",1118,G__RootEventData_rootcint_458_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - dedx_esat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDedxNoRun",1219,G__RootEventData_rootcint_458_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - dedx_norun", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDedxMoment",1345,G__RootEventData_rootcint_458_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - dedx_momentum", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setMdcTrackId",1282,G__RootEventData_rootcint_458_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - mdcTrackId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setMdcKalTrackId",1562,G__RootEventData_rootcint_458_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - mdcKalTrackId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_458_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trackId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setParticleId",1325,G__RootEventData_rootcint_458_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - particleId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setStatus",976,G__RootEventData_rootcint_458_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - status", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTruncAlg",1132,G__RootEventData_rootcint_458_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trunc_alg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setChiE",677,G__RootEventData_rootcint_458_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chiE", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setChiMu",802,G__RootEventData_rootcint_458_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chiMu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setChiPi",793,G__RootEventData_rootcint_458_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chiPi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setChiK",683,G__RootEventData_rootcint_458_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chiK", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setChiP",688,G__RootEventData_rootcint_458_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chiP", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNumGoodHits",1437,G__RootEventData_rootcint_458_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - numGoodHits", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNumTotalHits",1560,G__RootEventData_rootcint_458_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - numTotalHits", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setProbPH",887,G__RootEventData_rootcint_458_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - probPH", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNormPH",896,G__RootEventData_rootcint_458_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - normPH", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setErrorPH",1006,G__RootEventData_rootcint_458_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - errorPH", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTwentyPH",1135,G__RootEventData_rootcint_458_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - twentyPH", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setChi",608,G__RootEventData_rootcint_458_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "D - - 0 - chi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDedxExpect",1338,G__RootEventData_rootcint_458_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "D - - 0 - dedx_exp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setSigmaDedx",1218,G__RootEventData_rootcint_458_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "D - - 0 - sigma_dedx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPidProb",1020,G__RootEventData_rootcint_458_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "D - - 0 - pid_prob", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_458_0_52, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecMdcDedx::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_458_0_53, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcDedx::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_458_0_54, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecMdcDedx::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_458_0_55, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecMdcDedx::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_458_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_458_0_60, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcDedx::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_458_0_61, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcDedx::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_458_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcDedx::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_458_0_63, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcDedx::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TRecMdcDedx", 1031, G__RootEventData_rootcint_458_0_64, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedx), -1, 0, 1, 1, 1, 0, "u 'TRecMdcDedx' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TRecMdcDedx", 1157, G__RootEventData_rootcint_458_0_65, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_458_0_66, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedx), -1, 1, 1, 1, 1, 0, "u 'TRecMdcDedx' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRecMdcDedxHit(void) {
   /* TRecMdcDedxHit */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedxHit));
   G__memfunc_setup("TRecMdcDedxHit",1324,G__RootEventData_rootcint_459_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedxHit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("isGrouped",946,G__RootEventData_rootcint_459_0_2, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("mdcHitId",774,G__RootEventData_rootcint_459_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("mdcKalHelixSegId",1554,G__RootEventData_rootcint_459_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("trkId",510,G__RootEventData_rootcint_459_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("flagLR",568,G__RootEventData_rootcint_459_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("mdcId",481,G__RootEventData_rootcint_459_0_7, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pathLength",1039,G__RootEventData_rootcint_459_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getDedx",709,G__RootEventData_rootcint_459_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setMdcHitId",1074,G__RootEventData_rootcint_459_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - mdcHitId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setMdcKalHelixSegId",1854,G__RootEventData_rootcint_459_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - mdcKalHelixSegId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDedx",721,G__RootEventData_rootcint_459_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - dedx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setIsGrouped",1246,G__RootEventData_rootcint_459_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - isGrouped", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrkId",810,G__RootEventData_rootcint_459_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trkid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFlagLR",868,G__RootEventData_rootcint_459_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - lr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setMdcId",781,G__RootEventData_rootcint_459_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - mdcid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPathLength",1339,G__RootEventData_rootcint_459_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - pathlength", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_459_0_18, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecMdcDedxHit::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_459_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcDedxHit::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_459_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecMdcDedxHit::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_459_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecMdcDedxHit::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_459_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_459_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcDedxHit::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_459_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcDedxHit::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_459_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcDedxHit::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_459_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcDedxHit::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TRecMdcDedxHit", 1324, G__RootEventData_rootcint_459_0_30, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedxHit), -1, 0, 1, 1, 1, 0, "u 'TRecMdcDedxHit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TRecMdcDedxHit", 1450, G__RootEventData_rootcint_459_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_459_0_32, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedxHit), -1, 1, 1, 1, 1, 0, "u 'TRecMdcDedxHit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRecExtTrack(void) {
   /* TRecExtTrack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecExtTrack));
   G__memfunc_setup("TRecExtTrack",1172,G__RootEventData_rootcint_460_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecExtTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTrackId",974,G__RootEventData_rootcint_460_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trackId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1PositionX",1587,G__RootEventData_rootcint_460_0_3, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof1PositionX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1PositionY",1588,G__RootEventData_rootcint_460_0_4, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof1PositionY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1PositionZ",1589,G__RootEventData_rootcint_460_0_5, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof1PositionZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1MomentumX",1584,G__RootEventData_rootcint_460_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof1MomentumX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1MomentumY",1585,G__RootEventData_rootcint_460_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof1MomentumY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1MomentumZ",1586,G__RootEventData_rootcint_460_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof1MomentumZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1VolumeName",1663,G__RootEventData_rootcint_460_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TString' - 10 - Tof1VolumeName i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1VolumeNumber",1895,G__RootEventData_rootcint_460_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 10 - Tof1VolumeNumber i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1",646,G__RootEventData_rootcint_460_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof1 i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1Path",1043,G__RootEventData_rootcint_460_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof1Path i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1PosSigmaAlongZ",2036,G__RootEventData_rootcint_460_0_13, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof1PosSigmaAlongZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1PosSigmaAlongT",2030,G__RootEventData_rootcint_460_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof1PosSigmaAlongT i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1PosSigmaAlongX",2034,G__RootEventData_rootcint_460_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof1PosSigmaAlongX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1PosSigmaAlongY",2035,G__RootEventData_rootcint_460_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof1PosSigmaAlongY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1ErrorMatrix",1797,G__RootEventData_rootcint_460_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 12 - Tof1ErrorMatrix i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2PositionX",1588,G__RootEventData_rootcint_460_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof2PositionX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2PositionY",1589,G__RootEventData_rootcint_460_0_19, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof2PositionY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2PositionZ",1590,G__RootEventData_rootcint_460_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof2PositionZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2MomentumX",1585,G__RootEventData_rootcint_460_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof2MomentumX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2MomentumY",1586,G__RootEventData_rootcint_460_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof2MomentumY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2MomentumZ",1587,G__RootEventData_rootcint_460_0_23, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof2MomentumZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2VolumeName",1664,G__RootEventData_rootcint_460_0_24, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TString' - 10 - Tof2VolumeName i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2VolumeNumber",1896,G__RootEventData_rootcint_460_0_25, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 10 - Tof2VolumeNumber i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2",647,G__RootEventData_rootcint_460_0_26, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof2 i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2Path",1044,G__RootEventData_rootcint_460_0_27, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof2Path i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2PosSigmaAlongZ",2037,G__RootEventData_rootcint_460_0_28, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof2PosSigmaAlongZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2PosSigmaAlongT",2031,G__RootEventData_rootcint_460_0_29, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof2PosSigmaAlongT i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2PosSigmaAlongX",2035,G__RootEventData_rootcint_460_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof2PosSigmaAlongX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2PosSigmaAlongY",2036,G__RootEventData_rootcint_460_0_31, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - Tof2PosSigmaAlongY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2ErrorMatrix",1798,G__RootEventData_rootcint_460_0_32, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 12 - Tof2ErrorMatrix i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcPositionX",1518,G__RootEventData_rootcint_460_0_33, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - EmcPositionX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcPositionY",1519,G__RootEventData_rootcint_460_0_34, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - EmcPositionY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcPositionZ",1520,G__RootEventData_rootcint_460_0_35, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - EmcPositionZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcMomentumX",1515,G__RootEventData_rootcint_460_0_36, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - EmcMomentumX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcMomentumY",1516,G__RootEventData_rootcint_460_0_37, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - EmcMomentumY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcMomentumZ",1517,G__RootEventData_rootcint_460_0_38, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - EmcMomentumZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcVolumeName",1594,G__RootEventData_rootcint_460_0_39, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TString' - 10 - EmcVolumeName i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcVolumeNumber",1826,G__RootEventData_rootcint_460_0_40, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 10 - EmcVolumeNumber i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcPosSigmaAlongTheta",2379,G__RootEventData_rootcint_460_0_41, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - EmcPosSigmaAlongTheta i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcPosSigmaAlongPhi",2166,G__RootEventData_rootcint_460_0_42, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - EmcPosSigmaAlongPhi i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcErrorMatrix",1728,G__RootEventData_rootcint_460_0_43, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 12 - EmcErrorMatrix i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcPath",974,G__RootEventData_rootcint_460_0_44, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - path i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucPositionX",1534,G__RootEventData_rootcint_460_0_45, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - MucPositionX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucPositionY",1535,G__RootEventData_rootcint_460_0_46, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - MucPositionY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucPositionZ",1536,G__RootEventData_rootcint_460_0_47, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - MucPositionZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucMomentumX",1531,G__RootEventData_rootcint_460_0_48, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - MucMomentumX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucMomentumY",1532,G__RootEventData_rootcint_460_0_49, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - MucMomentumY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucMomentumZ",1533,G__RootEventData_rootcint_460_0_50, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - MucMomentumZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucVolumeName",1610,G__RootEventData_rootcint_460_0_51, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TString' - 10 - MucVolumeName i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucVolumeNumber",1842,G__RootEventData_rootcint_460_0_52, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 10 - MucVolumeNumber i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucPosSigmaAlongZ",1983,G__RootEventData_rootcint_460_0_53, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - MucPosSigmaAlongZ i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucPosSigmaAlongT",1977,G__RootEventData_rootcint_460_0_54, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - MucPosSigmaAlongT i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucPosSigmaAlongX",1981,G__RootEventData_rootcint_460_0_55, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - MucPosSigmaAlongX i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucPosSigmaAlongY",1982,G__RootEventData_rootcint_460_0_56, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - MucPosSigmaAlongY i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucErrorMatrix",1744,G__RootEventData_rootcint_460_0_57, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 12 - MucErrorMatrix i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSize",711,G__RootEventData_rootcint_460_0_58, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - size i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetExtMucHit",1191,G__RootEventData_rootcint_460_0_59, 121, -1, -1, 0, 14, 1, 1, 0, 
"d - 'Double_t' 0 - PositionX d - 'Double_t' 0 - PositionY "
"d - 'Double_t' 0 - PositionZ d - 'Double_t' 0 - MomentumX "
"d - 'Double_t' 0 - MomentumY d - 'Double_t' 0 - MomentumZ "
"u 'TString' - 0 - VolumeName i - 'Int_t' 0 - VolumeNumber "
"d - 'Double_t' 0 - PosSigmaAlongZ d - 'Double_t' 0 - PosSigmaAlongT "
"d - 'Double_t' 0 - PosSigmaAlongX d - 'Double_t' 0 - PosSigmaAlongY "
"D - 'Double_t' 2 - ErrorMatrix i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrackId",962,G__RootEventData_rootcint_460_0_60, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1PositionX",1575,G__RootEventData_rootcint_460_0_61, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1PositionY",1576,G__RootEventData_rootcint_460_0_62, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1PositionZ",1577,G__RootEventData_rootcint_460_0_63, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1MomentumX",1572,G__RootEventData_rootcint_460_0_64, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1MomentumY",1573,G__RootEventData_rootcint_460_0_65, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1MomentumZ",1574,G__RootEventData_rootcint_460_0_66, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1VolumeName",1651,G__RootEventData_rootcint_460_0_67, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1VolumeNumber",1883,G__RootEventData_rootcint_460_0_68, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1",634,G__RootEventData_rootcint_460_0_69, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1Path",1031,G__RootEventData_rootcint_460_0_70, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1PosSigmaAlongZ",2024,G__RootEventData_rootcint_460_0_71, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1PosSigmaAlongT",2018,G__RootEventData_rootcint_460_0_72, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1PosSigmaAlongX",2022,G__RootEventData_rootcint_460_0_73, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1PosSigmaAlongY",2023,G__RootEventData_rootcint_460_0_74, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1ErrorMatrix",1785,G__RootEventData_rootcint_460_0_75, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j "
"i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2PositionX",1576,G__RootEventData_rootcint_460_0_76, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2PositionY",1577,G__RootEventData_rootcint_460_0_77, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2PositionZ",1578,G__RootEventData_rootcint_460_0_78, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2MomentumX",1573,G__RootEventData_rootcint_460_0_79, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2MomentumY",1574,G__RootEventData_rootcint_460_0_80, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2MomentumZ",1575,G__RootEventData_rootcint_460_0_81, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2VolumeName",1652,G__RootEventData_rootcint_460_0_82, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2VolumeNumber",1884,G__RootEventData_rootcint_460_0_83, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2",635,G__RootEventData_rootcint_460_0_84, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2Path",1032,G__RootEventData_rootcint_460_0_85, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2PosSigmaAlongZ",2025,G__RootEventData_rootcint_460_0_86, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2PosSigmaAlongT",2019,G__RootEventData_rootcint_460_0_87, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2PosSigmaAlongX",2023,G__RootEventData_rootcint_460_0_88, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2PosSigmaAlongY",2024,G__RootEventData_rootcint_460_0_89, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2ErrorMatrix",1786,G__RootEventData_rootcint_460_0_90, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j "
"i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmcPositionX",1506,G__RootEventData_rootcint_460_0_91, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmcPositionY",1507,G__RootEventData_rootcint_460_0_92, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmcPositionZ",1508,G__RootEventData_rootcint_460_0_93, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmcMomentumX",1503,G__RootEventData_rootcint_460_0_94, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmcMomentumY",1504,G__RootEventData_rootcint_460_0_95, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmcMomentumZ",1505,G__RootEventData_rootcint_460_0_96, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmcVolumeName",1582,G__RootEventData_rootcint_460_0_97, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmcVolumeNumber",1814,G__RootEventData_rootcint_460_0_98, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmcPosSigmaAlongTheta",2367,G__RootEventData_rootcint_460_0_99, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmcPosSigmaAlongPhi",2154,G__RootEventData_rootcint_460_0_100, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmcErrorMatrix",1716,G__RootEventData_rootcint_460_0_101, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j "
"i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("emcPath",706,G__RootEventData_rootcint_460_0_102, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucPositionX",1522,G__RootEventData_rootcint_460_0_103, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucPositionY",1523,G__RootEventData_rootcint_460_0_104, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucPositionZ",1524,G__RootEventData_rootcint_460_0_105, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucMomentumX",1519,G__RootEventData_rootcint_460_0_106, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucMomentumY",1520,G__RootEventData_rootcint_460_0_107, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucMomentumZ",1521,G__RootEventData_rootcint_460_0_108, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucVolumeName",1598,G__RootEventData_rootcint_460_0_109, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucVolumeNumber",1830,G__RootEventData_rootcint_460_0_110, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucPosSigmaAlongZ",1971,G__RootEventData_rootcint_460_0_111, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucPosSigmaAlongT",1965,G__RootEventData_rootcint_460_0_112, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucPosSigmaAlongX",1969,G__RootEventData_rootcint_460_0_113, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucPosSigmaAlongY",1970,G__RootEventData_rootcint_460_0_114, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucErrorMatrix",1732,G__RootEventData_rootcint_460_0_115, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j "
"i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSize",699,G__RootEventData_rootcint_460_0_116, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 '2' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPositionX",1229,G__RootEventData_rootcint_460_0_117, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPositionY",1230,G__RootEventData_rootcint_460_0_118, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPositionZ",1231,G__RootEventData_rootcint_460_0_119, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMomentumX",1226,G__RootEventData_rootcint_460_0_120, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMomentumY",1227,G__RootEventData_rootcint_460_0_121, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMomentumZ",1228,G__RootEventData_rootcint_460_0_122, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVolumeName",1305,G__RootEventData_rootcint_460_0_123, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString), -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVolumeNumber",1537,G__RootEventData_rootcint_460_0_124, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPosSigmaAlongZ",1678,G__RootEventData_rootcint_460_0_125, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPosSigmaAlongT",1672,G__RootEventData_rootcint_460_0_126, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPosSigmaAlongX",1676,G__RootEventData_rootcint_460_0_127, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPosSigmaAlongY",1677,G__RootEventData_rootcint_460_0_128, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetErrorMatrix",1439,G__RootEventData_rootcint_460_0_129, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<Double_t>"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 10 '2' k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_460_0_130, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecExtTrack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_460_0_131, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecExtTrack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_460_0_132, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecExtTrack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_460_0_133, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecExtTrack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_460_0_137, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_460_0_138, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecExtTrack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_460_0_139, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecExtTrack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_460_0_140, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecExtTrack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_460_0_141, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecExtTrack::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TRecExtTrack", 1172, G__RootEventData_rootcint_460_0_142, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecExtTrack), -1, 0, 1, 1, 1, 0, "u 'TRecExtTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TRecExtTrack", 1298, G__RootEventData_rootcint_460_0_143, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_460_0_144, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecExtTrack), -1, 1, 1, 1, 1, 0, "u 'TRecExtTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRecEvTime(void) {
   /* TRecEvTime */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEvTime));
   G__memfunc_setup("TRecEvTime",952,G__RootEventData_rootcint_469_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEvTime), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("status",676,G__RootEventData_rootcint_469_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("estime",647,G__RootEventData_rootcint_469_0_3, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("quality",777,G__RootEventData_rootcint_469_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTest",748,G__RootEventData_rootcint_469_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - estime", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setStats",859,G__RootEventData_rootcint_469_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - status", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setQuality",1077,G__RootEventData_rootcint_469_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - quality", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_469_0_8, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecEvTime::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_469_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEvTime::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_469_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecEvTime::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_469_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecEvTime::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_469_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_469_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEvTime::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_469_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecEvTime::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_469_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecEvTime::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_469_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecEvTime::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TRecEvTime", 952, G__RootEventData_rootcint_469_0_20, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEvTime), -1, 0, 1, 1, 1, 0, "u 'TRecEvTime' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TRecEvTime", 1078, G__RootEventData_rootcint_469_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_469_0_22, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEvTime), -1, 1, 1, 1, 1, 0, "u 'TRecEvTime' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRecMdcKalHelixSeg(void) {
   /* TRecMdcKalHelixSeg */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg));
   G__memfunc_setup("TRecMdcKalHelixSeg",1715,G__RootEventData_rootcint_470_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTrackId",994,G__RootEventData_rootcint_470_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFlagLR",856,G__RootEventData_rootcint_470_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMdcId",769,G__RootEventData_rootcint_470_0_4, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTdc",603,G__RootEventData_rootcint_470_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getAdc",584,G__RootEventData_rootcint_470_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getZhit",735,G__RootEventData_rootcint_470_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTof",617,G__RootEventData_rootcint_470_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getDocaIncl",1085,G__RootEventData_rootcint_470_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getDocaExcl",1091,G__RootEventData_rootcint_470_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getDD",456,G__RootEventData_rootcint_470_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEntra",826,G__RootEventData_rootcint_470_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getDT",472,G__RootEventData_rootcint_470_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getHelixIncl",1216,G__RootEventData_rootcint_470_0_14, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getHelixExcl",1222,G__RootEventData_rootcint_470_0_15, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_470_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trkid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFlagLR",868,G__RootEventData_rootcint_470_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - lr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setMdcId",781,G__RootEventData_rootcint_470_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - mdcid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTdc",615,G__RootEventData_rootcint_470_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tdc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setAdc",596,G__RootEventData_rootcint_470_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - adc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZhit",747,G__RootEventData_rootcint_470_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - zhit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTof",629,G__RootEventData_rootcint_470_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDocaIncl",1097,G__RootEventData_rootcint_470_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - docaincl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDocaExcl",1103,G__RootEventData_rootcint_470_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - docaexcl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDD",468,G__RootEventData_rootcint_470_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - dd", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setEntra",838,G__RootEventData_rootcint_470_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - entra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDT",484,G__RootEventData_rootcint_470_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - driftT", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setHelixIncl",1228,G__RootEventData_rootcint_470_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - helix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setHelixExcl",1234,G__RootEventData_rootcint_470_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - helix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_470_0_30, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecMdcKalHelixSeg::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_470_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcKalHelixSeg::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_470_0_32, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecMdcKalHelixSeg::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_470_0_33, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecMdcKalHelixSeg::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_470_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_470_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcKalHelixSeg::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_470_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcKalHelixSeg::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_470_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecMdcKalHelixSeg::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_470_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecMdcKalHelixSeg::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TRecMdcKalHelixSeg", 1715, G__RootEventData_rootcint_470_0_42, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg), -1, 0, 1, 1, 1, 0, "u 'TRecMdcKalHelixSeg' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TRecMdcKalHelixSeg", 1841, G__RootEventData_rootcint_470_0_43, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_470_0_44, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg), -1, 1, 1, 1, 1, 0, "u 'TRecMdcKalHelixSeg' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRecZddChannel(void) {
   /* TRecZddChannel */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel));
   G__memfunc_setup("TRecZddChannel",1353,G__RootEventData_rootcint_471_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("channelId",902,G__RootEventData_rootcint_471_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("scanCode",800,G__RootEventData_rootcint_471_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("baseLine",803,G__RootEventData_rootcint_471_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("phase",529,G__RootEventData_rootcint_471_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("fragments",967,G__RootEventData_rootcint_471_0_6, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR), G__defined_typename("TRecZddChannel::Fragments"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setChannelId",1202,G__RootEventData_rootcint_471_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - chId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setScanCode",1100,G__RootEventData_rootcint_471_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - scanCode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setBaseLine",1103,G__RootEventData_rootcint_471_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - baseLine", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPhase",829,G__RootEventData_rootcint_471_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - phase", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFragments",1267,G__RootEventData_rootcint_471_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<pair<int,float>,allocator<pair<int,float> > >' 'TRecZddChannel::Fragments' 11 - frags", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_471_0_12, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecZddChannel::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_471_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecZddChannel::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_471_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecZddChannel::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_471_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecZddChannel::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_471_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_471_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecZddChannel::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_471_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecZddChannel::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_471_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecZddChannel::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_471_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecZddChannel::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TRecZddChannel", 1353, G__RootEventData_rootcint_471_0_24, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel), -1, 0, 1, 1, 1, 0, "u 'TRecZddChannel' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TRecZddChannel", 1479, G__RootEventData_rootcint_471_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_471_0_26, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel), -1, 1, 1, 1, 1, 0, "u 'TRecZddChannel' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRecTrackEvent(void) {
   /* TRecTrackEvent */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent));
   G__memfunc_setup("TRecTrackEvent",1381,G__RootEventData_rootcint_477_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_477_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("getRecMdcTrackCol",1665,G__RootEventData_rootcint_477_0_5, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addRecMdcTrack",1356,G__RootEventData_rootcint_477_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMdcTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getRecMdcTrack",1379,G__RootEventData_rootcint_477_0_7, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearRecMdcTrackCol",1864,G__RootEventData_rootcint_477_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getRecMdcHitCol",1457,G__RootEventData_rootcint_477_0_9, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addRecMdcHit",1148,G__RootEventData_rootcint_477_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMdcHit' - 0 - Hit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getRecMdcHit",1171,G__RootEventData_rootcint_477_0_11, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearRecMdcHitCol",1656,G__RootEventData_rootcint_477_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTofTrackCol",1404,G__RootEventData_rootcint_477_0_13, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addTofTrack",1095,G__RootEventData_rootcint_477_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecTofTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTofTrack",1118,G__RootEventData_rootcint_477_0_15, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearTofTrackCol",1603,G__RootEventData_rootcint_477_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEmcHitCol",1176,G__RootEventData_rootcint_477_0_17, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addEmcHit",867,G__RootEventData_rootcint_477_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecEmcHit' - 0 - Track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEmcHit",890,G__RootEventData_rootcint_477_0_19, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcHit), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearEmcHitCol",1375,G__RootEventData_rootcint_477_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEmcClusterCol",1621,G__RootEventData_rootcint_477_0_21, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addEmcCluster",1312,G__RootEventData_rootcint_477_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecEmcCluster' - 0 - Track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEmcCluster",1335,G__RootEventData_rootcint_477_0_23, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcCluster), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearEmcClusterCol",1820,G__RootEventData_rootcint_477_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEmcShowerCol",1515,G__RootEventData_rootcint_477_0_25, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addEmcShower",1206,G__RootEventData_rootcint_477_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecEmcShower' - 0 - Track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEmcShower",1229,G__RootEventData_rootcint_477_0_27, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearEmcShowerCol",1714,G__RootEventData_rootcint_477_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMucTrackCol",1400,G__RootEventData_rootcint_477_0_29, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addMucTrack",1091,G__RootEventData_rootcint_477_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMucTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMucTrack",1114,G__RootEventData_rootcint_477_0_31, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearMucTrackCol",1599,G__RootEventData_rootcint_477_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getRecMdcDedxCol",1553,G__RootEventData_rootcint_477_0_33, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addRecMdcDedx",1244,G__RootEventData_rootcint_477_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMdcDedx' - 0 - Track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getRecMdcDedx",1267,G__RootEventData_rootcint_477_0_35, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedx), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearRecMdcDedxCol",1752,G__RootEventData_rootcint_477_0_36, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getRecMdcDedxHitCol",1846,G__RootEventData_rootcint_477_0_37, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addRecMdcDedxHit",1537,G__RootEventData_rootcint_477_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMdcDedxHit' - 0 - Track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getRecMdcDedxHit",1560,G__RootEventData_rootcint_477_0_39, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcDedxHit), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearRecMdcDedxHitCol",2045,G__RootEventData_rootcint_477_0_40, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getExtTrackCol",1412,G__RootEventData_rootcint_477_0_41, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addExtTrack",1103,G__RootEventData_rootcint_477_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecExtTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getExtTrack",1126,G__RootEventData_rootcint_477_0_43, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecExtTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearExtTrackCol",1611,G__RootEventData_rootcint_477_0_44, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getRecMdcKalTrackCol",1945,G__RootEventData_rootcint_477_0_45, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addRecMdcKalTrack",1636,G__RootEventData_rootcint_477_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMdcKalTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getRecMdcKalTrack",1659,G__RootEventData_rootcint_477_0_47, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearRecMdcKalTrackCol",2144,G__RootEventData_rootcint_477_0_48, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getRecMdcKalHelixSegCol",2237,G__RootEventData_rootcint_477_0_49, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addRecMdcKalHelixSeg",1928,G__RootEventData_rootcint_477_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMdcKalHelixSeg' - 0 - Track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getRecMdcKalHelixSeg",1951,G__RootEventData_rootcint_477_0_51, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearRecMdcKalHelixSegCol",2436,G__RootEventData_rootcint_477_0_52, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEvTimeCol",1192,G__RootEventData_rootcint_477_0_53, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addEvTime",883,G__RootEventData_rootcint_477_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecEvTime' - 0 - Track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEvTime",906,G__RootEventData_rootcint_477_0_55, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEvTime), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearEvTimeCol",1391,G__RootEventData_rootcint_477_0_56, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getRecZddChannelCol",1875,G__RootEventData_rootcint_477_0_57, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addRecZddChannel",1566,G__RootEventData_rootcint_477_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecZddChannel' - 0 - dtag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getRecZddChannel",1589,G__RootEventData_rootcint_477_0_59, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecZddChannel), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearRecZddChannelCol",2074,G__RootEventData_rootcint_477_0_60, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_477_0_61, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRecTrackEvent::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_477_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecTrackEvent::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_477_0_63, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRecTrackEvent::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_477_0_64, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRecTrackEvent::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_477_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_477_0_69, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecTrackEvent::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_477_0_70, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecTrackEvent::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_477_0_71, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRecTrackEvent::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_477_0_72, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRecTrackEvent::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TRecTrackEvent", 1381, G__RootEventData_rootcint_477_0_73, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent), -1, 0, 1, 1, 1, 0, "u 'TRecTrackEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TRecTrackEvent", 1507, G__RootEventData_rootcint_477_0_74, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_477_0_75, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent), -1, 1, 1, 1, 1, 0, "u 'TRecTrackEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMdcTrack(void) {
   /* TMdcTrack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack));
   G__memfunc_setup("TMdcTrack",861,G__RootEventData_rootcint_478_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("trackId",706,G__RootEventData_rootcint_478_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("helix",538,G__RootEventData_rootcint_478_0_3, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("stat",444,G__RootEventData_rootcint_478_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("chi2",358,G__RootEventData_rootcint_478_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ndof",423,G__RootEventData_rootcint_478_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("err",329,G__RootEventData_rootcint_478_0_7, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("nster",556,G__RootEventData_rootcint_478_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("nlayer",651,G__RootEventData_rootcint_478_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("firstLayer",1061,G__RootEventData_rootcint_478_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("lastLayer",945,G__RootEventData_rootcint_478_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("x",120,G__RootEventData_rootcint_478_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("y",121,G__RootEventData_rootcint_478_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("z",122,G__RootEventData_rootcint_478_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("r",114,G__RootEventData_rootcint_478_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("charge",618,G__RootEventData_rootcint_478_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pxy",353,G__RootEventData_rootcint_478_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("px",232,G__RootEventData_rootcint_478_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("py",233,G__RootEventData_rootcint_478_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pz",234,G__RootEventData_rootcint_478_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("p",112,G__RootEventData_rootcint_478_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("theta",534,G__RootEventData_rootcint_478_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("phi",321,G__RootEventData_rootcint_478_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setHelix",838,G__RootEventData_rootcint_478_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - helix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setErr",629,G__RootEventData_rootcint_478_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - err", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_478_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trackId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setStat",744,G__RootEventData_rootcint_478_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - stat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setChi2",658,G__RootEventData_rootcint_478_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNdof",723,G__RootEventData_rootcint_478_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - ndof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNster",856,G__RootEventData_rootcint_478_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - ns", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNlayer",951,G__RootEventData_rootcint_478_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - nlayer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFirstLayer",1361,G__RootEventData_rootcint_478_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - fL", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLastLayer",1245,G__RootEventData_rootcint_478_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - lL", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_478_0_34, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMdcTrack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_478_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcTrack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_478_0_36, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMdcTrack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_478_0_37, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMdcTrack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_478_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_478_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcTrack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_478_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMdcTrack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_478_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcTrack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_478_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMdcTrack::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TMdcTrack", 861, G__RootEventData_rootcint_478_0_46, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack), -1, 0, 1, 1, 1, 0, "u 'TMdcTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TMdcTrack", 987, G__RootEventData_rootcint_478_0_47, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_478_0_48, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack), -1, 1, 1, 1, 1, 0, "u 'TMdcTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEmcTrack(void) {
   /* TEmcTrack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack));
   G__memfunc_setup("TEmcTrack",862,G__RootEventData_rootcint_479_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("trackId",706,G__RootEventData_rootcint_479_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("numHits",744,G__RootEventData_rootcint_479_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("status",676,G__RootEventData_rootcint_479_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("cellId",589,G__RootEventData_rootcint_479_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("module",646,G__RootEventData_rootcint_479_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("x",120,G__RootEventData_rootcint_479_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("y",121,G__RootEventData_rootcint_479_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("z",122,G__RootEventData_rootcint_479_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("theta",534,G__RootEventData_rootcint_479_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("phi",321,G__RootEventData_rootcint_479_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("dx",220,G__RootEventData_rootcint_479_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("dy",221,G__RootEventData_rootcint_479_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("dz",222,G__RootEventData_rootcint_479_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("dtheta",634,G__RootEventData_rootcint_479_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("dphi",421,G__RootEventData_rootcint_479_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("energy",650,G__RootEventData_rootcint_479_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("dE",169,G__RootEventData_rootcint_479_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("eSeed",486,G__RootEventData_rootcint_479_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("e3x3",323,G__RootEventData_rootcint_479_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("e5x5",327,G__RootEventData_rootcint_479_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("time",431,G__RootEventData_rootcint_479_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("secondMoment",1260,G__RootEventData_rootcint_479_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("latMoment",945,G__RootEventData_rootcint_479_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("a20Moment",819,G__RootEventData_rootcint_479_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("a42Moment",823,G__RootEventData_rootcint_479_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("err",329,G__RootEventData_rootcint_479_0_27, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_479_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trackId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNumHits",1044,G__RootEventData_rootcint_479_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - hit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setStatus",976,G__RootEventData_rootcint_479_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - st", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setCellId",889,G__RootEventData_rootcint_479_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setModule",946,G__RootEventData_rootcint_479_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - mod", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setX",420,G__RootEventData_rootcint_479_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setY",421,G__RootEventData_rootcint_479_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZ",422,G__RootEventData_rootcint_479_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setEnergy",950,G__RootEventData_rootcint_479_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDE",469,G__RootEventData_rootcint_479_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - de", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDtheta",934,G__RootEventData_rootcint_479_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - dt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDphi",721,G__RootEventData_rootcint_479_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - dpi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setESeed",786,G__RootEventData_rootcint_479_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - eSeed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setE3x3",623,G__RootEventData_rootcint_479_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - e3x3", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setE5x5",627,G__RootEventData_rootcint_479_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - e5x5", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTime",731,G__RootEventData_rootcint_479_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setSecondMoment",1560,G__RootEventData_rootcint_479_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - secondMoment", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLatMoment",1245,G__RootEventData_rootcint_479_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - latMoment", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setA20Moment",1119,G__RootEventData_rootcint_479_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - a20Moment", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setA42Moment",1123,G__RootEventData_rootcint_479_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - a42Moment", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setErr",629,G__RootEventData_rootcint_479_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - err", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_479_0_49, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEmcTrack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_479_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEmcTrack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_479_0_51, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEmcTrack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_479_0_52, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEmcTrack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_479_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_479_0_57, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEmcTrack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_479_0_58, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEmcTrack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_479_0_59, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEmcTrack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_479_0_60, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEmcTrack::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEmcTrack", 862, G__RootEventData_rootcint_479_0_61, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack), -1, 0, 1, 1, 1, 0, "u 'TEmcTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEmcTrack", 988, G__RootEventData_rootcint_479_0_62, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_479_0_63, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack), -1, 1, 1, 1, 1, 0, "u 'TEmcTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMucTrack(void) {
   /* TMucTrack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack));
   G__memfunc_setup("TMucTrack",878,G__RootEventData_rootcint_480_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("trackId",706,G__RootEventData_rootcint_480_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("id",205,G__RootEventData_rootcint_480_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("status",676,G__RootEventData_rootcint_480_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("type",450,G__RootEventData_rootcint_480_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("startPart",965,G__RootEventData_rootcint_480_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "start position of track locates in which part", (void*) NULL, 0);
   G__memfunc_setup("endPart",718,G__RootEventData_rootcint_480_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "end   position of track locates in which part", (void*) NULL, 0);
   G__memfunc_setup("brLastLayer",1125,G__RootEventData_rootcint_480_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "last layer with hits in barrel ", (void*) NULL, 0);
   G__memfunc_setup("ecLastLayer",1113,G__RootEventData_rootcint_480_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "last layer with hits in end cap", (void*) NULL, 0);
   G__memfunc_setup("numHits",744,G__RootEventData_rootcint_480_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "total hits on the track   ", (void*) NULL, 0);
   G__memfunc_setup("numLayers",960,G__RootEventData_rootcint_480_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "number of layers with hits ", (void*) NULL, 0);
   G__memfunc_setup("maxHitsInLayer",1426,G__RootEventData_rootcint_480_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("depth",533,G__RootEventData_rootcint_480_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "depth of the track transport in iron", (void*) NULL, 0);
   G__memfunc_setup("chi2",358,G__RootEventData_rootcint_480_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("dof",313,G__RootEventData_rootcint_480_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rms",338,G__RootEventData_rootcint_480_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("xPos",426,G__RootEventData_rootcint_480_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "position on the start of track in muc (vertex) ", (void*) NULL, 0);
   G__memfunc_setup("yPos",427,G__RootEventData_rootcint_480_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("zPos",428,G__RootEventData_rootcint_480_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("xPosSigma",923,G__RootEventData_rootcint_480_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("yPosSigma",924,G__RootEventData_rootcint_480_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("zPosSigma",925,G__RootEventData_rootcint_480_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("px",232,G__RootEventData_rootcint_480_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "momentum on the start of track in muc", (void*) NULL, 0);
   G__memfunc_setup("py",233,G__RootEventData_rootcint_480_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pz",234,G__RootEventData_rootcint_480_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("distance",843,G__RootEventData_rootcint_480_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("deltaPhi",811,G__RootEventData_rootcint_480_0_27, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("kalRechi2",853,G__RootEventData_rootcint_480_0_28, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("kaldof",625,G__RootEventData_rootcint_480_0_29, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("kaldepth",845,G__RootEventData_rootcint_480_0_30, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("kalbrLastLayer",1437,G__RootEventData_rootcint_480_0_31, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("kalecLastLayer",1425,G__RootEventData_rootcint_480_0_32, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_480_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trackId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setId",505,G__RootEventData_rootcint_480_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setStatus",976,G__RootEventData_rootcint_480_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - st", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setType",750,G__RootEventData_rootcint_480_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setStartPart",1265,G__RootEventData_rootcint_480_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - part", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setEndPart",1018,G__RootEventData_rootcint_480_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - part", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setBrLastLayer",1425,G__RootEventData_rootcint_480_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - layer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setEcLastLayer",1413,G__RootEventData_rootcint_480_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - layer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNumHits",1044,G__RootEventData_rootcint_480_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - numHits", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNumLayers",1260,G__RootEventData_rootcint_480_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - numLayers", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setMaxHitsInLayer",1726,G__RootEventData_rootcint_480_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - maxHits", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDepth",833,G__RootEventData_rootcint_480_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - depth", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setChi2",658,G__RootEventData_rootcint_480_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - chi2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDof",613,G__RootEventData_rootcint_480_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - dof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setRms",638,G__RootEventData_rootcint_480_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - rms", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setXPos",726,G__RootEventData_rootcint_480_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setYPos",727,G__RootEventData_rootcint_480_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZPos",728,G__RootEventData_rootcint_480_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setXPosSigma",1223,G__RootEventData_rootcint_480_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setYPosSigma",1224,G__RootEventData_rootcint_480_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZPosSigma",1225,G__RootEventData_rootcint_480_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPx",532,G__RootEventData_rootcint_480_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - px", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPy",533,G__RootEventData_rootcint_480_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - py", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPz",534,G__RootEventData_rootcint_480_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - pz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDistance",1143,G__RootEventData_rootcint_480_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - dist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDeltaPhi",1111,G__RootEventData_rootcint_480_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - dphi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setkalRechi2",1185,G__RootEventData_rootcint_480_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - ch", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setkalDof",925,G__RootEventData_rootcint_480_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setkalDepth",1145,G__RootEventData_rootcint_480_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - de", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setkalbrLastLayer",1769,G__RootEventData_rootcint_480_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - br", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setkalecLastLayer",1757,G__RootEventData_rootcint_480_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_480_0_64, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMucTrack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_480_0_65, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMucTrack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_480_0_66, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMucTrack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_480_0_67, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMucTrack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_480_0_71, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_480_0_72, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMucTrack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_480_0_73, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMucTrack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_480_0_74, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMucTrack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_480_0_75, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMucTrack::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TMucTrack", 878, G__RootEventData_rootcint_480_0_76, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack), -1, 0, 1, 1, 1, 0, "u 'TMucTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TMucTrack", 1004, G__RootEventData_rootcint_480_0_77, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_480_0_78, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack), -1, 1, 1, 1, 1, 0, "u 'TMucTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMdcDedx(void) {
   /* TMdcDedx */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx));
   G__memfunc_setup("TMdcDedx",749,G__RootEventData_rootcint_481_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("trackId",706,G__RootEventData_rootcint_481_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("particleId",1025,G__RootEventData_rootcint_481_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("status",676,G__RootEventData_rootcint_481_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("truncAlg",832,G__RootEventData_rootcint_481_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("chi",308,G__RootEventData_rootcint_481_0_6, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("chiE",377,G__RootEventData_rootcint_481_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("chiMu",502,G__RootEventData_rootcint_481_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("chiPi",493,G__RootEventData_rootcint_481_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("chiK",383,G__RootEventData_rootcint_481_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("chiP",388,G__RootEventData_rootcint_481_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("numGoodHits",1137,G__RootEventData_rootcint_481_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("numTotalHits",1260,G__RootEventData_rootcint_481_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("probPH",587,G__RootEventData_rootcint_481_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("normPH",596,G__RootEventData_rootcint_481_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("errorPH",706,G__RootEventData_rootcint_481_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("twentyPH",835,G__RootEventData_rootcint_481_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_481_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trackId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setParticleId",1325,G__RootEventData_rootcint_481_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - particleId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setStatus",976,G__RootEventData_rootcint_481_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - status", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTruncAlg",1132,G__RootEventData_rootcint_481_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trunc_alg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setChiE",677,G__RootEventData_rootcint_481_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chiE", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setChiMu",802,G__RootEventData_rootcint_481_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chiMu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setChiPi",793,G__RootEventData_rootcint_481_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chiPi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setChiK",683,G__RootEventData_rootcint_481_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chiK", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setChiP",688,G__RootEventData_rootcint_481_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - chiP", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNumGoodHits",1437,G__RootEventData_rootcint_481_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - numGoodHits", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNumTotalHits",1560,G__RootEventData_rootcint_481_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - numTotalHits", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setProbPH",887,G__RootEventData_rootcint_481_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - probPH", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNormPH",896,G__RootEventData_rootcint_481_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - normPH", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setErrorPH",1006,G__RootEventData_rootcint_481_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - errorPH", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTwentyPH",1135,G__RootEventData_rootcint_481_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - twentyPH", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_481_0_33, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMdcDedx::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_481_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcDedx::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_481_0_35, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMdcDedx::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_481_0_36, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMdcDedx::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_481_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_481_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcDedx::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_481_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMdcDedx::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_481_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcDedx::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_481_0_44, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMdcDedx::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TMdcDedx", 749, G__RootEventData_rootcint_481_0_45, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx), -1, 0, 1, 1, 1, 0, "u 'TMdcDedx' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TMdcDedx", 875, G__RootEventData_rootcint_481_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_481_0_47, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx), -1, 1, 1, 1, 1, 0, "u 'TMdcDedx' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTExtTrack(void) {
   /* TExtTrack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack));
   G__memfunc_setup("TExtTrack",890,G__RootEventData_rootcint_483_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTrackId",974,G__RootEventData_rootcint_483_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trackId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1PositionX",1587,G__RootEventData_rootcint_483_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1PositionX", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1PositionY",1588,G__RootEventData_rootcint_483_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1PositionY", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1PositionZ",1589,G__RootEventData_rootcint_483_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1PositionZ", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1MomentumX",1584,G__RootEventData_rootcint_483_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1MomentumX", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1MomentumY",1585,G__RootEventData_rootcint_483_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1MomentumY", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1MomentumZ",1586,G__RootEventData_rootcint_483_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1MomentumZ", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1VolumeName",1663,G__RootEventData_rootcint_483_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 10 - Tof1VolumeName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1VolumeNumber",1895,G__RootEventData_rootcint_483_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - Tof1VolumeNumber", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1",646,G__RootEventData_rootcint_483_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1Path",1043,G__RootEventData_rootcint_483_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1Path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1PosSigmaAlongZ",2036,G__RootEventData_rootcint_483_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1PosSigmaAlongZ", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1PosSigmaAlongT",2030,G__RootEventData_rootcint_483_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1PosSigmaAlongT", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1PosSigmaAlongX",2034,G__RootEventData_rootcint_483_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1PosSigmaAlongX", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1PosSigmaAlongY",2035,G__RootEventData_rootcint_483_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof1PosSigmaAlongY", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof1ErrorMatrix",1797,G__RootEventData_rootcint_483_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - Tof1ErrorMatrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2PositionX",1588,G__RootEventData_rootcint_483_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2PositionX", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2PositionY",1589,G__RootEventData_rootcint_483_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2PositionY", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2PositionZ",1590,G__RootEventData_rootcint_483_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2PositionZ", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2MomentumX",1585,G__RootEventData_rootcint_483_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2MomentumX", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2MomentumY",1586,G__RootEventData_rootcint_483_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2MomentumY", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2MomentumZ",1587,G__RootEventData_rootcint_483_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2MomentumZ", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2VolumeName",1664,G__RootEventData_rootcint_483_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 10 - Tof2VolumeName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2VolumeNumber",1896,G__RootEventData_rootcint_483_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - Tof2VolumeNumber", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2",647,G__RootEventData_rootcint_483_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2Path",1044,G__RootEventData_rootcint_483_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2Path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2PosSigmaAlongZ",2037,G__RootEventData_rootcint_483_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2PosSigmaAlongZ", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2PosSigmaAlongT",2031,G__RootEventData_rootcint_483_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2PosSigmaAlongT", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2PosSigmaAlongX",2035,G__RootEventData_rootcint_483_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2PosSigmaAlongX", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2PosSigmaAlongY",2036,G__RootEventData_rootcint_483_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - Tof2PosSigmaAlongY", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTof2ErrorMatrix",1798,G__RootEventData_rootcint_483_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - Tof2ErrorMatrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcPositionX",1518,G__RootEventData_rootcint_483_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - EmcPositionX", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcPositionY",1519,G__RootEventData_rootcint_483_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - EmcPositionY", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcPositionZ",1520,G__RootEventData_rootcint_483_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - EmcPositionZ", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcMomentumX",1515,G__RootEventData_rootcint_483_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - EmcMomentumX", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcMomentumY",1516,G__RootEventData_rootcint_483_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - EmcMomentumY", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcMomentumZ",1517,G__RootEventData_rootcint_483_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - EmcMomentumZ", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcVolumeName",1594,G__RootEventData_rootcint_483_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 10 - EmcVolumeName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcVolumeNumber",1826,G__RootEventData_rootcint_483_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - EmcVolumeNumber", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcPosSigmaAlongTheta",2379,G__RootEventData_rootcint_483_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - EmcPosSigmaAlongTheta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcPosSigmaAlongPhi",2166,G__RootEventData_rootcint_483_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - EmcPosSigmaAlongPhi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcErrorMatrix",1728,G__RootEventData_rootcint_483_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - EmcErrorMatrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmcPath",974,G__RootEventData_rootcint_483_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucPositionX",1534,G__RootEventData_rootcint_483_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - MucPositionX", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucPositionY",1535,G__RootEventData_rootcint_483_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - MucPositionY", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucPositionZ",1536,G__RootEventData_rootcint_483_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - MucPositionZ", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucMomentumX",1531,G__RootEventData_rootcint_483_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - MucMomentumX", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucMomentumY",1532,G__RootEventData_rootcint_483_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - MucMomentumY", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucMomentumZ",1533,G__RootEventData_rootcint_483_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - MucMomentumZ", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucVolumeName",1610,G__RootEventData_rootcint_483_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 10 - MucVolumeName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucVolumeNumber",1842,G__RootEventData_rootcint_483_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - MucVolumeNumber", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucPosSigmaAlongZ",1983,G__RootEventData_rootcint_483_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - MucPosSigmaAlongZ", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucPosSigmaAlongT",1977,G__RootEventData_rootcint_483_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - MucPosSigmaAlongT", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucPosSigmaAlongX",1981,G__RootEventData_rootcint_483_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - MucPosSigmaAlongX", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucPosSigmaAlongY",1982,G__RootEventData_rootcint_483_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - MucPosSigmaAlongY", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMucErrorMatrix",1744,G__RootEventData_rootcint_483_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - MucErrorMatrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrackId",962,G__RootEventData_rootcint_483_0_58, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1PositionX",1575,G__RootEventData_rootcint_483_0_59, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1PositionY",1576,G__RootEventData_rootcint_483_0_60, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1PositionZ",1577,G__RootEventData_rootcint_483_0_61, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1MomentumX",1572,G__RootEventData_rootcint_483_0_62, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1MomentumY",1573,G__RootEventData_rootcint_483_0_63, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1MomentumZ",1574,G__RootEventData_rootcint_483_0_64, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1VolumeName",1651,G__RootEventData_rootcint_483_0_65, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1VolumeNumber",1883,G__RootEventData_rootcint_483_0_66, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1",634,G__RootEventData_rootcint_483_0_67, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1Path",1031,G__RootEventData_rootcint_483_0_68, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1PosSigmaAlongZ",2024,G__RootEventData_rootcint_483_0_69, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1PosSigmaAlongT",2018,G__RootEventData_rootcint_483_0_70, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1PosSigmaAlongX",2022,G__RootEventData_rootcint_483_0_71, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1PosSigmaAlongY",2023,G__RootEventData_rootcint_483_0_72, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof1ErrorMatrix",1785,G__RootEventData_rootcint_483_0_73, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2PositionX",1576,G__RootEventData_rootcint_483_0_74, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2PositionY",1577,G__RootEventData_rootcint_483_0_75, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2PositionZ",1578,G__RootEventData_rootcint_483_0_76, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2MomentumX",1573,G__RootEventData_rootcint_483_0_77, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2MomentumY",1574,G__RootEventData_rootcint_483_0_78, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2MomentumZ",1575,G__RootEventData_rootcint_483_0_79, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2VolumeName",1652,G__RootEventData_rootcint_483_0_80, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2VolumeNumber",1884,G__RootEventData_rootcint_483_0_81, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2",635,G__RootEventData_rootcint_483_0_82, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2Path",1032,G__RootEventData_rootcint_483_0_83, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2PosSigmaAlongZ",2025,G__RootEventData_rootcint_483_0_84, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2PosSigmaAlongT",2019,G__RootEventData_rootcint_483_0_85, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2PosSigmaAlongX",2023,G__RootEventData_rootcint_483_0_86, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2PosSigmaAlongY",2024,G__RootEventData_rootcint_483_0_87, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTof2ErrorMatrix",1786,G__RootEventData_rootcint_483_0_88, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmcPositionX",1506,G__RootEventData_rootcint_483_0_89, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmcPositionY",1507,G__RootEventData_rootcint_483_0_90, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmcPositionZ",1508,G__RootEventData_rootcint_483_0_91, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmcMomentumX",1503,G__RootEventData_rootcint_483_0_92, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmcMomentumY",1504,G__RootEventData_rootcint_483_0_93, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmcMomentumZ",1505,G__RootEventData_rootcint_483_0_94, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmcVolumeName",1582,G__RootEventData_rootcint_483_0_95, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmcVolumeNumber",1814,G__RootEventData_rootcint_483_0_96, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmcPosSigmaAlongTheta",2367,G__RootEventData_rootcint_483_0_97, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmcPosSigmaAlongPhi",2154,G__RootEventData_rootcint_483_0_98, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmcErrorMatrix",1716,G__RootEventData_rootcint_483_0_99, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("emcPath",706,G__RootEventData_rootcint_483_0_100, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucPositionX",1522,G__RootEventData_rootcint_483_0_101, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucPositionY",1523,G__RootEventData_rootcint_483_0_102, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucPositionZ",1524,G__RootEventData_rootcint_483_0_103, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucMomentumX",1519,G__RootEventData_rootcint_483_0_104, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucMomentumY",1520,G__RootEventData_rootcint_483_0_105, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucMomentumZ",1521,G__RootEventData_rootcint_483_0_106, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucVolumeName",1598,G__RootEventData_rootcint_483_0_107, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucVolumeNumber",1830,G__RootEventData_rootcint_483_0_108, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucPosSigmaAlongZ",1971,G__RootEventData_rootcint_483_0_109, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucPosSigmaAlongT",1965,G__RootEventData_rootcint_483_0_110, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucPosSigmaAlongX",1969,G__RootEventData_rootcint_483_0_111, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucPosSigmaAlongY",1970,G__RootEventData_rootcint_483_0_112, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMucErrorMatrix",1732,G__RootEventData_rootcint_483_0_113, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_483_0_114, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TExtTrack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_483_0_115, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TExtTrack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_483_0_116, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TExtTrack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_483_0_117, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TExtTrack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_483_0_121, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_483_0_122, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TExtTrack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_483_0_123, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TExtTrack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_483_0_124, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TExtTrack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_483_0_125, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TExtTrack::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TExtTrack", 890, G__RootEventData_rootcint_483_0_126, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack), -1, 0, 1, 1, 1, 0, "u 'TExtTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TExtTrack", 1016, G__RootEventData_rootcint_483_0_127, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_483_0_128, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack), -1, 1, 1, 1, 1, 0, "u 'TExtTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMdcKalTrack(void) {
   /* TMdcKalTrack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack));
   G__memfunc_setup("TMdcKalTrack",1141,G__RootEventData_rootcint_484_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTrackId",994,G__RootEventData_rootcint_484_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getStat",732,G__RootEventData_rootcint_484_0_3, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getStat2",782,G__RootEventData_rootcint_484_0_4, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getChisq",824,G__RootEventData_rootcint_484_0_5, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getNdf",600,G__RootEventData_rootcint_484_0_6, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getNlayer",939,G__RootEventData_rootcint_484_0_7, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getZHelix",916,G__RootEventData_rootcint_484_0_8, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getZError",932,G__RootEventData_rootcint_484_0_9, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getZHelixE",985,G__RootEventData_rootcint_484_0_10, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getZErrorE",1001,G__RootEventData_rootcint_484_0_11, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getZHelixMu",1110,G__RootEventData_rootcint_484_0_12, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getZErrorMu",1126,G__RootEventData_rootcint_484_0_13, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getZHelixK",991,G__RootEventData_rootcint_484_0_14, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getZErrorK",1007,G__RootEventData_rootcint_484_0_15, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getZHelixP",996,G__RootEventData_rootcint_484_0_16, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getZErrorP",1012,G__RootEventData_rootcint_484_0_17, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFHelix",896,G__RootEventData_rootcint_484_0_18, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFError",912,G__RootEventData_rootcint_484_0_19, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFHelixE",965,G__RootEventData_rootcint_484_0_20, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFErrorE",981,G__RootEventData_rootcint_484_0_21, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFHelixMu",1090,G__RootEventData_rootcint_484_0_22, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFErrorMu",1106,G__RootEventData_rootcint_484_0_23, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFHelixK",971,G__RootEventData_rootcint_484_0_24, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFErrorK",987,G__RootEventData_rootcint_484_0_25, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFHelixP",976,G__RootEventData_rootcint_484_0_26, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFErrorP",992,G__RootEventData_rootcint_484_0_27, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_484_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - trackId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setStat",744,G__RootEventData_rootcint_484_0_29, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 10 - stat i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setStat2",794,G__RootEventData_rootcint_484_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 10 - stat i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setChisq",836,G__RootEventData_rootcint_484_0_31, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 10 - chisq i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNdf",612,G__RootEventData_rootcint_484_0_32, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 10 - ndf i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNlayer",951,G__RootEventData_rootcint_484_0_33, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 10 - nlayer i - 'Int_t' 10 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZHelix",928,G__RootEventData_rootcint_484_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - zhelix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZError",944,G__RootEventData_rootcint_484_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - zerror", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZHelixE",997,G__RootEventData_rootcint_484_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - zhelix_e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZErrorE",1013,G__RootEventData_rootcint_484_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - zerror_e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZHelixMu",1122,G__RootEventData_rootcint_484_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - zhelix_mu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZErrorMu",1138,G__RootEventData_rootcint_484_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - zerror_mu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZHelixK",1003,G__RootEventData_rootcint_484_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - zhelix_k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZErrorK",1019,G__RootEventData_rootcint_484_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - zerror_k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZHelixP",1008,G__RootEventData_rootcint_484_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - zhelix_p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setZErrorP",1024,G__RootEventData_rootcint_484_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - zerror_p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFHelix",908,G__RootEventData_rootcint_484_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - fhelix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFError",924,G__RootEventData_rootcint_484_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - ferror", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFHelixE",977,G__RootEventData_rootcint_484_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - fhelix_e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFErrorE",993,G__RootEventData_rootcint_484_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - ferror_e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFHelixMu",1102,G__RootEventData_rootcint_484_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - fhelix_mu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFErrorMu",1118,G__RootEventData_rootcint_484_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - ferror_mu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFHelixK",983,G__RootEventData_rootcint_484_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - fhelix_k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFErrorK",999,G__RootEventData_rootcint_484_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - ferror_k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFHelixP",988,G__RootEventData_rootcint_484_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - fhelix_p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFErrorP",1004,G__RootEventData_rootcint_484_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 12 - ferror_p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_484_0_54, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMdcKalTrack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_484_0_55, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcKalTrack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_484_0_56, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMdcKalTrack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_484_0_57, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMdcKalTrack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_484_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_484_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcKalTrack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_484_0_63, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMdcKalTrack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_484_0_64, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcKalTrack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_484_0_65, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMdcKalTrack::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TMdcKalTrack", 1141, G__RootEventData_rootcint_484_0_66, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack), -1, 0, 1, 1, 1, 0, "u 'TMdcKalTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TMdcKalTrack", 1267, G__RootEventData_rootcint_484_0_67, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_484_0_68, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack), -1, 1, 1, 1, 1, 0, "u 'TMdcKalTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTDstEvent(void) {
   /* TDstEvent */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent));
   G__memfunc_setup("TDstEvent",897,G__RootEventData_rootcint_485_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_485_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("getMdcTrackCol",1383,G__RootEventData_rootcint_485_0_5, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addMdcTrack",1074,G__RootEventData_rootcint_485_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMdcTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMdcTrack",1097,G__RootEventData_rootcint_485_0_7, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearMdcTrackCol",1582,G__RootEventData_rootcint_485_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEmcTrackCol",1384,G__RootEventData_rootcint_485_0_9, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addEmcTrack",1075,G__RootEventData_rootcint_485_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEmcTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEmcTrack",1098,G__RootEventData_rootcint_485_0_11, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearEmcTrackCol",1583,G__RootEventData_rootcint_485_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTofTrackCol",1404,G__RootEventData_rootcint_485_0_13, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addTofTrack",1095,G__RootEventData_rootcint_485_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTofTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTofTrack",1118,G__RootEventData_rootcint_485_0_15, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearTofTrackCol",1603,G__RootEventData_rootcint_485_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMucTrackCol",1400,G__RootEventData_rootcint_485_0_17, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addMucTrack",1091,G__RootEventData_rootcint_485_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMucTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMucTrack",1114,G__RootEventData_rootcint_485_0_19, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearMucTrackCol",1599,G__RootEventData_rootcint_485_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMdcDedxCol",1271,G__RootEventData_rootcint_485_0_21, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addMdcDedx",962,G__RootEventData_rootcint_485_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMdcDedx' - 0 - Track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMdcDedx",985,G__RootEventData_rootcint_485_0_23, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcDedx), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearMdcDedxCol",1470,G__RootEventData_rootcint_485_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getExtTrackCol",1412,G__RootEventData_rootcint_485_0_25, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addExtTrack",1103,G__RootEventData_rootcint_485_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TExtTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getExtTrack",1126,G__RootEventData_rootcint_485_0_27, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TExtTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearExtTrackCol",1611,G__RootEventData_rootcint_485_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMdcKalTrackCol",1663,G__RootEventData_rootcint_485_0_29, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addMdcKalTrack",1354,G__RootEventData_rootcint_485_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMdcKalTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMdcKalTrack",1377,G__RootEventData_rootcint_485_0_31, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcKalTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearMdcKalTrackCol",1862,G__RootEventData_rootcint_485_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_485_0_33, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDstEvent::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_485_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDstEvent::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_485_0_35, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDstEvent::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_485_0_36, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDstEvent::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_485_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_485_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDstEvent::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_485_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDstEvent::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_485_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDstEvent::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_485_0_44, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDstEvent::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TDstEvent", 897, G__RootEventData_rootcint_485_0_45, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent), -1, 0, 1, 1, 1, 0, "u 'TDstEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TDstEvent", 1023, G__RootEventData_rootcint_485_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_485_0_47, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent), -1, 1, 1, 1, 1, 0, "u 'TDstEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMdcMc(void) {
   /* TMdcMc */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc));
   G__memfunc_setup("TMdcMc",536,G__RootEventData_rootcint_486_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getId",493,G__RootEventData_rootcint_486_0_2, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTrackIndex",1325,G__RootEventData_rootcint_486_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPositionX",1261,G__RootEventData_rootcint_486_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPositionY",1262,G__RootEventData_rootcint_486_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPositionZ",1263,G__RootEventData_rootcint_486_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getDriftDistance",1636,G__RootEventData_rootcint_486_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getDepositEnergy",1666,G__RootEventData_rootcint_486_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPositionFlag",1551,G__RootEventData_rootcint_486_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setId",505,G__RootEventData_rootcint_486_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrackIndex",1337,G__RootEventData_rootcint_486_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - trackIndex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPositionX",1273,G__RootEventData_rootcint_486_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionX", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPositionY",1274,G__RootEventData_rootcint_486_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionY", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPositionZ",1275,G__RootEventData_rootcint_486_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionZ", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDriftDistance",1648,G__RootEventData_rootcint_486_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - driftDistance", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDepositEnergy",1678,G__RootEventData_rootcint_486_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - depositEnergy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPositionFlag",1563,G__RootEventData_rootcint_486_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - posFlag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_486_0_18, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMdcMc::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_486_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcMc::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_486_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMdcMc::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_486_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMdcMc::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_486_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_486_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcMc::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_486_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMdcMc::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_486_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMdcMc::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_486_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMdcMc::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TMdcMc", 536, G__RootEventData_rootcint_486_0_30, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc), -1, 0, 1, 1, 1, 0, "u 'TMdcMc' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TMdcMc", 662, G__RootEventData_rootcint_486_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_486_0_32, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc), -1, 1, 1, 1, 1, 0, "u 'TMdcMc' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEmcMc(void) {
   /* TEmcMc */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc));
   G__memfunc_setup("TEmcMc",537,G__RootEventData_rootcint_487_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getHitMap",899,G__RootEventData_rootcint_487_0_2, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR), G__defined_typename("map<Int_t,Double_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getHitEmc",890,G__RootEventData_rootcint_487_0_3, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPDGCode",918,G__RootEventData_rootcint_487_0_4, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPDGCharge",1125,G__RootEventData_rootcint_487_0_5, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTime",719,G__RootEventData_rootcint_487_0_6, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getId",493,G__RootEventData_rootcint_487_0_7, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTrackIndex",1325,G__RootEventData_rootcint_487_0_8, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPositionX",1261,G__RootEventData_rootcint_487_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPositionY",1262,G__RootEventData_rootcint_487_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPositionZ",1263,G__RootEventData_rootcint_487_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPx",520,G__RootEventData_rootcint_487_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPy",521,G__RootEventData_rootcint_487_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPz",522,G__RootEventData_rootcint_487_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getDepositEnergy",1666,G__RootEventData_rootcint_487_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setHitMap",911,G__RootEventData_rootcint_487_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'map<int,double,less<int>,allocator<pair<const int,double> > >' 'map<Int_t,Double_t>' 0 - hitMap", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setHitEmc",902,G__RootEventData_rootcint_487_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - hitEmc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPDGCode",930,G__RootEventData_rootcint_487_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - PDGCode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPDGCharge",1137,G__RootEventData_rootcint_487_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - PDGCharge", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTime",731,G__RootEventData_rootcint_487_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setId",505,G__RootEventData_rootcint_487_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrackIndex",1337,G__RootEventData_rootcint_487_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - trackIndex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPositionX",1273,G__RootEventData_rootcint_487_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionX", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPositionY",1274,G__RootEventData_rootcint_487_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionY", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPositionZ",1275,G__RootEventData_rootcint_487_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionZ", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPx",532,G__RootEventData_rootcint_487_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - px", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPy",533,G__RootEventData_rootcint_487_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - py", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPz",534,G__RootEventData_rootcint_487_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - pz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDepositEnergy",1678,G__RootEventData_rootcint_487_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - depositEnergy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_487_0_30, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEmcMc::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_487_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEmcMc::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_487_0_32, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEmcMc::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_487_0_33, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEmcMc::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_487_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_487_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEmcMc::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_487_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEmcMc::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_487_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEmcMc::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_487_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEmcMc::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEmcMc", 537, G__RootEventData_rootcint_487_0_42, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc), -1, 0, 1, 1, 1, 0, "u 'TEmcMc' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEmcMc", 663, G__RootEventData_rootcint_487_0_43, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_487_0_44, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc), -1, 1, 1, 1, 1, 0, "u 'TEmcMc' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTofMc(void) {
   /* TTofMc */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc));
   G__memfunc_setup("TTofMc",557,G__RootEventData_rootcint_488_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getId",493,G__RootEventData_rootcint_488_0_2, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTrackIndex",1325,G__RootEventData_rootcint_488_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPositionX",1261,G__RootEventData_rootcint_488_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPositionY",1262,G__RootEventData_rootcint_488_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPositionZ",1263,G__RootEventData_rootcint_488_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPx",520,G__RootEventData_rootcint_488_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPy",521,G__RootEventData_rootcint_488_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPz",522,G__RootEventData_rootcint_488_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTrackLength",1431,G__RootEventData_rootcint_488_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFlightTime",1325,G__RootEventData_rootcint_488_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setId",505,G__RootEventData_rootcint_488_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrackIndex",1337,G__RootEventData_rootcint_488_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - trackIndex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPositionX",1273,G__RootEventData_rootcint_488_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionX", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPositionY",1274,G__RootEventData_rootcint_488_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionY", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPositionZ",1275,G__RootEventData_rootcint_488_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionZ", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPx",532,G__RootEventData_rootcint_488_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - px", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPy",533,G__RootEventData_rootcint_488_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - py", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPz",534,G__RootEventData_rootcint_488_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - pz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrackLength",1443,G__RootEventData_rootcint_488_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - trackLength", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFlightTime",1337,G__RootEventData_rootcint_488_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - flightTime", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_488_0_22, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTofMc::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_488_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTofMc::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_488_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTofMc::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_488_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTofMc::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_488_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_488_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTofMc::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_488_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTofMc::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_488_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTofMc::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_488_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTofMc::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TTofMc", 557, G__RootEventData_rootcint_488_0_34, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc), -1, 0, 1, 1, 1, 0, "u 'TTofMc' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TTofMc", 683, G__RootEventData_rootcint_488_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_488_0_36, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc), -1, 1, 1, 1, 1, 0, "u 'TTofMc' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMucMc(void) {
   /* TMucMc */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc));
   G__memfunc_setup("TMucMc",553,G__RootEventData_rootcint_489_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getId",493,G__RootEventData_rootcint_489_0_2, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTrackIndex",1325,G__RootEventData_rootcint_489_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPositionX",1261,G__RootEventData_rootcint_489_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPositionY",1262,G__RootEventData_rootcint_489_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPositionZ",1263,G__RootEventData_rootcint_489_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPx",520,G__RootEventData_rootcint_489_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPy",521,G__RootEventData_rootcint_489_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPz",522,G__RootEventData_rootcint_489_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setId",505,G__RootEventData_rootcint_489_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrackIndex",1337,G__RootEventData_rootcint_489_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - trackIndex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPositionX",1273,G__RootEventData_rootcint_489_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionX", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPositionY",1274,G__RootEventData_rootcint_489_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionY", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPositionZ",1275,G__RootEventData_rootcint_489_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionZ", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPx",532,G__RootEventData_rootcint_489_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - px", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPy",533,G__RootEventData_rootcint_489_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - py", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPz",534,G__RootEventData_rootcint_489_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - pz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_489_0_18, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMucMc::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_489_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMucMc::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_489_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMucMc::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_489_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMucMc::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_489_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_489_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMucMc::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_489_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMucMc::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_489_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMucMc::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_489_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMucMc::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TMucMc", 553, G__RootEventData_rootcint_489_0_30, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc), -1, 0, 1, 1, 1, 0, "u 'TMucMc' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TMucMc", 679, G__RootEventData_rootcint_489_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_489_0_32, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc), -1, 1, 1, 1, 1, 0, "u 'TMucMc' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMcParticle(void) {
   /* TMcParticle */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle));
   G__memfunc_setup("TMcParticle",1080,G__RootEventData_rootcint_490_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getParticleID",1281,G__RootEventData_rootcint_490_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTrackIndex",1325,G__RootEventData_rootcint_490_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getVertexIndex0",1510,G__RootEventData_rootcint_490_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getVertexIndex1",1511,G__RootEventData_rootcint_490_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getStatusFlags",1457,G__RootEventData_rootcint_490_0_6, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getInitialPositionX",1975,G__RootEventData_rootcint_490_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getInitialPositionY",1976,G__RootEventData_rootcint_490_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getInitialPositionZ",1977,G__RootEventData_rootcint_490_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getInitialPositionT",1971,G__RootEventData_rootcint_490_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFinalPositionX",1751,G__RootEventData_rootcint_490_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFinalPositionY",1752,G__RootEventData_rootcint_490_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFinalPositionZ",1753,G__RootEventData_rootcint_490_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFinalPositionT",1747,G__RootEventData_rootcint_490_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getInitialMomentumX",1972,G__RootEventData_rootcint_490_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getInitialMomentumY",1973,G__RootEventData_rootcint_490_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getInitialMomentumZ",1974,G__RootEventData_rootcint_490_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getInitialMomentumE",1953,G__RootEventData_rootcint_490_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMother",943,G__RootEventData_rootcint_490_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getDaughters",1255,G__RootEventData_rootcint_490_0_20, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("primaryParticle",1592,G__RootEventData_rootcint_490_0_21, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("leafParticle",1228,G__RootEventData_rootcint_490_0_22, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("decayFromGenerator",1857,G__RootEventData_rootcint_490_0_23, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("decayInFlight",1307,G__RootEventData_rootcint_490_0_24, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setParticleID",1293,G__RootEventData_rootcint_490_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - particleID", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrackIndex",1337,G__RootEventData_rootcint_490_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trackIndex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setVertexIndex0",1522,G__RootEventData_rootcint_490_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - vertexIndex0", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setVertexIndex1",1523,G__RootEventData_rootcint_490_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - vertexIndex1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setStatusFlags",1469,G__RootEventData_rootcint_490_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - statusFlags", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setInitialPositionX",1987,G__RootEventData_rootcint_490_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionX", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setInitialPositionY",1988,G__RootEventData_rootcint_490_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionY", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setInitialPositionZ",1989,G__RootEventData_rootcint_490_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionZ", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setInitialPositionT",1983,G__RootEventData_rootcint_490_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionT", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFinalPositionX",1763,G__RootEventData_rootcint_490_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionX", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFinalPositionY",1764,G__RootEventData_rootcint_490_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionY", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFinalPositionZ",1765,G__RootEventData_rootcint_490_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionZ", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFinalPositionT",1759,G__RootEventData_rootcint_490_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - positionT", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setInitialMomentumX",1984,G__RootEventData_rootcint_490_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - momentumX", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setInitialMomentumY",1985,G__RootEventData_rootcint_490_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - momentumY", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setInitialMomentumZ",1986,G__RootEventData_rootcint_490_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - momentumZ", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setInitialMomentumE",1965,G__RootEventData_rootcint_490_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - momentumE", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setMother",955,G__RootEventData_rootcint_490_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mother", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDaughters",1267,G__RootEventData_rootcint_490_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 1 - daughters", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_490_0_44, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMcParticle::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_490_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcParticle::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_490_0_46, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMcParticle::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_490_0_47, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMcParticle::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_490_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_490_0_52, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcParticle::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_490_0_53, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcParticle::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_490_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcParticle::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_490_0_55, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcParticle::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TMcParticle", 1080, G__RootEventData_rootcint_490_0_56, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle), -1, 0, 1, 1, 1, 0, "u 'TMcParticle' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TMcParticle", 1206, G__RootEventData_rootcint_490_0_57, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_490_0_58, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle), -1, 1, 1, 1, 1, 0, "u 'TMcParticle' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMcEvent(void) {
   /* TMcEvent */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent));
   G__memfunc_setup("TMcEvent",774,G__RootEventData_rootcint_492_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_492_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("getMdcMcHitCol",1351,G__RootEventData_rootcint_492_0_5, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addMdcMc",749,G__RootEventData_rootcint_492_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMdcMc' - 0 - mcHit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMdcMc",772,G__RootEventData_rootcint_492_0_7, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMdcMc), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearMdcMcHitCol",1550,G__RootEventData_rootcint_492_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEmcMcHitCol",1352,G__RootEventData_rootcint_492_0_9, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addEmcMc",750,G__RootEventData_rootcint_492_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEmcMc' - 0 - mcHit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEmcMc",773,G__RootEventData_rootcint_492_0_11, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEmcMc), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearEmcMcHitCol",1551,G__RootEventData_rootcint_492_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTofMcHitCol",1372,G__RootEventData_rootcint_492_0_13, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addTofMc",770,G__RootEventData_rootcint_492_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTofMc' - 0 - mcHit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTofMc",793,G__RootEventData_rootcint_492_0_15, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTofMc), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearTofMcHitCol",1571,G__RootEventData_rootcint_492_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMucMcHitCol",1368,G__RootEventData_rootcint_492_0_17, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addMucMc",766,G__RootEventData_rootcint_492_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMucMc' - 0 - mcHit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMucMc",789,G__RootEventData_rootcint_492_0_19, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMucMc), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearMucMcHitCol",1567,G__RootEventData_rootcint_492_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMcParticleCol",1602,G__RootEventData_rootcint_492_0_21, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addMcParticle",1293,G__RootEventData_rootcint_492_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMcParticle' - 0 - mcHit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMcParticle",1316,G__RootEventData_rootcint_492_0_23, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcParticle), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearMcParticleCol",1801,G__RootEventData_rootcint_492_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_492_0_25, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMcEvent::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_492_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcEvent::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_492_0_27, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMcEvent::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_492_0_28, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMcEvent::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_492_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_492_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcEvent::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_492_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcEvent::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_492_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcEvent::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_492_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcEvent::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TMcEvent", 774, G__RootEventData_rootcint_492_0_37, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent), -1, 0, 1, 1, 1, 0, "u 'TMcEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TMcEvent", 900, G__RootEventData_rootcint_492_0_38, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_492_0_39, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent), -1, 1, 1, 1, 1, 0, "u 'TMcEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvtHeader(void) {
   /* TEvtHeader */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader));
   G__memfunc_setup("TEvtHeader",972,G__RootEventData_rootcint_493_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_493_0_2, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - Id i - 'Int_t' 0 - runId "
"h - 'UInt_t' 0 - evenTag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("getEventId",1007,G__RootEventData_rootcint_493_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getRunId",802,G__RootEventData_rootcint_493_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("time",431,G__RootEventData_rootcint_493_0_7, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTime",731,G__RootEventData_rootcint_493_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEventTag",1118,G__RootEventData_rootcint_493_0_9, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFlag1",759,G__RootEventData_rootcint_493_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFlag2",760,G__RootEventData_rootcint_493_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFlag1",747,G__RootEventData_rootcint_493_0_12, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getFlag2",748,G__RootEventData_rootcint_493_0_13, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_493_0_14, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvtHeader::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_493_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtHeader::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_493_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvtHeader::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_493_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvtHeader::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_493_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_493_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtHeader::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_493_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtHeader::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_493_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtHeader::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_493_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtHeader::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEvtHeader", 972, G__RootEventData_rootcint_493_0_26, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader), -1, 0, 1, 1, 1, 0, "u 'TEvtHeader' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEvtHeader", 1098, G__RootEventData_rootcint_493_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_493_0_28, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader), -1, 1, 1, 1, 1, 0, "u 'TEvtHeader' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvtNavigator(void) {
   /* TEvtNavigator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtNavigator));
   G__memfunc_setup("TEvtNavigator",1326,G__RootEventData_rootcint_503_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtNavigator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LoadMcMdcMcHits",1420,G__RootEventData_rootcint_503_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'multimap<int,int,less<int>,allocator<pair<const int,int> > >' 'multimap<int,int>' 1 - map", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadMcMdcTracks",1452,G__RootEventData_rootcint_503_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'multimap<int,int,less<int>,allocator<pair<const int,int> > >' 'multimap<int,int>' 1 - map", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadMcEmcMcHits",1421,G__RootEventData_rootcint_503_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'multimap<int,int,less<int>,allocator<pair<const int,int> > >' 'multimap<int,int>' 1 - map", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadMcEmcRecShowers",1866,G__RootEventData_rootcint_503_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'multimap<int,int,less<int>,allocator<pair<const int,int> > >' 'multimap<int,int>' 1 - map", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_503_0_8, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvtNavigator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_503_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtNavigator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_503_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvtNavigator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_503_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvtNavigator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_503_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_503_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtNavigator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_503_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtNavigator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_503_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtNavigator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_503_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtNavigator::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEvtNavigator", 1326, G__RootEventData_rootcint_503_0_20, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtNavigator), -1, 0, 1, 1, 1, 0, "u 'TEvtNavigator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEvtNavigator", 1452, G__RootEventData_rootcint_503_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_503_0_22, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtNavigator), -1, 1, 1, 1, 1, 0, "u 'TEvtNavigator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTrigData(void) {
   /* TTrigData */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData));
   G__memfunc_setup("TTrigData",868,G__RootEventData_rootcint_507_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("setTrigCondition",1673,G__RootEventData_rootcint_507_0_4, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - - 0 - i i - - 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrigCondition",1673,G__RootEventData_rootcint_507_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "I - - 10 - cond", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrigChannel",1435,G__RootEventData_rootcint_507_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - - 0 - i i - - 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrigChannel",1435,G__RootEventData_rootcint_507_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "I - - 10 - chan", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTimeWindow",1363,G__RootEventData_rootcint_507_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTimingType",1366,G__RootEventData_rootcint_507_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPreScale",1115,G__RootEventData_rootcint_507_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTrigCondition",1661,G__RootEventData_rootcint_507_0_11, 105, -1, -1, 0, 1, 1, 1, 9, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTrigCondition",1661,G__RootEventData_rootcint_507_0_12, 73, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTrigChannel",1423,G__RootEventData_rootcint_507_0_13, 105, -1, -1, 0, 1, 1, 1, 9, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTrigChannel",1423,G__RootEventData_rootcint_507_0_14, 73, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTimeWindow",1351,G__RootEventData_rootcint_507_0_15, 105, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTimingType",1354,G__RootEventData_rootcint_507_0_16, 105, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getPreScale",1103,G__RootEventData_rootcint_507_0_17, 103, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_507_0_18, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTrigData::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_507_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTrigData::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_507_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTrigData::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_507_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTrigData::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_507_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_507_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTrigData::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_507_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTrigData::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_507_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTrigData::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_507_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTrigData::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TTrigData", 868, G__RootEventData_rootcint_507_0_30, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData), -1, 0, 1, 1, 1, 0, "u 'TTrigData' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TTrigData", 994, G__RootEventData_rootcint_507_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_507_0_32, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData), -1, 1, 1, 1, 1, 0, "u 'TTrigData' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTrigEvent(void) {
   /* TTrigEvent */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent));
   G__memfunc_setup("TTrigEvent",1004,G__RootEventData_rootcint_508_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_508_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("addTrigData",1081,G__RootEventData_rootcint_508_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTrigData' - 0 - trigData", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTrigData",1104,G__RootEventData_rootcint_508_0_6, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigData), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearTrigData",1303,G__RootEventData_rootcint_508_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_508_0_8, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTrigEvent::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_508_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTrigEvent::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_508_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTrigEvent::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_508_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTrigEvent::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_508_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_508_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTrigEvent::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_508_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTrigEvent::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_508_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTrigEvent::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_508_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTrigEvent::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TTrigEvent", 1004, G__RootEventData_rootcint_508_0_20, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent), -1, 0, 1, 1, 1, 0, "u 'TTrigEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TTrigEvent", 1130, G__RootEventData_rootcint_508_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_508_0_22, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent), -1, 1, 1, 1, 1, 0, "u 'TTrigEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHltRaw(void) {
   /* THltRaw */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw));
   G__memfunc_setup("THltRaw",678,G__RootEventData_rootcint_509_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_509_0_2, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THltRaw::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_509_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THltRaw::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_509_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THltRaw::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_509_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THltRaw::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_509_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_509_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THltRaw::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_509_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THltRaw::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_509_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THltRaw::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_509_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THltRaw::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("THltRaw", 678, G__RootEventData_rootcint_509_0_14, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw), -1, 0, 1, 1, 1, 0, "u 'THltRaw' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~THltRaw", 804, G__RootEventData_rootcint_509_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_509_0_16, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw), -1, 1, 1, 1, 1, 0, "u 'THltRaw' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHltInf(void) {
   /* THltInf */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf));
   G__memfunc_setup("THltInf",665,G__RootEventData_rootcint_510_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setEventType",1264,G__RootEventData_rootcint_510_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setAlgProcess",1343,G__RootEventData_rootcint_510_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setCriteriaTable",1639,G__RootEventData_rootcint_510_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setVersion",1074,G__RootEventData_rootcint_510_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTotalEnergy",1466,G__RootEventData_rootcint_510_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - etot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNumber",949,G__RootEventData_rootcint_510_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNCON",634,G__RootEventData_rootcint_510_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setMdcData",986,G__RootEventData_rootcint_510_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - vec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTofData",1007,G__RootEventData_rootcint_510_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - vec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setEmcData",987,G__RootEventData_rootcint_510_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - vec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setMucData",1003,G__RootEventData_rootcint_510_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - vec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setConData",998,G__RootEventData_rootcint_510_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - vec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEventType",1252,G__RootEventData_rootcint_510_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getAlgProcess",1331,G__RootEventData_rootcint_510_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getCriteriaTable",1627,G__RootEventData_rootcint_510_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getVersion",1062,G__RootEventData_rootcint_510_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTotalEnergy",1454,G__RootEventData_rootcint_510_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getNumber",937,G__RootEventData_rootcint_510_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getNCON",622,G__RootEventData_rootcint_510_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMdcData",974,G__RootEventData_rootcint_510_0_21, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTofData",995,G__RootEventData_rootcint_510_0_22, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEmcData",975,G__RootEventData_rootcint_510_0_23, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMucData",991,G__RootEventData_rootcint_510_0_24, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getConData",986,G__RootEventData_rootcint_510_0_25, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_510_0_26, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THltInf::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_510_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THltInf::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_510_0_28, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THltInf::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_510_0_29, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THltInf::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_510_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_510_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THltInf::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_510_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THltInf::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_510_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THltInf::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_510_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THltInf::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("THltInf", 665, G__RootEventData_rootcint_510_0_38, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf), -1, 0, 1, 1, 1, 0, "u 'THltInf' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~THltInf", 791, G__RootEventData_rootcint_510_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_510_0_40, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf), -1, 1, 1, 1, 1, 0, "u 'THltInf' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTDstHltInf(void) {
   /* TDstHltInf */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf));
   G__memfunc_setup("TDstHltInf",964,G__RootEventData_rootcint_511_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setEventType",1264,G__RootEventData_rootcint_511_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setAlgProcess",1343,G__RootEventData_rootcint_511_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setCriteriaTable",1639,G__RootEventData_rootcint_511_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setVersion",1074,G__RootEventData_rootcint_511_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTotalEnergy",1466,G__RootEventData_rootcint_511_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - etot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNumber",949,G__RootEventData_rootcint_511_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNCON",634,G__RootEventData_rootcint_511_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEventType",1252,G__RootEventData_rootcint_511_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getAlgProcess",1331,G__RootEventData_rootcint_511_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getCriteriaTable",1627,G__RootEventData_rootcint_511_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getVersion",1062,G__RootEventData_rootcint_511_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTotalEnergy",1454,G__RootEventData_rootcint_511_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getNumber",937,G__RootEventData_rootcint_511_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getNCON",622,G__RootEventData_rootcint_511_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_511_0_16, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDstHltInf::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_511_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDstHltInf::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_511_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDstHltInf::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_511_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDstHltInf::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_511_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_511_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDstHltInf::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_511_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDstHltInf::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_511_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDstHltInf::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_511_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDstHltInf::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TDstHltInf", 964, G__RootEventData_rootcint_511_0_28, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf), -1, 0, 1, 1, 1, 0, "u 'TDstHltInf' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TDstHltInf", 1090, G__RootEventData_rootcint_511_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_511_0_30, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf), -1, 1, 1, 1, 1, 0, "u 'TDstHltInf' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHltEvent(void) {
   /* THltEvent */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent));
   G__memfunc_setup("THltEvent",894,G__RootEventData_rootcint_512_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_512_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("addHltRaw",891,G__RootEventData_rootcint_512_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'THltRaw' - 0 - hltRaw", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getHltRaw",914,G__RootEventData_rootcint_512_0_6, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltRaw), -1, 0, 1, 1, 1, 9, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getHltRawCol",1200,G__RootEventData_rootcint_512_0_7, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearHltRawCol",1399,G__RootEventData_rootcint_512_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addHltInf",878,G__RootEventData_rootcint_512_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'THltInf' - 0 - hltInf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getHltInf",901,G__RootEventData_rootcint_512_0_10, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltInf), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearHltInf",1100,G__RootEventData_rootcint_512_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addDstHltInf",1177,G__RootEventData_rootcint_512_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDstHltInf' - 0 - dstHltInf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getDstHltInf",1200,G__RootEventData_rootcint_512_0_13, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstHltInf), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearDstHltInf",1399,G__RootEventData_rootcint_512_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_512_0_15, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THltEvent::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_512_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THltEvent::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_512_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THltEvent::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_512_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THltEvent::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_512_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_512_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THltEvent::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_512_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THltEvent::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_512_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THltEvent::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_512_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THltEvent::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("THltEvent", 894, G__RootEventData_rootcint_512_0_27, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent), -1, 0, 1, 1, 1, 0, "u 'THltEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~THltEvent", 1020, G__RootEventData_rootcint_512_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_512_0_29, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent), -1, 1, 1, 1, 1, 0, "u 'THltEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTDisTrack(void) {
   /* TDisTrack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDisTrack));
   G__memfunc_setup("TDisTrack",873,G__RootEventData_rootcint_513_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDisTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_513_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("getRecMdcTrackCol",1665,G__RootEventData_rootcint_513_0_5, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addRecMdcTrack",1356,G__RootEventData_rootcint_513_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMdcTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getRecMdcTrack",1379,G__RootEventData_rootcint_513_0_7, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearRecMdcTrackCol",1864,G__RootEventData_rootcint_513_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getRecMdcHitCol",1457,G__RootEventData_rootcint_513_0_9, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addRecMdcHit",1148,G__RootEventData_rootcint_513_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMdcHit' - 0 - Hit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getRecMdcHit",1171,G__RootEventData_rootcint_513_0_11, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMdcHit), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearRecMdcHitCol",1656,G__RootEventData_rootcint_513_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTofTrackCol",1404,G__RootEventData_rootcint_513_0_13, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addTofTrack",1095,G__RootEventData_rootcint_513_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecTofTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTofTrack",1118,G__RootEventData_rootcint_513_0_15, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTofTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearTofTrackCol",1603,G__RootEventData_rootcint_513_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMucTrackCol",1400,G__RootEventData_rootcint_513_0_17, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addMucTrack",1091,G__RootEventData_rootcint_513_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecMucTrack' - 0 - Track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMucTrack",1114,G__RootEventData_rootcint_513_0_19, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecMucTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearMucTrackCol",1599,G__RootEventData_rootcint_513_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMdcTrackNum",1401,G__RootEventData_rootcint_513_0_21, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTofTrackNum",1422,G__RootEventData_rootcint_513_0_22, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEmcShowerNum",1533,G__RootEventData_rootcint_513_0_23, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMucTrackNum",1418,G__RootEventData_rootcint_513_0_24, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMdcHitNum",1193,G__RootEventData_rootcint_513_0_25, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEmcShowerCol",1515,G__RootEventData_rootcint_513_0_26, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addEmcShower",1206,G__RootEventData_rootcint_513_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecEmcShower' - 0 - Track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEmcShower",1229,G__RootEventData_rootcint_513_0_28, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecEmcShower), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearEmcShowerCol",1714,G__RootEventData_rootcint_513_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_513_0_30, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDisTrack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_513_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDisTrack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_513_0_32, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDisTrack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_513_0_33, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDisTrack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_513_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_513_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDisTrack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_513_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDisTrack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_513_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDisTrack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_513_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDisTrack::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TDisTrack", 873, G__RootEventData_rootcint_513_0_42, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDisTrack), -1, 0, 1, 1, 1, 0, "u 'TDisTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TDisTrack", 999, G__RootEventData_rootcint_513_0_43, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_513_0_44, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDisTrack), -1, 1, 1, 1, 1, 0, "u 'TDisTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvtRecEvent(void) {
   /* TEvtRecEvent */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent));
   G__memfunc_setup("TEvtRecEvent",1183,G__RootEventData_rootcint_514_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_514_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("totalTracks",1164,G__RootEventData_rootcint_514_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("totalCharged",1234,G__RootEventData_rootcint_514_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("totalNeutral",1279,G__RootEventData_rootcint_514_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("numberOfVee",1118,G__RootEventData_rootcint_514_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("numberOfPi0",1063,G__RootEventData_rootcint_514_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("numberOfEtaToGG",1449,G__RootEventData_rootcint_514_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("numberOfDTag",1182,G__RootEventData_rootcint_514_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTotalTracks",1464,G__RootEventData_rootcint_514_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - tottks", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTotalCharged",1534,G__RootEventData_rootcint_514_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - nchrg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTotalNeutral",1579,G__RootEventData_rootcint_514_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - nneu", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNumberOfVee",1418,G__RootEventData_rootcint_514_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - nvee", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNumberOfPi0",1363,G__RootEventData_rootcint_514_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - npi0", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNumberOfEtaToGG",1749,G__RootEventData_rootcint_514_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - neta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNumberOfDTag",1482,G__RootEventData_rootcint_514_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - ndtag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_514_0_19, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvtRecEvent::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_514_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecEvent::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_514_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvtRecEvent::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_514_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvtRecEvent::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_514_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_514_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecEvent::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_514_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecEvent::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_514_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecEvent::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_514_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecEvent::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEvtRecEvent", 1183, G__RootEventData_rootcint_514_0_31, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent), -1, 0, 1, 1, 1, 0, "u 'TEvtRecEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEvtRecEvent", 1309, G__RootEventData_rootcint_514_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_514_0_33, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent), -1, 1, 1, 1, 1, 0, "u 'TEvtRecEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvtRecTrack(void) {
   /* TEvtRecTrack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack));
   G__memfunc_setup("TEvtRecTrack",1170,G__RootEventData_rootcint_515_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("trackId",706,G__RootEventData_rootcint_515_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("partId",612,G__RootEventData_rootcint_515_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("quality",777,G__RootEventData_rootcint_515_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("mdcTrackId",982,G__RootEventData_rootcint_515_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("mdcKalTrackId",1262,G__RootEventData_rootcint_515_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("mdcDedxId",870,G__RootEventData_rootcint_515_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("extTrackId",1011,G__RootEventData_rootcint_515_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("emcShowerId",1114,G__RootEventData_rootcint_515_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("mucTrackId",999,G__RootEventData_rootcint_515_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("tofTrackIds",1118,G__RootEventData_rootcint_515_0_11, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrackId",1006,G__RootEventData_rootcint_515_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - trackId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPartId",912,G__RootEventData_rootcint_515_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - partId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setQuality",1077,G__RootEventData_rootcint_515_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - quality", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setMdcTrackId",1282,G__RootEventData_rootcint_515_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - mdcTrackId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setMdcKalTrackId",1562,G__RootEventData_rootcint_515_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - mdcKalTrackId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setMdcDedxId",1170,G__RootEventData_rootcint_515_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - mdcDedxId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setExtTrackId",1311,G__RootEventData_rootcint_515_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - extTrackId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setEmcShowerId",1414,G__RootEventData_rootcint_515_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - emcShowerId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setMucTrackId",1299,G__RootEventData_rootcint_515_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - mucTrackId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTofTrackIds",1418,G__RootEventData_rootcint_515_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - tofTrackIds", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addTofTrackId",1268,G__RootEventData_rootcint_515_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - tofTrackId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_515_0_23, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvtRecTrack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_515_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecTrack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_515_0_25, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvtRecTrack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_515_0_26, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvtRecTrack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_515_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_515_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecTrack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_515_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecTrack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_515_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecTrack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_515_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecTrack::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEvtRecTrack", 1170, G__RootEventData_rootcint_515_0_35, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack), -1, 0, 1, 1, 1, 0, "u 'TEvtRecTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEvtRecTrack", 1296, G__RootEventData_rootcint_515_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_515_0_37, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack), -1, 1, 1, 1, 1, 0, "u 'TEvtRecTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvtRecPrimaryVertex(void) {
   /* TEvtRecPrimaryVertex */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex));
   G__memfunc_setup("TEvtRecPrimaryVertex",2047,G__RootEventData_rootcint_516_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("isValid",716,G__RootEventData_rootcint_516_0_2, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("nTracks",726,G__RootEventData_rootcint_516_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("trackIdList",1118,G__RootEventData_rootcint_516_0_4, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("chi2",358,G__RootEventData_rootcint_516_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ndof",423,G__RootEventData_rootcint_516_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("fitMethod",932,G__RootEventData_rootcint_516_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vertex",670,G__RootEventData_rootcint_516_0_8, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("errorVertex",1192,G__RootEventData_rootcint_516_0_9, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setIsValid",1016,G__RootEventData_rootcint_516_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - isValid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNTracks",1026,G__RootEventData_rootcint_516_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nTracks", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrackIdList",1418,G__RootEventData_rootcint_516_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - trackIdList", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setChi2",658,G__RootEventData_rootcint_516_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - chi2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNdof",723,G__RootEventData_rootcint_516_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ndof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setFitMethod",1232,G__RootEventData_rootcint_516_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - fitMethod", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setVertex",970,G__RootEventData_rootcint_516_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - vtx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setErrorVertex",1492,G__RootEventData_rootcint_516_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - Evtx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_516_0_18, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvtRecPrimaryVertex::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_516_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecPrimaryVertex::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_516_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvtRecPrimaryVertex::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_516_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvtRecPrimaryVertex::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_516_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_516_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecPrimaryVertex::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_516_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecPrimaryVertex::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_516_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecPrimaryVertex::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_516_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecPrimaryVertex::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEvtRecPrimaryVertex", 2047, G__RootEventData_rootcint_516_0_30, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex), -1, 0, 1, 1, 1, 0, "u 'TEvtRecPrimaryVertex' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEvtRecPrimaryVertex", 2173, G__RootEventData_rootcint_516_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_516_0_32, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex), -1, 1, 1, 1, 1, 0, "u 'TEvtRecPrimaryVertex' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvtRecVeeVertex(void) {
   /* TEvtRecVeeVertex */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex));
   G__memfunc_setup("TEvtRecVeeVertex",1595,G__RootEventData_rootcint_517_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vertexId",843,G__RootEventData_rootcint_517_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vertexType",1088,G__RootEventData_rootcint_517_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("chi2",358,G__RootEventData_rootcint_517_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ndof",423,G__RootEventData_rootcint_517_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("mass",436,G__RootEventData_rootcint_517_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("w",119,G__RootEventData_rootcint_517_0_7, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Ew",188,G__RootEventData_rootcint_517_0_8, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pair",428,G__RootEventData_rootcint_517_0_9, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("nCharge",696,G__RootEventData_rootcint_517_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("nTracks",726,G__RootEventData_rootcint_517_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("daughter",852,G__RootEventData_rootcint_517_0_12, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setVertexId",1143,G__RootEventData_rootcint_517_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - vtxId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setVertexType",1388,G__RootEventData_rootcint_517_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - vtxType", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setChi2",658,G__RootEventData_rootcint_517_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - chi2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNdof",723,G__RootEventData_rootcint_517_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ndof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setMass",736,G__RootEventData_rootcint_517_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - mass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setW",419,G__RootEventData_rootcint_517_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setEw",520,G__RootEventData_rootcint_517_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - Ew", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPair",728,G__RootEventData_rootcint_517_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "I - 'Int_t' 0 - pair", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNCharge",996,G__RootEventData_rootcint_517_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nCharge", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setNTracks",1026,G__RootEventData_rootcint_517_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nTracks", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDaughter",1152,G__RootEventData_rootcint_517_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "I - 'Int_t' 0 - daughter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_517_0_24, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvtRecVeeVertex::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_517_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecVeeVertex::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_517_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvtRecVeeVertex::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_517_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvtRecVeeVertex::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_517_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_517_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecVeeVertex::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_517_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecVeeVertex::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_517_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecVeeVertex::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_517_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecVeeVertex::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEvtRecVeeVertex", 1595, G__RootEventData_rootcint_517_0_36, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex), -1, 0, 1, 1, 1, 0, "u 'TEvtRecVeeVertex' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEvtRecVeeVertex", 1721, G__RootEventData_rootcint_517_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_517_0_38, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex), -1, 1, 1, 1, 1, 0, "u 'TEvtRecVeeVertex' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvtRecPi0(void) {
   /* TEvtRecPi0 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0));
   G__memfunc_setup("TEvtRecPi0",902,G__RootEventData_rootcint_518_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("unconMass",951,G__RootEventData_rootcint_518_0_2, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("chisq",536,G__RootEventData_rootcint_518_0_3, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("hiPxfit",732,G__RootEventData_rootcint_518_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("hiPyfit",733,G__RootEventData_rootcint_518_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("hiPzfit",734,G__RootEventData_rootcint_518_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("hiPefit",713,G__RootEventData_rootcint_518_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("loPxfit",742,G__RootEventData_rootcint_518_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("loPyfit",743,G__RootEventData_rootcint_518_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("loPzfit",744,G__RootEventData_rootcint_518_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("loPefit",723,G__RootEventData_rootcint_518_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("hiEnGamma",871,G__RootEventData_rootcint_518_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("loEnGamma",881,G__RootEventData_rootcint_518_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setUnconMass",1251,G__RootEventData_rootcint_518_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - unconMass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setChisq",836,G__RootEventData_rootcint_518_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - chisq", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setHiPxfit",1032,G__RootEventData_rootcint_518_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - hiPx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setHiPyfit",1033,G__RootEventData_rootcint_518_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - hiPy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setHiPzfit",1034,G__RootEventData_rootcint_518_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - hiPz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setHiPefit",1013,G__RootEventData_rootcint_518_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - hiPe", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLoPxfit",1042,G__RootEventData_rootcint_518_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - loPx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLoPyfit",1043,G__RootEventData_rootcint_518_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - loPy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLoPzfit",1044,G__RootEventData_rootcint_518_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - loPz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLoPefit",1023,G__RootEventData_rootcint_518_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - loPe", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setHiEnGamma",1171,G__RootEventData_rootcint_518_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - hiEnGamma", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLoEnGamma",1181,G__RootEventData_rootcint_518_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - loEnGamma", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_518_0_26, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvtRecPi0::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_518_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecPi0::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_518_0_28, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvtRecPi0::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_518_0_29, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvtRecPi0::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_518_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_518_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecPi0::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_518_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecPi0::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_518_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecPi0::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_518_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecPi0::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEvtRecPi0", 902, G__RootEventData_rootcint_518_0_38, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0), -1, 0, 1, 1, 1, 0, "u 'TEvtRecPi0' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEvtRecPi0", 1028, G__RootEventData_rootcint_518_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_518_0_40, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0), -1, 1, 1, 1, 1, 0, "u 'TEvtRecPi0' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvtRecEtaToGG(void) {
   /* TEvtRecEtaToGG */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG));
   G__memfunc_setup("TEvtRecEtaToGG",1288,G__RootEventData_rootcint_519_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("unconMass",951,G__RootEventData_rootcint_519_0_2, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("chisq",536,G__RootEventData_rootcint_519_0_3, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("hiPxfit",732,G__RootEventData_rootcint_519_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("hiPyfit",733,G__RootEventData_rootcint_519_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("hiPzfit",734,G__RootEventData_rootcint_519_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("hiPefit",713,G__RootEventData_rootcint_519_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("loPxfit",742,G__RootEventData_rootcint_519_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("loPyfit",743,G__RootEventData_rootcint_519_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("loPzfit",744,G__RootEventData_rootcint_519_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("loPefit",723,G__RootEventData_rootcint_519_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("hiEnGamma",871,G__RootEventData_rootcint_519_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("loEnGamma",881,G__RootEventData_rootcint_519_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setUnconMass",1251,G__RootEventData_rootcint_519_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - unconMass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setChisq",836,G__RootEventData_rootcint_519_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - chisq", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setHiPxfit",1032,G__RootEventData_rootcint_519_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - hiPx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setHiPyfit",1033,G__RootEventData_rootcint_519_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - hiPy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setHiPzfit",1034,G__RootEventData_rootcint_519_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - hiPz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setHiPefit",1013,G__RootEventData_rootcint_519_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - hiPe", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLoPxfit",1042,G__RootEventData_rootcint_519_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - loPx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLoPyfit",1043,G__RootEventData_rootcint_519_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - loPy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLoPzfit",1044,G__RootEventData_rootcint_519_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - loPz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLoPefit",1023,G__RootEventData_rootcint_519_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - loPe", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setHiEnGamma",1171,G__RootEventData_rootcint_519_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - hiEnGamma", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setLoEnGamma",1181,G__RootEventData_rootcint_519_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - loEnGamma", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_519_0_26, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvtRecEtaToGG::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_519_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecEtaToGG::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_519_0_28, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvtRecEtaToGG::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_519_0_29, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvtRecEtaToGG::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_519_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_519_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecEtaToGG::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_519_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecEtaToGG::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_519_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecEtaToGG::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_519_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecEtaToGG::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEvtRecEtaToGG", 1288, G__RootEventData_rootcint_519_0_38, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG), -1, 0, 1, 1, 1, 0, "u 'TEvtRecEtaToGG' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEvtRecEtaToGG", 1414, G__RootEventData_rootcint_519_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_519_0_40, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG), -1, 1, 1, 1, 1, 0, "u 'TEvtRecEtaToGG' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvtRecDTag(void) {
   /* TEvtRecDTag */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag));
   G__memfunc_setup("TEvtRecDTag",1021,G__RootEventData_rootcint_520_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("decayMode",907,G__RootEventData_rootcint_520_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("type",450,G__RootEventData_rootcint_520_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("beamE",474,G__RootEventData_rootcint_520_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("mass",436,G__RootEventData_rootcint_520_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("mBC",242,G__RootEventData_rootcint_520_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("deltaE",591,G__RootEventData_rootcint_520_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("charge",618,G__RootEventData_rootcint_520_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("charm",523,G__RootEventData_rootcint_520_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("numOfChildren",1326,G__RootEventData_rootcint_520_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("px",232,G__RootEventData_rootcint_520_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("py",233,G__RootEventData_rootcint_520_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pz",234,G__RootEventData_rootcint_520_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pe",213,G__RootEventData_rootcint_520_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("tracks",648,G__RootEventData_rootcint_520_0_15, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("showers",779,G__RootEventData_rootcint_520_0_16, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("otherTracks",1162,G__RootEventData_rootcint_520_0_17, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("otherShowers",1293,G__RootEventData_rootcint_520_0_18, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pionId",611,G__RootEventData_rootcint_520_0_19, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("kaonId",598,G__RootEventData_rootcint_520_0_20, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setdecayMode",1239,G__RootEventData_rootcint_520_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - decayMode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("settype",782,G__RootEventData_rootcint_520_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setbeamE",806,G__RootEventData_rootcint_520_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - beamE", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setmass",768,G__RootEventData_rootcint_520_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - mass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setmBC",574,G__RootEventData_rootcint_520_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - mBC", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setdeltaE",923,G__RootEventData_rootcint_520_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - deltaE", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setcharge",950,G__RootEventData_rootcint_520_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - charge", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setcharm",855,G__RootEventData_rootcint_520_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - charm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setnumOfChildren",1658,G__RootEventData_rootcint_520_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - numOfChildren", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setpx",564,G__RootEventData_rootcint_520_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - px", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setpy",565,G__RootEventData_rootcint_520_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - py", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setpz",566,G__RootEventData_rootcint_520_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - pz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setpe",545,G__RootEventData_rootcint_520_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - pe", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTracks",948,G__RootEventData_rootcint_520_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - tracks", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setShowers",1079,G__RootEventData_rootcint_520_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - showers", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setOtherTracks",1462,G__RootEventData_rootcint_520_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - tracks", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setOtherShowers",1593,G__RootEventData_rootcint_520_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - showers", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setPionId",911,G__RootEventData_rootcint_520_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - pionId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setKaonId",898,G__RootEventData_rootcint_520_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - kaonId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addTrack",798,G__RootEventData_rootcint_520_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addShower",929,G__RootEventData_rootcint_520_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - shower", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addOtherTrack",1312,G__RootEventData_rootcint_520_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addOtherShower",1443,G__RootEventData_rootcint_520_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - shower", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addPionId",876,G__RootEventData_rootcint_520_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - pionId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addKaonId",863,G__RootEventData_rootcint_520_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - kaonId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_520_0_46, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvtRecDTag::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_520_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecDTag::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_520_0_48, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvtRecDTag::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_520_0_49, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvtRecDTag::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_520_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_520_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecDTag::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_520_0_55, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecDTag::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_520_0_56, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecDTag::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_520_0_57, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecDTag::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEvtRecDTag", 1021, G__RootEventData_rootcint_520_0_58, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag), -1, 0, 1, 1, 1, 0, "u 'TEvtRecDTag' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEvtRecDTag", 1147, G__RootEventData_rootcint_520_0_59, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_520_0_60, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag), -1, 1, 1, 1, 1, 0, "u 'TEvtRecDTag' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvtRecObject(void) {
   /* TEvtRecObject */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject));
   G__memfunc_setup("TEvtRecObject",1268,G__RootEventData_rootcint_521_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("initialize",1074,G__RootEventData_rootcint_521_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("getEvtRecEvent",1419,G__RootEventData_rootcint_521_0_5, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEvent), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setEvtRecEvent",1431,G__RootEventData_rootcint_521_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEvtRecEvent' - 0 - evtRecEvent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEvtRecTrackCol",1692,G__RootEventData_rootcint_521_0_7, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addEvtRecTrack",1383,G__RootEventData_rootcint_521_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEvtRecTrack' - 0 - track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEvtRecTrack",1406,G__RootEventData_rootcint_521_0_9, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecTrack), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearEvtRecTrackCol",1891,G__RootEventData_rootcint_521_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEvtRecPrimaryVertex",2283,G__RootEventData_rootcint_521_0_11, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setEvtRecPrimaryVertex",2295,G__RootEventData_rootcint_521_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEvtRecPrimaryVertex' - 0 - evtRecPrimaryVertex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEvtRecVeeVertexCol",2117,G__RootEventData_rootcint_521_0_13, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addEvtRecVeeVertex",1808,G__RootEventData_rootcint_521_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEvtRecVeeVertex' - 0 - veeVertex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEvtRecVeeVertex",1831,G__RootEventData_rootcint_521_0_15, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecVeeVertex), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearEvtRecVeeVertexCol",2316,G__RootEventData_rootcint_521_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEvtRecPi0Col",1424,G__RootEventData_rootcint_521_0_17, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addEvtRecPi0",1115,G__RootEventData_rootcint_521_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEvtRecPi0' - 0 - pi0", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEvtRecPi0",1138,G__RootEventData_rootcint_521_0_19, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecPi0), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearEvtRecPi0Col",1623,G__RootEventData_rootcint_521_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEvtRecEtaToGGCol",1810,G__RootEventData_rootcint_521_0_21, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addEvtRecEtaToGG",1501,G__RootEventData_rootcint_521_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEvtRecEtaToGG' - 0 - eta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEvtRecEtaToGG",1524,G__RootEventData_rootcint_521_0_23, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecEtaToGG), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearEvtRecEtaToGGCol",2009,G__RootEventData_rootcint_521_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEvtRecDTagCol",1543,G__RootEventData_rootcint_521_0_25, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addEvtRecDTag",1234,G__RootEventData_rootcint_521_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEvtRecDTag' - 0 - dtag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEvtRecDTag",1257,G__RootEventData_rootcint_521_0_27, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecDTag), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clearEvtRecDTagCol",1742,G__RootEventData_rootcint_521_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_521_0_29, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvtRecObject::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_521_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecObject::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_521_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvtRecObject::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_521_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvtRecObject::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_521_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_521_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecObject::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_521_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecObject::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_521_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvtRecObject::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_521_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvtRecObject::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEvtRecObject", 1268, G__RootEventData_rootcint_521_0_41, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject), -1, 0, 1, 1, 1, 0, "u 'TEvtRecObject' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEvtRecObject", 1394, G__RootEventData_rootcint_521_0_42, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_521_0_43, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject), -1, 1, 1, 1, 1, 0, "u 'TEvtRecObject' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMcHitTof(void) {
   /* TMcHitTof */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof));
   G__memfunc_setup("TMcHitTof",850,G__RootEventData_rootcint_559_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTrackIndex",1305,G__RootEventData_rootcint_559_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trackIndex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetG4Index",927,G__RootEventData_rootcint_559_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPartId",880,G__RootEventData_rootcint_559_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - partId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetScinNb",873,G__RootEventData_rootcint_559_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - scinNb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEdep",682,G__RootEventData_rootcint_559_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - edep", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStepL",788,G__RootEventData_rootcint_559_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - stepL", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTrackL",877,G__RootEventData_rootcint_559_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPos",606,G__RootEventData_rootcint_559_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTime",699,G__RootEventData_rootcint_559_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDeltaT",874,G__RootEventData_rootcint_559_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - deltaT", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPDirection",1309,G__RootEventData_rootcint_559_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 0 - pDirection", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMomentum",1150,G__RootEventData_rootcint_559_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 0 - momentum", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCharge",886,G__RootEventData_rootcint_559_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - charge", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrackIndex",1293,G__RootEventData_rootcint_559_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetG4Index",915,G__RootEventData_rootcint_559_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPartId",868,G__RootEventData_rootcint_559_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScinNb",861,G__RootEventData_rootcint_559_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEdep",670,G__RootEventData_rootcint_559_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStepL",776,G__RootEventData_rootcint_559_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrackL",865,G__RootEventData_rootcint_559_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPos",594,G__RootEventData_rootcint_559_0_22, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTime",687,G__RootEventData_rootcint_559_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDeltaT",862,G__RootEventData_rootcint_559_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPDirection",1297,G__RootEventData_rootcint_559_0_25, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMomentum",1138,G__RootEventData_rootcint_559_0_26, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCharge",874,G__RootEventData_rootcint_559_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_559_0_28, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMcHitTof::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_559_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcHitTof::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_559_0_30, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMcHitTof::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_559_0_31, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMcHitTof::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_559_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_559_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcHitTof::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_559_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcHitTof::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_559_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcHitTof::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_559_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcHitTof::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TMcHitTof", 850, G__RootEventData_rootcint_559_0_40, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof), -1, 0, 1, 1, 1, 0, "u 'TMcHitTof' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TMcHitTof", 976, G__RootEventData_rootcint_559_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_559_0_42, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof), -1, 1, 1, 1, 1, 0, "u 'TMcHitTof' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMcHitMdc(void) {
   /* TMcHitMdc */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc));
   G__memfunc_setup("TMcHitMdc",829,G__RootEventData_rootcint_560_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTrackID",942,G__RootEventData_rootcint_560_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLayerNo",998,G__RootEventData_rootcint_560_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - layer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCellNo",873,G__RootEventData_rootcint_560_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - cell", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEdep",682,G__RootEventData_rootcint_560_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - de", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPos",606,G__RootEventData_rootcint_560_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 0 - xyz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDriftD",873,G__RootEventData_rootcint_560_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - distance", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDriftT",889,G__RootEventData_rootcint_560_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGlobalT",977,G__RootEventData_rootcint_560_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTheta",802,G__RootEventData_rootcint_560_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - angle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEnterAngle",1297,G__RootEventData_rootcint_560_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - angle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPosFlag",984,G__RootEventData_rootcint_560_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrackID",930,G__RootEventData_rootcint_560_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLayerNo",986,G__RootEventData_rootcint_560_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCellNo",861,G__RootEventData_rootcint_560_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEdep",670,G__RootEventData_rootcint_560_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPos",594,G__RootEventData_rootcint_560_0_17, 117, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDriftD",861,G__RootEventData_rootcint_560_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDriftT",877,G__RootEventData_rootcint_560_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGlobalT",965,G__RootEventData_rootcint_560_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTheta",790,G__RootEventData_rootcint_560_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEnterAngle",1285,G__RootEventData_rootcint_560_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPosFlag",972,G__RootEventData_rootcint_560_0_23, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_560_0_24, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMcHitMdc::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_560_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcHitMdc::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_560_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMcHitMdc::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_560_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMcHitMdc::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_560_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_560_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcHitMdc::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_560_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcHitMdc::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_560_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcHitMdc::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_560_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcHitMdc::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TMcHitMdc", 829, G__RootEventData_rootcint_560_0_36, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc), -1, 0, 1, 1, 1, 0, "u 'TMcHitMdc' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TMcHitMdc", 955, G__RootEventData_rootcint_560_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_560_0_38, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc), -1, 1, 1, 1, 1, 0, "u 'TMcHitMdc' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMcDigiEmc(void) {
   /* TMcDigiEmc */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc));
   G__memfunc_setup("TMcDigiEmc",918,G__RootEventData_rootcint_561_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPartId",880,G__RootEventData_rootcint_561_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetThetaNb",978,G__RootEventData_rootcint_561_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nTheta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPhiNb",765,G__RootEventData_rootcint_561_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nPhi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEnergy",918,G__RootEventData_rootcint_561_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - energy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTime",699,G__RootEventData_rootcint_561_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTrackIndex",1305,G__RootEventData_rootcint_561_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPartId",868,G__RootEventData_rootcint_561_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetThetaNb",966,G__RootEventData_rootcint_561_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhiNb",753,G__RootEventData_rootcint_561_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEnergy",906,G__RootEventData_rootcint_561_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTime",687,G__RootEventData_rootcint_561_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrackIndex",1293,G__RootEventData_rootcint_561_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_561_0_14, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMcDigiEmc::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_561_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcDigiEmc::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_561_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMcDigiEmc::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_561_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMcDigiEmc::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_561_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_561_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcDigiEmc::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_561_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcDigiEmc::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_561_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcDigiEmc::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_561_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcDigiEmc::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TMcDigiEmc", 918, G__RootEventData_rootcint_561_0_26, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc), -1, 0, 1, 1, 1, 0, "u 'TMcDigiEmc' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TMcDigiEmc", 1044, G__RootEventData_rootcint_561_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_561_0_28, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc), -1, 1, 1, 1, 1, 0, "u 'TMcDigiEmc' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMcHitEvent(void) {
   /* TMcHitEvent */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitEvent));
   G__memfunc_setup("TMcHitEvent",1067,G__RootEventData_rootcint_562_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("getMcHitTofCol",1372,G__RootEventData_rootcint_562_0_4, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addMcHitTof",1063,G__RootEventData_rootcint_562_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMcHitTof' - 0 - hit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMcHitTof",1086,G__RootEventData_rootcint_562_0_6, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitTof), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMcHitMdcCol",1351,G__RootEventData_rootcint_562_0_7, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addMcHitMdc",1042,G__RootEventData_rootcint_562_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMcHitMdc' - 0 - hit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMcHitMdc",1065,G__RootEventData_rootcint_562_0_9, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitMdc), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMcDigiEmcCol",1440,G__RootEventData_rootcint_562_0_10, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TObjArray), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addMcDigiEmc",1131,G__RootEventData_rootcint_562_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMcDigiEmc' - 0 - digi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMcDigiEmc",1154,G__RootEventData_rootcint_562_0_12, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcDigiEmc), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setBeamTime",1104,G__RootEventData_rootcint_562_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getBeamTime",1092,G__RootEventData_rootcint_562_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_562_0_15, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMcHitEvent::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_562_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcHitEvent::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_562_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMcHitEvent::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_562_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMcHitEvent::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_562_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_562_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcHitEvent::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_562_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcHitEvent::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_562_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMcHitEvent::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_562_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMcHitEvent::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TMcHitEvent", 1067, G__RootEventData_rootcint_562_0_27, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitEvent), -1, 0, 1, 1, 1, 0, "u 'TMcHitEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TMcHitEvent", 1193, G__RootEventData_rootcint_562_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_562_0_29, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcHitEvent), -1, 1, 1, 1, 1, 0, "u 'TMcHitEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBossFullEvent(void) {
   /* TBossFullEvent */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEvent));
   G__memfunc_setup("TBossFullEvent",1408,G__RootEventData_rootcint_563_0_1, 105, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("copy",443,G__RootEventData_rootcint_563_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TBossFullEvent' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reset",547,G__RootEventData_rootcint_563_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setEvtHeader",1220,G__RootEventData_rootcint_563_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEvtHeader' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDigiEvent",1227,G__RootEventData_rootcint_563_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDigiEvent' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setDstEvent",1145,G__RootEventData_rootcint_563_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDstEvent' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setMcEvent",1022,G__RootEventData_rootcint_563_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMcEvent' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setTrigEvent",1252,G__RootEventData_rootcint_563_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTrigEvent' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setHltEvent",1142,G__RootEventData_rootcint_563_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'THltEvent' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setRecTrackEvent",1629,G__RootEventData_rootcint_563_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRecTrackEvent' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setEvtRecObject",1516,G__RootEventData_rootcint_563_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEvtRecObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEvtHeader",1208,G__RootEventData_rootcint_563_0_13, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtHeader), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getDigiEvent",1215,G__RootEventData_rootcint_563_0_14, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDigiEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getDstEvent",1133,G__RootEventData_rootcint_563_0_15, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TDstEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMcEvent",1010,G__RootEventData_rootcint_563_0_16, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TMcEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getTrigEvent",1240,G__RootEventData_rootcint_563_0_17, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TTrigEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getHltEvent",1130,G__RootEventData_rootcint_563_0_18, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_THltEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getRecTrackEvent",1617,G__RootEventData_rootcint_563_0_19, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TRecTrackEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getEvtRecObject",1504,G__RootEventData_rootcint_563_0_20, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TEvtRecObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RootEventData_rootcint_563_0_21, 85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBossFullEvent::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RootEventData_rootcint_563_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBossFullEvent::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RootEventData_rootcint_563_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBossFullEvent::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RootEventData_rootcint_563_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBossFullEvent::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RootEventData_rootcintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RootEventData_rootcint_563_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RootEventData_rootcint_563_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBossFullEvent::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RootEventData_rootcint_563_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBossFullEvent::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RootEventData_rootcint_563_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBossFullEvent::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RootEventData_rootcint_563_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBossFullEvent::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TBossFullEvent", 1408, G__RootEventData_rootcint_563_0_33, (int) ('i'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEvent), -1, 0, 1, 1, 1, 0, "u 'TBossFullEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TBossFullEvent", 1534, G__RootEventData_rootcint_563_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RootEventData_rootcint_563_0_35, (int) ('u'), G__get_linked_tagnum(&G__RootEventData_rootcintLN_TBossFullEvent), -1, 1, 1, 1, 1, 0, "u 'TBossFullEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}


/*********************************************************
* Member function information setup
*********************************************************/
extern "C" void G__cpp_setup_memfuncRootEventData_rootcint() {
}

/*********************************************************
* Global variable information setup for each class
*********************************************************/
static void G__cpp_setup_global0() {

   /* Setting up global variables */
   G__resetplocal();

}

static void G__cpp_setup_global1() {
}

static void G__cpp_setup_global2() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalRootEventData_rootcint() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {
}

static void G__cpp_setup_func4() {
}

static void G__cpp_setup_func5() {
}

static void G__cpp_setup_func6() {
}

static void G__cpp_setup_func7() {
}

static void G__cpp_setup_func8() {
}

static void G__cpp_setup_func9() {
}

static void G__cpp_setup_func10() {
}

static void G__cpp_setup_func11() {
}

static void G__cpp_setup_func12() {
}

static void G__cpp_setup_func13() {
}

static void G__cpp_setup_func14() {
}

static void G__cpp_setup_func15() {
}

static void G__cpp_setup_func16() {
}

static void G__cpp_setup_func17() {
}

static void G__cpp_setup_func18() {
}

static void G__cpp_setup_func19() {
}

static void G__cpp_setup_func20() {
}

static void G__cpp_setup_func21() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcRootEventData_rootcint() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
  G__cpp_setup_func5();
  G__cpp_setup_func6();
  G__cpp_setup_func7();
  G__cpp_setup_func8();
  G__cpp_setup_func9();
  G__cpp_setup_func10();
  G__cpp_setup_func11();
  G__cpp_setup_func12();
  G__cpp_setup_func13();
  G__cpp_setup_func14();
  G__cpp_setup_func15();
  G__cpp_setup_func16();
  G__cpp_setup_func17();
  G__cpp_setup_func18();
  G__cpp_setup_func19();
  G__cpp_setup_func20();
  G__cpp_setup_func21();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__RootEventData_rootcintLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR = { "vector<float,allocator<float> >" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_string = { "string" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TObjArray = { "TObjArray" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TJobInfo = { "TJobInfo" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR = { "vector<string,allocator<string> >" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<string,allocator<string> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR = { "vector<int,allocator<int> >" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<int,allocator<int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TRawData = { "TRawData" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMdcDigi = { "TMdcDigi" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TEmcDigi = { "TEmcDigi" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TTofDigi = { "TTofDigi" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMucDigi = { "TMucDigi" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TLumiDigi = { "TLumiDigi" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TDigiEvent = { "TDigiEvent" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcTrack = { "TRecMdcTrack" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcKalTrack = { "TRecMdcKalTrack" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcHit = { "TRecMdcHit" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TTofTrack = { "TTofTrack" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TRecTofTrack = { "TRecTofTrack" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TRecEmcHit = { "TRecEmcHit" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TRecEmcCluster = { "TRecEmcCluster" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TRecEmcShower = { "TRecEmcShower" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR = { "map<int,double,less<int>,allocator<pair<const int,double> > >" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TRecMucTrack = { "TRecMucTrack" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcDedx = { "TRecMdcDedx" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcDedxHit = { "TRecMdcDedxHit" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TRecExtTrack = { "TRecExtTrack" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR = { "vector<TString,allocator<TString> >" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TString,allocator<TString> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR = { "vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TRecEvTime = { "TRecEvTime" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TRecMdcKalHelixSeg = { "TRecMdcKalHelixSeg" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TRecZddChannel = { "TRecZddChannel" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_pairlEintcOfloatgR = { "pair<int,float>" , 115 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR = { "vector<pair<int,float>,allocator<pair<int,float> > >" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<int,float>,allocator<pair<int,float> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TRecTrackEvent = { "TRecTrackEvent" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMdcTrack = { "TMdcTrack" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TEmcTrack = { "TEmcTrack" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMucTrack = { "TMucTrack" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMdcDedx = { "TMdcDedx" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TExtTrack = { "TExtTrack" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMdcKalTrack = { "TMdcKalTrack" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TDstEvent = { "TDstEvent" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMdcMc = { "TMdcMc" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TEmcMc = { "TEmcMc" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TTofMc = { "TTofMc" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMucMc = { "TMucMc" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMcParticle = { "TMcParticle" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMcParticlecLcLStatusBits = { "TMcParticle::StatusBits" , 101 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMcEvent = { "TMcEvent" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TEvtHeader = { "TEvtHeader" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TEvtNavigator = { "TEvtNavigator" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR = { "multimap<int,int,less<int>,allocator<pair<const int,int> > >" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TTrigData = { "TTrigData" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TTrigEvent = { "TTrigEvent" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_THltRaw = { "THltRaw" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_THltInf = { "THltInf" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TDstHltInf = { "TDstHltInf" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_THltEvent = { "THltEvent" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TDisTrack = { "TDisTrack" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecEvent = { "TEvtRecEvent" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecTrack = { "TEvtRecTrack" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecPrimaryVertex = { "TEvtRecPrimaryVertex" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecVeeVertex = { "TEvtRecVeeVertex" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecPi0 = { "TEvtRecPi0" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecEtaToGG = { "TEvtRecEtaToGG" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecDTag = { "TEvtRecDTag" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TEvtRecObject = { "TEvtRecObject" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TElementActionTlEfloatgR = { "TElementActionT<float>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TElementPosActionTlEfloatgR = { "TElementPosActionT<float>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTlEfloatgR = { "TMatrixT<float>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTRow_constlEfloatgR = { "TMatrixTRow_const<float>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTRowlEfloatgR = { "TMatrixTRow<float>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTDiag_constlEfloatgR = { "TMatrixTDiag_const<float>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTColumn_constlEfloatgR = { "TMatrixTColumn_const<float>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTFlat_constlEfloatgR = { "TMatrixTFlat_const<float>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSub_constlEfloatgR = { "TMatrixTSub_const<float>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSparseRow_constlEfloatgR = { "TMatrixTSparseRow_const<float>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSparseDiag_constlEfloatgR = { "TMatrixTSparseDiag_const<float>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTColumnlEfloatgR = { "TMatrixTColumn<float>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTDiaglEfloatgR = { "TMatrixTDiag<float>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTFlatlEfloatgR = { "TMatrixTFlat<float>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSublEfloatgR = { "TMatrixTSub<float>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSparseRowlEfloatgR = { "TMatrixTSparseRow<float>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMatrixTSparseDiaglEfloatgR = { "TMatrixTSparseDiag<float>" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TVector3 = { "TVector3" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMcHitTof = { "TMcHitTof" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMcHitMdc = { "TMcHitMdc" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMcDigiEmc = { "TMcDigiEmc" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TMcHitEvent = { "TMcHitEvent" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TBossFullEvent = { "TBossFullEvent" , 99 , -1 };
G__linked_taginfo G__RootEventData_rootcintLN_TBossFullEventcLcLdA = { "TBossFullEvent::$" , 101 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableRootEventData_rootcint() {
  G__RootEventData_rootcintLN_TClass.tagnum = -1 ;
  G__RootEventData_rootcintLN_TBuffer.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMemberInspector.tagnum = -1 ;
  G__RootEventData_rootcintLN_TObject.tagnum = -1 ;
  G__RootEventData_rootcintLN_TString.tagnum = -1 ;
  G__RootEventData_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_string.tagnum = -1 ;
  G__RootEventData_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TObjArray.tagnum = -1 ;
  G__RootEventData_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TJobInfo.tagnum = -1 ;
  G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TRawData.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMdcDigi.tagnum = -1 ;
  G__RootEventData_rootcintLN_TEmcDigi.tagnum = -1 ;
  G__RootEventData_rootcintLN_TTofDigi.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMucDigi.tagnum = -1 ;
  G__RootEventData_rootcintLN_TLumiDigi.tagnum = -1 ;
  G__RootEventData_rootcintLN_TDigiEvent.tagnum = -1 ;
  G__RootEventData_rootcintLN_TRecMdcTrack.tagnum = -1 ;
  G__RootEventData_rootcintLN_TRecMdcKalTrack.tagnum = -1 ;
  G__RootEventData_rootcintLN_TRecMdcHit.tagnum = -1 ;
  G__RootEventData_rootcintLN_TTofTrack.tagnum = -1 ;
  G__RootEventData_rootcintLN_TRecTofTrack.tagnum = -1 ;
  G__RootEventData_rootcintLN_TRecEmcHit.tagnum = -1 ;
  G__RootEventData_rootcintLN_TRecEmcCluster.tagnum = -1 ;
  G__RootEventData_rootcintLN_TRecEmcShower.tagnum = -1 ;
  G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TRecMucTrack.tagnum = -1 ;
  G__RootEventData_rootcintLN_TRecMdcDedx.tagnum = -1 ;
  G__RootEventData_rootcintLN_TRecMdcDedxHit.tagnum = -1 ;
  G__RootEventData_rootcintLN_TRecExtTrack.tagnum = -1 ;
  G__RootEventData_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TRecEvTime.tagnum = -1 ;
  G__RootEventData_rootcintLN_TRecMdcKalHelixSeg.tagnum = -1 ;
  G__RootEventData_rootcintLN_TRecZddChannel.tagnum = -1 ;
  G__RootEventData_rootcintLN_pairlEintcOfloatgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TRecTrackEvent.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMdcTrack.tagnum = -1 ;
  G__RootEventData_rootcintLN_TEmcTrack.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMucTrack.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMdcDedx.tagnum = -1 ;
  G__RootEventData_rootcintLN_TExtTrack.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMdcKalTrack.tagnum = -1 ;
  G__RootEventData_rootcintLN_TDstEvent.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMdcMc.tagnum = -1 ;
  G__RootEventData_rootcintLN_TEmcMc.tagnum = -1 ;
  G__RootEventData_rootcintLN_TTofMc.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMucMc.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMcParticle.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMcParticlecLcLStatusBits.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMcEvent.tagnum = -1 ;
  G__RootEventData_rootcintLN_TEvtHeader.tagnum = -1 ;
  G__RootEventData_rootcintLN_TEvtNavigator.tagnum = -1 ;
  G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TTrigData.tagnum = -1 ;
  G__RootEventData_rootcintLN_TTrigEvent.tagnum = -1 ;
  G__RootEventData_rootcintLN_THltRaw.tagnum = -1 ;
  G__RootEventData_rootcintLN_THltInf.tagnum = -1 ;
  G__RootEventData_rootcintLN_TDstHltInf.tagnum = -1 ;
  G__RootEventData_rootcintLN_THltEvent.tagnum = -1 ;
  G__RootEventData_rootcintLN_TDisTrack.tagnum = -1 ;
  G__RootEventData_rootcintLN_TEvtRecEvent.tagnum = -1 ;
  G__RootEventData_rootcintLN_TEvtRecTrack.tagnum = -1 ;
  G__RootEventData_rootcintLN_TEvtRecPrimaryVertex.tagnum = -1 ;
  G__RootEventData_rootcintLN_TEvtRecVeeVertex.tagnum = -1 ;
  G__RootEventData_rootcintLN_TEvtRecPi0.tagnum = -1 ;
  G__RootEventData_rootcintLN_TEvtRecEtaToGG.tagnum = -1 ;
  G__RootEventData_rootcintLN_TEvtRecDTag.tagnum = -1 ;
  G__RootEventData_rootcintLN_TEvtRecObject.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMatrixTBaselEfloatgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMatrixTBaselEdoublegR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TVectorTlEfloatgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TVectorTlEdoublegR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TElementActionTlEfloatgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TElementPosActionTlEfloatgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMatrixTlEfloatgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMatrixTRow_constlEfloatgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMatrixTRowlEfloatgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMatrixTDiag_constlEfloatgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMatrixTColumn_constlEfloatgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMatrixTFlat_constlEfloatgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMatrixTSub_constlEfloatgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMatrixTSparseRow_constlEfloatgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMatrixTSparseDiag_constlEfloatgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMatrixTColumnlEfloatgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMatrixTDiaglEfloatgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMatrixTFlatlEfloatgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMatrixTSublEfloatgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMatrixTSparseRowlEfloatgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMatrixTSparseDiaglEfloatgR.tagnum = -1 ;
  G__RootEventData_rootcintLN_TVector3.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMcHitTof.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMcHitMdc.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMcDigiEmc.tagnum = -1 ;
  G__RootEventData_rootcintLN_TMcHitEvent.tagnum = -1 ;
  G__RootEventData_rootcintLN_TBossFullEvent.tagnum = -1 ;
  G__RootEventData_rootcintLN_TBossFullEventcLcLdA.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableRootEventData_rootcint() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TClass);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TObject);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TString);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlEfloatcOallocatorlEfloatgRsPgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlEdoublecOallocatorlEdoublegRsPgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_string);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TObjArray);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TJobInfo),sizeof(TJobInfo),-1,292096,(char*)NULL,G__setup_memvarTJobInfo,G__setup_memfuncTJobInfo);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlEstringcOallocatorlEstringgRsPgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlEintcOallocatorlEintgRsPgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRawData),sizeof(TRawData),-1,292096,(char*)NULL,G__setup_memvarTRawData,G__setup_memfuncTRawData);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMdcDigi),sizeof(TMdcDigi),-1,292096,(char*)NULL,G__setup_memvarTMdcDigi,G__setup_memfuncTMdcDigi);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEmcDigi),sizeof(TEmcDigi),-1,292096,(char*)NULL,G__setup_memvarTEmcDigi,G__setup_memfuncTEmcDigi);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TTofDigi),sizeof(TTofDigi),-1,292096,(char*)NULL,G__setup_memvarTTofDigi,G__setup_memfuncTTofDigi);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMucDigi),sizeof(TMucDigi),-1,292096,(char*)NULL,G__setup_memvarTMucDigi,G__setup_memfuncTMucDigi);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TLumiDigi),sizeof(TLumiDigi),-1,292096,(char*)NULL,G__setup_memvarTLumiDigi,G__setup_memfuncTLumiDigi);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TDigiEvent),sizeof(TDigiEvent),-1,292096,"Storage for Raw(Digi) event and subsystem data",G__setup_memvarTDigiEvent,G__setup_memfuncTDigiEvent);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecMdcTrack),sizeof(TRecMdcTrack),-1,292096,(char*)NULL,G__setup_memvarTRecMdcTrack,G__setup_memfuncTRecMdcTrack);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecMdcKalTrack),sizeof(TRecMdcKalTrack),-1,292096,(char*)NULL,G__setup_memvarTRecMdcKalTrack,G__setup_memfuncTRecMdcKalTrack);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecMdcHit),sizeof(TRecMdcHit),-1,292096,(char*)NULL,G__setup_memvarTRecMdcHit,G__setup_memfuncTRecMdcHit);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TTofTrack),sizeof(TTofTrack),-1,292096,(char*)NULL,G__setup_memvarTTofTrack,G__setup_memfuncTTofTrack);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecTofTrack),sizeof(TRecTofTrack),-1,292096,(char*)NULL,G__setup_memvarTRecTofTrack,G__setup_memfuncTRecTofTrack);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecEmcHit),sizeof(TRecEmcHit),-1,292096,(char*)NULL,G__setup_memvarTRecEmcHit,G__setup_memfuncTRecEmcHit);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecEmcCluster),sizeof(TRecEmcCluster),-1,292096,(char*)NULL,G__setup_memvarTRecEmcCluster,G__setup_memfuncTRecEmcCluster);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecEmcShower),sizeof(TRecEmcShower),-1,292096,(char*)NULL,G__setup_memvarTRecEmcShower,G__setup_memfuncTRecEmcShower);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecMucTrack),sizeof(TRecMucTrack),-1,292096,(char*)NULL,G__setup_memvarTRecMucTrack,G__setup_memfuncTRecMucTrack);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecMdcDedx),sizeof(TRecMdcDedx),-1,292096,(char*)NULL,G__setup_memvarTRecMdcDedx,G__setup_memfuncTRecMdcDedx);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecMdcDedxHit),sizeof(TRecMdcDedxHit),-1,292096,(char*)NULL,G__setup_memvarTRecMdcDedxHit,G__setup_memfuncTRecMdcDedxHit);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecExtTrack),sizeof(TRecExtTrack),-1,292096,(char*)NULL,G__setup_memvarTRecExtTrack,G__setup_memfuncTRecExtTrack);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlETStringcOallocatorlETStringgRsPgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecEvTime),sizeof(TRecEvTime),-1,292096,(char*)NULL,G__setup_memvarTRecEvTime,G__setup_memfuncTRecEvTime);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecMdcKalHelixSeg),sizeof(TRecMdcKalHelixSeg),-1,292096,(char*)NULL,G__setup_memvarTRecMdcKalHelixSeg,G__setup_memfuncTRecMdcKalHelixSeg);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecZddChannel),sizeof(TRecZddChannel),-1,292096,(char*)NULL,G__setup_memvarTRecZddChannel,G__setup_memfuncTRecZddChannel);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_pairlEintcOfloatgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_vectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_reverse_iteratorlEvectorlEpairlEintcOfloatgRcOallocatorlEpairlEintcOfloatgRsPgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TRecTrackEvent),sizeof(TRecTrackEvent),-1,292096,(char*)NULL,G__setup_memvarTRecTrackEvent,G__setup_memfuncTRecTrackEvent);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMdcTrack),sizeof(TMdcTrack),-1,292096,(char*)NULL,G__setup_memvarTMdcTrack,G__setup_memfuncTMdcTrack);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEmcTrack),sizeof(TEmcTrack),-1,292096,(char*)NULL,G__setup_memvarTEmcTrack,G__setup_memfuncTEmcTrack);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMucTrack),sizeof(TMucTrack),-1,292096,(char*)NULL,G__setup_memvarTMucTrack,G__setup_memfuncTMucTrack);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMdcDedx),sizeof(TMdcDedx),-1,292096,(char*)NULL,G__setup_memvarTMdcDedx,G__setup_memfuncTMdcDedx);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TExtTrack),sizeof(TExtTrack),-1,292096,(char*)NULL,G__setup_memvarTExtTrack,G__setup_memfuncTExtTrack);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMdcKalTrack),sizeof(TMdcKalTrack),-1,292096,(char*)NULL,G__setup_memvarTMdcKalTrack,G__setup_memfuncTMdcKalTrack);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TDstEvent),sizeof(TDstEvent),-1,292096,(char*)NULL,G__setup_memvarTDstEvent,G__setup_memfuncTDstEvent);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMdcMc),sizeof(TMdcMc),-1,292096,(char*)NULL,G__setup_memvarTMdcMc,G__setup_memfuncTMdcMc);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEmcMc),sizeof(TEmcMc),-1,292096,(char*)NULL,G__setup_memvarTEmcMc,G__setup_memfuncTEmcMc);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TTofMc),sizeof(TTofMc),-1,292096,(char*)NULL,G__setup_memvarTTofMc,G__setup_memfuncTTofMc);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMucMc),sizeof(TMucMc),-1,292096,(char*)NULL,G__setup_memvarTMucMc,G__setup_memfuncTMucMc);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMcParticle),sizeof(TMcParticle),-1,292096,(char*)NULL,G__setup_memvarTMcParticle,G__setup_memfuncTMcParticle);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMcParticlecLcLStatusBits);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMcEvent),sizeof(TMcEvent),-1,292096,"Storage for McTruth event and subsystem data",G__setup_memvarTMcEvent,G__setup_memfuncTMcEvent);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtHeader),sizeof(TEvtHeader),-1,292096,(char*)NULL,G__setup_memvarTEvtHeader,G__setup_memfuncTEvtHeader);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtNavigator),sizeof(TEvtNavigator),-1,292096,(char*)NULL,G__setup_memvarTEvtNavigator,G__setup_memfuncTEvtNavigator);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_multimaplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TTrigData),sizeof(TTrigData),-1,292096,(char*)NULL,G__setup_memvarTTrigData,G__setup_memfuncTTrigData);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TTrigEvent),sizeof(TTrigEvent),-1,292096,"Storage for trigger event and subsystem data",G__setup_memvarTTrigEvent,G__setup_memfuncTTrigEvent);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_THltRaw),sizeof(THltRaw),-1,292096,(char*)NULL,G__setup_memvarTHltRaw,G__setup_memfuncTHltRaw);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_THltInf),sizeof(THltInf),-1,292096,(char*)NULL,G__setup_memvarTHltInf,G__setup_memfuncTHltInf);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TDstHltInf),sizeof(TDstHltInf),-1,292096,(char*)NULL,G__setup_memvarTDstHltInf,G__setup_memfuncTDstHltInf);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_THltEvent),sizeof(THltEvent),-1,292096,"Storage for event filter and subsystem data",G__setup_memvarTHltEvent,G__setup_memfuncTHltEvent);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TDisTrack),sizeof(TDisTrack),-1,29952,(char*)NULL,G__setup_memvarTDisTrack,G__setup_memfuncTDisTrack);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecEvent),sizeof(TEvtRecEvent),-1,292096,(char*)NULL,G__setup_memvarTEvtRecEvent,G__setup_memfuncTEvtRecEvent);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecTrack),sizeof(TEvtRecTrack),-1,292096,(char*)NULL,G__setup_memvarTEvtRecTrack,G__setup_memfuncTEvtRecTrack);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecPrimaryVertex),sizeof(TEvtRecPrimaryVertex),-1,292096,(char*)NULL,G__setup_memvarTEvtRecPrimaryVertex,G__setup_memfuncTEvtRecPrimaryVertex);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecVeeVertex),sizeof(TEvtRecVeeVertex),-1,292096,(char*)NULL,G__setup_memvarTEvtRecVeeVertex,G__setup_memfuncTEvtRecVeeVertex);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecPi0),sizeof(TEvtRecPi0),-1,292096,(char*)NULL,G__setup_memvarTEvtRecPi0,G__setup_memfuncTEvtRecPi0);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecEtaToGG),sizeof(TEvtRecEtaToGG),-1,292096,(char*)NULL,G__setup_memvarTEvtRecEtaToGG,G__setup_memfuncTEvtRecEtaToGG);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecDTag),sizeof(TEvtRecDTag),-1,292096,(char*)NULL,G__setup_memvarTEvtRecDTag,G__setup_memfuncTEvtRecDTag);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TEvtRecObject),sizeof(TEvtRecObject),-1,292096,(char*)NULL,G__setup_memvarTEvtRecObject,G__setup_memfuncTEvtRecObject);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTBaselEfloatgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTBaselEdoublegR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TVectorTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TVectorTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TElementActionTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TElementPosActionTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTRow_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTRowlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTDiag_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTColumn_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTFlat_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTSub_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTSparseRow_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTSparseDiag_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTColumnlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTDiaglEfloatgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTFlatlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTSublEfloatgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTSparseRowlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMatrixTSparseDiaglEfloatgR);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TVector3);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMcHitTof),sizeof(TMcHitTof),-1,292096,(char*)NULL,G__setup_memvarTMcHitTof,G__setup_memfuncTMcHitTof);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMcHitMdc),sizeof(TMcHitMdc),-1,292096,(char*)NULL,G__setup_memvarTMcHitMdc,G__setup_memfuncTMcHitMdc);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMcDigiEmc),sizeof(TMcDigiEmc),-1,292096,(char*)NULL,G__setup_memvarTMcDigiEmc,G__setup_memfuncTMcDigiEmc);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TMcHitEvent),sizeof(TMcHitEvent),-1,292096,"Storage for Raw(Digi) event and subsystem data",G__setup_memvarTMcHitEvent,G__setup_memfuncTMcHitEvent);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TBossFullEvent),sizeof(TBossFullEvent),-1,95488,(char*)NULL,G__setup_memvarTBossFullEvent,G__setup_memfuncTBossFullEvent);
   G__get_linked_tagnum_fwd(&G__RootEventData_rootcintLN_TBossFullEventcLcLdA);
}
extern "C" void G__cpp_setupRootEventData_rootcint(void) {
  G__check_setup_version(30051515,"G__cpp_setupRootEventData_rootcint()");
  G__set_cpp_environmentRootEventData_rootcint();
  G__cpp_setup_tagtableRootEventData_rootcint();

  G__cpp_setup_inheritanceRootEventData_rootcint();

  G__cpp_setup_typetableRootEventData_rootcint();

  G__cpp_setup_memvarRootEventData_rootcint();

  G__cpp_setup_memfuncRootEventData_rootcint();
  G__cpp_setup_globalRootEventData_rootcint();
  G__cpp_setup_funcRootEventData_rootcint();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncRootEventData_rootcint();
  return;
}
class G__cpp_setup_initRootEventData_rootcint {
  public:
    G__cpp_setup_initRootEventData_rootcint() { G__add_setup_func("RootEventData_rootcint",(G__incsetup)(&G__cpp_setupRootEventData_rootcint)); G__call_setup_funcs(); }
   ~G__cpp_setup_initRootEventData_rootcint() { G__remove_setup_func("RootEventData_rootcint"); }
};
G__cpp_setup_initRootEventData_rootcint G__cpp_setup_initializerRootEventData_rootcint;

---