//
// File generated by rootcint at Mon Jul 10 21:23:57 2006

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

#include "RConfig.h"
#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 "TBenchDict.h"

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

#ifndef G__ROOT
#define G__ROOT
#endif

#include "RtypesImp.h"
#include "TCollectionProxy.h"
#include "TIsAProxy.h"
// START OF SHADOWS

namespace ROOT {
   namespace Shadow {
      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef pair< int, ::THit > pairlEintcOTHitgR;
      #else
      class pairlEintcOTHitgR  {
         public:
         //friend XX;
         int first; //
         ::THit second; //
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef pair< int, ::THit* > pairlEintcOTHitmUgR;
      #else
      class pairlEintcOTHitmUgR  {
         public:
         //friend XX;
         int first; //
         ::THit* second; //
      };
      #endif

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

namespace ROOT {
   void THit_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_THit(void *p = 0);
   static void *newArray_THit(Long_t size, void *p);
   static void delete_THit(void *p);
   static void deleteArray_THit(void *p);
   static void destruct_THit(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THit*)
   {
      ::THit *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THit >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THit", ::THit::Class_Version(), "TBench.h", 44,
                  typeid(::THit), DefineBehavior(ptr, ptr),
                  &::THit::Dictionary, isa_proxy, 6,
                  sizeof(::THit) );
      instance.SetNew(&new_THit);
      instance.SetNewArray(&newArray_THit);
      instance.SetDelete(&delete_THit);
      instance.SetDeleteArray(&deleteArray_THit);
      instance.SetDestructor(&destruct_THit);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THit*)
   {
      return GenerateInitInstanceLocal((::THit*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THit*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TObjHit_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_TObjHit(void *p = 0);
   static void *newArray_TObjHit(Long_t size, void *p);
   static void delete_TObjHit(void *p);
   static void deleteArray_TObjHit(void *p);
   static void destruct_TObjHit(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TObjHit*)
   {
      ::TObjHit *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TObjHit >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TObjHit", ::TObjHit::Class_Version(), "TBench.h", 94,
                  typeid(::TObjHit), DefineBehavior(ptr, ptr),
                  &::TObjHit::Dictionary, isa_proxy, 4,
                  sizeof(::TObjHit) );
      instance.SetNew(&new_TObjHit);
      instance.SetNewArray(&newArray_TObjHit);
      instance.SetDelete(&delete_TObjHit);
      instance.SetDeleteArray(&deleteArray_TObjHit);
      instance.SetDestructor(&destruct_TObjHit);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TObjHit*)
   {
      return GenerateInitInstanceLocal((::TObjHit*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TObjHit*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSTLhit_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_TSTLhit(void *p = 0);
   static void *newArray_TSTLhit(Long_t size, void *p);
   static void delete_TSTLhit(void *p);
   static void deleteArray_TSTLhit(void *p);
   static void destruct_TSTLhit(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSTLhit*)
   {
      ::TSTLhit *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSTLhit >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSTLhit", ::TSTLhit::Class_Version(), "TBench.h", 106,
                  typeid(::TSTLhit), DefineBehavior(ptr, ptr),
                  &::TSTLhit::Dictionary, isa_proxy, 4,
                  sizeof(::TSTLhit) );
      instance.SetNew(&new_TSTLhit);
      instance.SetNewArray(&newArray_TSTLhit);
      instance.SetDelete(&delete_TSTLhit);
      instance.SetDeleteArray(&deleteArray_TSTLhit);
      instance.SetDestructor(&destruct_TSTLhit);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSTLhit*)
   {
      return GenerateInitInstanceLocal((::TSTLhit*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSTLhit*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSTLhitList_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_TSTLhitList(void *p = 0);
   static void *newArray_TSTLhitList(Long_t size, void *p);
   static void delete_TSTLhitList(void *p);
   static void deleteArray_TSTLhitList(void *p);
   static void destruct_TSTLhitList(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSTLhitList*)
   {
      ::TSTLhitList *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSTLhitList >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSTLhitList", ::TSTLhitList::Class_Version(), "TBench.h", 124,
                  typeid(::TSTLhitList), DefineBehavior(ptr, ptr),
                  &::TSTLhitList::Dictionary, isa_proxy, 4,
                  sizeof(::TSTLhitList) );
      instance.SetNew(&new_TSTLhitList);
      instance.SetNewArray(&newArray_TSTLhitList);
      instance.SetDelete(&delete_TSTLhitList);
      instance.SetDeleteArray(&deleteArray_TSTLhitList);
      instance.SetDestructor(&destruct_TSTLhitList);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSTLhitList*)
   {
      return GenerateInitInstanceLocal((::TSTLhitList*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSTLhitList*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSTLhitDeque_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_TSTLhitDeque(void *p = 0);
   static void *newArray_TSTLhitDeque(Long_t size, void *p);
   static void delete_TSTLhitDeque(void *p);
   static void deleteArray_TSTLhitDeque(void *p);
   static void destruct_TSTLhitDeque(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSTLhitDeque*)
   {
      ::TSTLhitDeque *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSTLhitDeque >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSTLhitDeque", ::TSTLhitDeque::Class_Version(), "TBench.h", 143,
                  typeid(::TSTLhitDeque), DefineBehavior(ptr, ptr),
                  &::TSTLhitDeque::Dictionary, isa_proxy, 4,
                  sizeof(::TSTLhitDeque) );
      instance.SetNew(&new_TSTLhitDeque);
      instance.SetNewArray(&newArray_TSTLhitDeque);
      instance.SetDelete(&delete_TSTLhitDeque);
      instance.SetDeleteArray(&deleteArray_TSTLhitDeque);
      instance.SetDestructor(&destruct_TSTLhitDeque);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSTLhitDeque*)
   {
      return GenerateInitInstanceLocal((::TSTLhitDeque*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSTLhitDeque*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSTLhitMultiset_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_TSTLhitMultiset(void *p = 0);
   static void *newArray_TSTLhitMultiset(Long_t size, void *p);
   static void delete_TSTLhitMultiset(void *p);
   static void deleteArray_TSTLhitMultiset(void *p);
   static void destruct_TSTLhitMultiset(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSTLhitMultiset*)
   {
      ::TSTLhitMultiset *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSTLhitMultiset >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSTLhitMultiset", ::TSTLhitMultiset::Class_Version(), "TBench.h", 162,
                  typeid(::TSTLhitMultiset), DefineBehavior(ptr, ptr),
                  &::TSTLhitMultiset::Dictionary, isa_proxy, 4,
                  sizeof(::TSTLhitMultiset) );
      instance.SetNew(&new_TSTLhitMultiset);
      instance.SetNewArray(&newArray_TSTLhitMultiset);
      instance.SetDelete(&delete_TSTLhitMultiset);
      instance.SetDeleteArray(&deleteArray_TSTLhitMultiset);
      instance.SetDestructor(&destruct_TSTLhitMultiset);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSTLhitMultiset*)
   {
      return GenerateInitInstanceLocal((::TSTLhitMultiset*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSTLhitMultiset*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSTLhitSet_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_TSTLhitSet(void *p = 0);
   static void *newArray_TSTLhitSet(Long_t size, void *p);
   static void delete_TSTLhitSet(void *p);
   static void deleteArray_TSTLhitSet(void *p);
   static void destruct_TSTLhitSet(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSTLhitSet*)
   {
      ::TSTLhitSet *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSTLhitSet >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSTLhitSet", ::TSTLhitSet::Class_Version(), "TBench.h", 181,
                  typeid(::TSTLhitSet), DefineBehavior(ptr, ptr),
                  &::TSTLhitSet::Dictionary, isa_proxy, 4,
                  sizeof(::TSTLhitSet) );
      instance.SetNew(&new_TSTLhitSet);
      instance.SetNewArray(&newArray_TSTLhitSet);
      instance.SetDelete(&delete_TSTLhitSet);
      instance.SetDeleteArray(&deleteArray_TSTLhitSet);
      instance.SetDestructor(&destruct_TSTLhitSet);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSTLhitSet*)
   {
      return GenerateInitInstanceLocal((::TSTLhitSet*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSTLhitSet*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSTLhitMap_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_TSTLhitMap(void *p = 0);
   static void *newArray_TSTLhitMap(Long_t size, void *p);
   static void delete_TSTLhitMap(void *p);
   static void deleteArray_TSTLhitMap(void *p);
   static void destruct_TSTLhitMap(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSTLhitMap*)
   {
      ::TSTLhitMap *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSTLhitMap >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSTLhitMap", ::TSTLhitMap::Class_Version(), "TBench.h", 199,
                  typeid(::TSTLhitMap), DefineBehavior(ptr, ptr),
                  &::TSTLhitMap::Dictionary, isa_proxy, 4,
                  sizeof(::TSTLhitMap) );
      instance.SetNew(&new_TSTLhitMap);
      instance.SetNewArray(&newArray_TSTLhitMap);
      instance.SetDelete(&delete_TSTLhitMap);
      instance.SetDeleteArray(&deleteArray_TSTLhitMap);
      instance.SetDestructor(&destruct_TSTLhitMap);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSTLhitMap*)
   {
      return GenerateInitInstanceLocal((::TSTLhitMap*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSTLhitMap*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void pairlEintcOTHitgR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void pairlEintcOTHitgR_Dictionary();
   static void *new_pairlEintcOTHitgR(void *p = 0);
   static void *newArray_pairlEintcOTHitgR(Long_t size, void *p);
   static void delete_pairlEintcOTHitgR(void *p);
   static void deleteArray_pairlEintcOTHitgR(void *p);
   static void destruct_pairlEintcOTHitgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const pair<int,THit>*)
   {
      // Make sure the shadow class has the right sizeof
      pair<int,THit> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair<int,THit>),0);
      static ::ROOT::TGenericClassInfo 
         instance("pair<int,THit>", "prec_stl/utility", 10,
                  typeid(pair<int,THit>), DefineBehavior(ptr, ptr),
                  (void*)&pairlEintcOTHitgR_ShowMembers, &pairlEintcOTHitgR_Dictionary, isa_proxy, 4,
                  sizeof(pair<int,THit>) );
      instance.SetNew(&new_pairlEintcOTHitgR);
      instance.SetNewArray(&newArray_pairlEintcOTHitgR);
      instance.SetDelete(&delete_pairlEintcOTHitgR);
      instance.SetDeleteArray(&deleteArray_pairlEintcOTHitgR);
      instance.SetDestructor(&destruct_pairlEintcOTHitgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const pair<int,THit>*)
   {
      return GenerateInitInstanceLocal((pair<int,THit>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const pair<int,THit>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TSTLhitMultiMap_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_TSTLhitMultiMap(void *p = 0);
   static void *newArray_TSTLhitMultiMap(Long_t size, void *p);
   static void delete_TSTLhitMultiMap(void *p);
   static void deleteArray_TSTLhitMultiMap(void *p);
   static void destruct_TSTLhitMultiMap(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSTLhitMultiMap*)
   {
      ::TSTLhitMultiMap *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSTLhitMultiMap >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSTLhitMultiMap", ::TSTLhitMultiMap::Class_Version(), "TBench.h", 217,
                  typeid(::TSTLhitMultiMap), DefineBehavior(ptr, ptr),
                  &::TSTLhitMultiMap::Dictionary, isa_proxy, 4,
                  sizeof(::TSTLhitMultiMap) );
      instance.SetNew(&new_TSTLhitMultiMap);
      instance.SetNewArray(&newArray_TSTLhitMultiMap);
      instance.SetDelete(&delete_TSTLhitMultiMap);
      instance.SetDeleteArray(&deleteArray_TSTLhitMultiMap);
      instance.SetDestructor(&destruct_TSTLhitMultiMap);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSTLhitMultiMap*)
   {
      return GenerateInitInstanceLocal((::TSTLhitMultiMap*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSTLhitMultiMap*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSTLhitStar_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_TSTLhitStar(void *p = 0);
   static void *newArray_TSTLhitStar(Long_t size, void *p);
   static void delete_TSTLhitStar(void *p);
   static void deleteArray_TSTLhitStar(void *p);
   static void destruct_TSTLhitStar(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSTLhitStar*)
   {
      ::TSTLhitStar *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSTLhitStar >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSTLhitStar", ::TSTLhitStar::Class_Version(), "TBench.h", 273,
                  typeid(::TSTLhitStar), DefineBehavior(ptr, ptr),
                  &::TSTLhitStar::Dictionary, isa_proxy, 4,
                  sizeof(::TSTLhitStar) );
      instance.SetNew(&new_TSTLhitStar);
      instance.SetNewArray(&newArray_TSTLhitStar);
      instance.SetDelete(&delete_TSTLhitStar);
      instance.SetDeleteArray(&deleteArray_TSTLhitStar);
      instance.SetDestructor(&destruct_TSTLhitStar);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSTLhitStar*)
   {
      return GenerateInitInstanceLocal((::TSTLhitStar*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSTLhitStar*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSTLhitStarList_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_TSTLhitStarList(void *p = 0);
   static void *newArray_TSTLhitStarList(Long_t size, void *p);
   static void delete_TSTLhitStarList(void *p);
   static void deleteArray_TSTLhitStarList(void *p);
   static void destruct_TSTLhitStarList(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSTLhitStarList*)
   {
      ::TSTLhitStarList *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSTLhitStarList >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSTLhitStarList", ::TSTLhitStarList::Class_Version(), "TBench.h", 291,
                  typeid(::TSTLhitStarList), DefineBehavior(ptr, ptr),
                  &::TSTLhitStarList::Dictionary, isa_proxy, 4,
                  sizeof(::TSTLhitStarList) );
      instance.SetNew(&new_TSTLhitStarList);
      instance.SetNewArray(&newArray_TSTLhitStarList);
      instance.SetDelete(&delete_TSTLhitStarList);
      instance.SetDeleteArray(&deleteArray_TSTLhitStarList);
      instance.SetDestructor(&destruct_TSTLhitStarList);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSTLhitStarList*)
   {
      return GenerateInitInstanceLocal((::TSTLhitStarList*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSTLhitStarList*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSTLhitStarDeque_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_TSTLhitStarDeque(void *p = 0);
   static void *newArray_TSTLhitStarDeque(Long_t size, void *p);
   static void delete_TSTLhitStarDeque(void *p);
   static void deleteArray_TSTLhitStarDeque(void *p);
   static void destruct_TSTLhitStarDeque(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSTLhitStarDeque*)
   {
      ::TSTLhitStarDeque *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSTLhitStarDeque >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSTLhitStarDeque", ::TSTLhitStarDeque::Class_Version(), "TBench.h", 309,
                  typeid(::TSTLhitStarDeque), DefineBehavior(ptr, ptr),
                  &::TSTLhitStarDeque::Dictionary, isa_proxy, 4,
                  sizeof(::TSTLhitStarDeque) );
      instance.SetNew(&new_TSTLhitStarDeque);
      instance.SetNewArray(&newArray_TSTLhitStarDeque);
      instance.SetDelete(&delete_TSTLhitStarDeque);
      instance.SetDeleteArray(&deleteArray_TSTLhitStarDeque);
      instance.SetDestructor(&destruct_TSTLhitStarDeque);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSTLhitStarDeque*)
   {
      return GenerateInitInstanceLocal((::TSTLhitStarDeque*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSTLhitStarDeque*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSTLhitStarSet_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_TSTLhitStarSet(void *p = 0);
   static void *newArray_TSTLhitStarSet(Long_t size, void *p);
   static void delete_TSTLhitStarSet(void *p);
   static void deleteArray_TSTLhitStarSet(void *p);
   static void destruct_TSTLhitStarSet(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSTLhitStarSet*)
   {
      ::TSTLhitStarSet *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSTLhitStarSet >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSTLhitStarSet", ::TSTLhitStarSet::Class_Version(), "TBench.h", 328,
                  typeid(::TSTLhitStarSet), DefineBehavior(ptr, ptr),
                  &::TSTLhitStarSet::Dictionary, isa_proxy, 4,
                  sizeof(::TSTLhitStarSet) );
      instance.SetNew(&new_TSTLhitStarSet);
      instance.SetNewArray(&newArray_TSTLhitStarSet);
      instance.SetDelete(&delete_TSTLhitStarSet);
      instance.SetDeleteArray(&deleteArray_TSTLhitStarSet);
      instance.SetDestructor(&destruct_TSTLhitStarSet);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSTLhitStarSet*)
   {
      return GenerateInitInstanceLocal((::TSTLhitStarSet*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSTLhitStarSet*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSTLhitStarMultiSet_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_TSTLhitStarMultiSet(void *p = 0);
   static void *newArray_TSTLhitStarMultiSet(Long_t size, void *p);
   static void delete_TSTLhitStarMultiSet(void *p);
   static void deleteArray_TSTLhitStarMultiSet(void *p);
   static void destruct_TSTLhitStarMultiSet(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSTLhitStarMultiSet*)
   {
      ::TSTLhitStarMultiSet *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSTLhitStarMultiSet >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSTLhitStarMultiSet", ::TSTLhitStarMultiSet::Class_Version(), "TBench.h", 347,
                  typeid(::TSTLhitStarMultiSet), DefineBehavior(ptr, ptr),
                  &::TSTLhitStarMultiSet::Dictionary, isa_proxy, 4,
                  sizeof(::TSTLhitStarMultiSet) );
      instance.SetNew(&new_TSTLhitStarMultiSet);
      instance.SetNewArray(&newArray_TSTLhitStarMultiSet);
      instance.SetDelete(&delete_TSTLhitStarMultiSet);
      instance.SetDeleteArray(&deleteArray_TSTLhitStarMultiSet);
      instance.SetDestructor(&destruct_TSTLhitStarMultiSet);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSTLhitStarMultiSet*)
   {
      return GenerateInitInstanceLocal((::TSTLhitStarMultiSet*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSTLhitStarMultiSet*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSTLhitStarMap_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_TSTLhitStarMap(void *p = 0);
   static void *newArray_TSTLhitStarMap(Long_t size, void *p);
   static void delete_TSTLhitStarMap(void *p);
   static void deleteArray_TSTLhitStarMap(void *p);
   static void destruct_TSTLhitStarMap(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSTLhitStarMap*)
   {
      ::TSTLhitStarMap *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSTLhitStarMap >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSTLhitStarMap", ::TSTLhitStarMap::Class_Version(), "TBench.h", 366,
                  typeid(::TSTLhitStarMap), DefineBehavior(ptr, ptr),
                  &::TSTLhitStarMap::Dictionary, isa_proxy, 4,
                  sizeof(::TSTLhitStarMap) );
      instance.SetNew(&new_TSTLhitStarMap);
      instance.SetNewArray(&newArray_TSTLhitStarMap);
      instance.SetDelete(&delete_TSTLhitStarMap);
      instance.SetDeleteArray(&deleteArray_TSTLhitStarMap);
      instance.SetDestructor(&destruct_TSTLhitStarMap);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSTLhitStarMap*)
   {
      return GenerateInitInstanceLocal((::TSTLhitStarMap*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSTLhitStarMap*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void pairlEintcOTHitmUgR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void pairlEintcOTHitmUgR_Dictionary();
   static void *new_pairlEintcOTHitmUgR(void *p = 0);
   static void *newArray_pairlEintcOTHitmUgR(Long_t size, void *p);
   static void delete_pairlEintcOTHitmUgR(void *p);
   static void deleteArray_pairlEintcOTHitmUgR(void *p);
   static void destruct_pairlEintcOTHitmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const pair<int,THit*>*)
   {
      // Make sure the shadow class has the right sizeof
      pair<int,THit*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair<int,THit*>),0);
      static ::ROOT::TGenericClassInfo 
         instance("pair<int,THit*>", "prec_stl/utility", 10,
                  typeid(pair<int,THit*>), DefineBehavior(ptr, ptr),
                  (void*)&pairlEintcOTHitmUgR_ShowMembers, &pairlEintcOTHitmUgR_Dictionary, isa_proxy, 4,
                  sizeof(pair<int,THit*>) );
      instance.SetNew(&new_pairlEintcOTHitmUgR);
      instance.SetNewArray(&newArray_pairlEintcOTHitmUgR);
      instance.SetDelete(&delete_pairlEintcOTHitmUgR);
      instance.SetDeleteArray(&deleteArray_pairlEintcOTHitmUgR);
      instance.SetDestructor(&destruct_pairlEintcOTHitmUgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const pair<int,THit*>*)
   {
      return GenerateInitInstanceLocal((pair<int,THit*>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const pair<int,THit*>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TSTLhitStarMultiMap_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_TSTLhitStarMultiMap(void *p = 0);
   static void *newArray_TSTLhitStarMultiMap(Long_t size, void *p);
   static void delete_TSTLhitStarMultiMap(void *p);
   static void deleteArray_TSTLhitStarMultiMap(void *p);
   static void destruct_TSTLhitStarMultiMap(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSTLhitStarMultiMap*)
   {
      ::TSTLhitStarMultiMap *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSTLhitStarMultiMap >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSTLhitStarMultiMap", ::TSTLhitStarMultiMap::Class_Version(), "TBench.h", 385,
                  typeid(::TSTLhitStarMultiMap), DefineBehavior(ptr, ptr),
                  &::TSTLhitStarMultiMap::Dictionary, isa_proxy, 4,
                  sizeof(::TSTLhitStarMultiMap) );
      instance.SetNew(&new_TSTLhitStarMultiMap);
      instance.SetNewArray(&newArray_TSTLhitStarMultiMap);
      instance.SetDelete(&delete_TSTLhitStarMultiMap);
      instance.SetDeleteArray(&deleteArray_TSTLhitStarMultiMap);
      instance.SetDestructor(&destruct_TSTLhitStarMultiMap);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSTLhitStarMultiMap*)
   {
      return GenerateInitInstanceLocal((::TSTLhitStarMultiMap*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSTLhitStarMultiMap*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TCloneshit_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_TCloneshit(void *p = 0);
   static void *newArray_TCloneshit(Long_t size, void *p);
   static void delete_TCloneshit(void *p);
   static void deleteArray_TCloneshit(void *p);
   static void destruct_TCloneshit(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TCloneshit*)
   {
      ::TCloneshit *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TCloneshit >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TCloneshit", ::TCloneshit::Class_Version(), "TBench.h", 404,
                  typeid(::TCloneshit), DefineBehavior(ptr, ptr),
                  &::TCloneshit::Dictionary, isa_proxy, 4,
                  sizeof(::TCloneshit) );
      instance.SetNew(&new_TCloneshit);
      instance.SetNewArray(&newArray_TCloneshit);
      instance.SetDelete(&delete_TCloneshit);
      instance.SetDeleteArray(&deleteArray_TCloneshit);
      instance.SetDestructor(&destruct_TCloneshit);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TCloneshit*)
   {
      return GenerateInitInstanceLocal((::TCloneshit*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TCloneshit*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   if (R__b.IsReading()) {
      THit::Class()->ReadBuffer(R__b, this);
   } else {
      THit::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void THit::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class THit.
      TClass *R__cl = ::THit::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fX", &fX);
      R__insp.Inspect(R__cl, R__parent, "fY", &fY);
      R__insp.Inspect(R__cl, R__parent, "fZ", &fZ);
      R__insp.Inspect(R__cl, R__parent, "fNpulses", &fNpulses);
      R__insp.Inspect(R__cl, R__parent, "*fPulses", &fPulses);
      R__insp.Inspect(R__cl, R__parent, "fTime[10]", fTime);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_THit(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::THit : new ::THit;
   }
   static void *newArray_THit(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::THit[nElements] : new ::THit[nElements];
   }
   // Wrapper around operator delete
   static void delete_THit(void *p) {
      delete ((::THit*)p);
   }
   static void deleteArray_THit(void *p) {
      delete [] ((::THit*)p);
   }
   static void destruct_THit(void *p) {
      typedef ::THit current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THit

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

   if (R__b.IsReading()) {
      TObjHit::Class()->ReadBuffer(R__b, this);
   } else {
      TObjHit::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TObjHit::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TObjHit.
      TClass *R__cl = ::TObjHit::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      TObject::ShowMembers(R__insp, R__parent);
      THit::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TObjHit(void *p) {
      return  p ? new(p) ::TObjHit : new ::TObjHit;
   }
   static void *newArray_TObjHit(Long_t nElements, void *p) {
      return p ? new(p) ::TObjHit[nElements] : new ::TObjHit[nElements];
   }
   // Wrapper around operator delete
   static void delete_TObjHit(void *p) {
      delete ((::TObjHit*)p);
   }
   static void deleteArray_TObjHit(void *p) {
      delete [] ((::TObjHit*)p);
   }
   static void destruct_TObjHit(void *p) {
      typedef ::TObjHit current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TObjHit

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

   if (R__b.IsReading()) {
      TSTLhit::Class()->ReadBuffer(R__b, this);
   } else {
      TSTLhit::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TSTLhit::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TSTLhit.
      TClass *R__cl = ::TSTLhit::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNhits", &fNhits);
      R__insp.Inspect(R__cl, R__parent, "fList1", (void*)&fList1);
      ::ROOT::GenericShowMembers("vector<THit>", (void*)&fList1, R__insp, strcat(R__parent,"fList1."),false);
      R__parent[R__ncp] = 0;
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSTLhit(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhit : new ::TSTLhit;
   }
   static void *newArray_TSTLhit(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhit[nElements] : new ::TSTLhit[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSTLhit(void *p) {
      delete ((::TSTLhit*)p);
   }
   static void deleteArray_TSTLhit(void *p) {
      delete [] ((::TSTLhit*)p);
   }
   static void destruct_TSTLhit(void *p) {
      typedef ::TSTLhit current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSTLhit

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

   if (R__b.IsReading()) {
      TSTLhitList::Class()->ReadBuffer(R__b, this);
   } else {
      TSTLhitList::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TSTLhitList::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TSTLhitList.
      TClass *R__cl = ::TSTLhitList::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNhits", &fNhits);
      R__insp.Inspect(R__cl, R__parent, "fList1", (void*)&fList1);
      ::ROOT::GenericShowMembers("list<THit>", (void*)&fList1, R__insp, strcat(R__parent,"fList1."),false);
      R__parent[R__ncp] = 0;
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSTLhitList(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitList : new ::TSTLhitList;
   }
   static void *newArray_TSTLhitList(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitList[nElements] : new ::TSTLhitList[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSTLhitList(void *p) {
      delete ((::TSTLhitList*)p);
   }
   static void deleteArray_TSTLhitList(void *p) {
      delete [] ((::TSTLhitList*)p);
   }
   static void destruct_TSTLhitList(void *p) {
      typedef ::TSTLhitList current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSTLhitList

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

   if (R__b.IsReading()) {
      TSTLhitDeque::Class()->ReadBuffer(R__b, this);
   } else {
      TSTLhitDeque::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TSTLhitDeque::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TSTLhitDeque.
      TClass *R__cl = ::TSTLhitDeque::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNhits", &fNhits);
      R__insp.Inspect(R__cl, R__parent, "fList1", (void*)&fList1);
      ::ROOT::GenericShowMembers("deque<THit>", (void*)&fList1, R__insp, strcat(R__parent,"fList1."),false);
      R__parent[R__ncp] = 0;
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSTLhitDeque(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitDeque : new ::TSTLhitDeque;
   }
   static void *newArray_TSTLhitDeque(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitDeque[nElements] : new ::TSTLhitDeque[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSTLhitDeque(void *p) {
      delete ((::TSTLhitDeque*)p);
   }
   static void deleteArray_TSTLhitDeque(void *p) {
      delete [] ((::TSTLhitDeque*)p);
   }
   static void destruct_TSTLhitDeque(void *p) {
      typedef ::TSTLhitDeque current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSTLhitDeque

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

   if (R__b.IsReading()) {
      TSTLhitSet::Class()->ReadBuffer(R__b, this);
   } else {
      TSTLhitSet::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TSTLhitSet::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TSTLhitSet.
      TClass *R__cl = ::TSTLhitSet::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNhits", &fNhits);
      R__insp.Inspect(R__cl, R__parent, "fList1", (void*)&fList1);
      ::ROOT::GenericShowMembers("set<THit>", (void*)&fList1, R__insp, strcat(R__parent,"fList1."),false);
      R__parent[R__ncp] = 0;
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSTLhitSet(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitSet : new ::TSTLhitSet;
   }
   static void *newArray_TSTLhitSet(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitSet[nElements] : new ::TSTLhitSet[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSTLhitSet(void *p) {
      delete ((::TSTLhitSet*)p);
   }
   static void deleteArray_TSTLhitSet(void *p) {
      delete [] ((::TSTLhitSet*)p);
   }
   static void destruct_TSTLhitSet(void *p) {
      typedef ::TSTLhitSet current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSTLhitSet

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

   if (R__b.IsReading()) {
      TSTLhitMultiset::Class()->ReadBuffer(R__b, this);
   } else {
      TSTLhitMultiset::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TSTLhitMultiset::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TSTLhitMultiset.
      TClass *R__cl = ::TSTLhitMultiset::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNhits", &fNhits);
      R__insp.Inspect(R__cl, R__parent, "fList1", (void*)&fList1);
      ::ROOT::GenericShowMembers("multiset<THit>", (void*)&fList1, R__insp, strcat(R__parent,"fList1."),false);
      R__parent[R__ncp] = 0;
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSTLhitMultiset(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitMultiset : new ::TSTLhitMultiset;
   }
   static void *newArray_TSTLhitMultiset(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitMultiset[nElements] : new ::TSTLhitMultiset[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSTLhitMultiset(void *p) {
      delete ((::TSTLhitMultiset*)p);
   }
   static void deleteArray_TSTLhitMultiset(void *p) {
      delete [] ((::TSTLhitMultiset*)p);
   }
   static void destruct_TSTLhitMultiset(void *p) {
      typedef ::TSTLhitMultiset current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSTLhitMultiset

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

   if (R__b.IsReading()) {
      TSTLhitMap::Class()->ReadBuffer(R__b, this);
   } else {
      TSTLhitMap::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TSTLhitMap::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TSTLhitMap.
      TClass *R__cl = ::TSTLhitMap::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNhits", &fNhits);
      R__insp.Inspect(R__cl, R__parent, "fList1", (void*)&fList1);
      ::ROOT::GenericShowMembers("map<int,THit>", (void*)&fList1, R__insp, strcat(R__parent,"fList1."),false);
      R__parent[R__ncp] = 0;
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSTLhitMap(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitMap : new ::TSTLhitMap;
   }
   static void *newArray_TSTLhitMap(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitMap[nElements] : new ::TSTLhitMap[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSTLhitMap(void *p) {
      delete ((::TSTLhitMap*)p);
   }
   static void deleteArray_TSTLhitMap(void *p) {
      delete [] ((::TSTLhitMap*)p);
   }
   static void destruct_TSTLhitMap(void *p) {
      typedef ::TSTLhitMap current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSTLhitMap

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

   if (R__b.IsReading()) {
      TSTLhitMultiMap::Class()->ReadBuffer(R__b, this);
   } else {
      TSTLhitMultiMap::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TSTLhitMultiMap::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TSTLhitMultiMap.
      TClass *R__cl = ::TSTLhitMultiMap::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNhits", &fNhits);
      R__insp.Inspect(R__cl, R__parent, "fList1", (void*)&fList1);
      ::ROOT::GenericShowMembers("multimap<int,THit>", (void*)&fList1, R__insp, strcat(R__parent,"fList1."),false);
      R__parent[R__ncp] = 0;
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSTLhitMultiMap(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitMultiMap : new ::TSTLhitMultiMap;
   }
   static void *newArray_TSTLhitMultiMap(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitMultiMap[nElements] : new ::TSTLhitMultiMap[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSTLhitMultiMap(void *p) {
      delete ((::TSTLhitMultiMap*)p);
   }
   static void deleteArray_TSTLhitMultiMap(void *p) {
      delete [] ((::TSTLhitMultiMap*)p);
   }
   static void destruct_TSTLhitMultiMap(void *p) {
      typedef ::TSTLhitMultiMap current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSTLhitMultiMap

//______________________________________________________________________________
namespace ROOT {
   void pairlEintcOTHitgR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent)
   {
      // Inspect the data members of an object of class pair<int,THit>.
      typedef ::ROOT::Shadow::pairlEintcOTHitgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const pair<int,THit>*)0x0)->GetClass();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "first", &sobj->first);
      R__insp.Inspect(R__cl, R__parent, "second", &sobj->second);
      sobj->second.ShowMembers(R__insp, strcat(R__parent,"second.")); R__parent[R__ncp] = 0;
   }

}

namespace ROOT {
   // Wrappers around operator new
   static void *new_pairlEintcOTHitgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) pair<int,THit> : new pair<int,THit>;
   }
   static void *newArray_pairlEintcOTHitgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) pair<int,THit>[nElements] : new pair<int,THit>[nElements];
   }
   // Wrapper around operator delete
   static void delete_pairlEintcOTHitgR(void *p) {
      delete ((pair<int,THit>*)p);
   }
   static void deleteArray_pairlEintcOTHitgR(void *p) {
      delete [] ((pair<int,THit>*)p);
   }
   static void destruct_pairlEintcOTHitgR(void *p) {
      typedef pair<int,THit> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class pair<int,THit>

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

   if (R__b.IsReading()) {
      TSTLhitStar::Class()->ReadBuffer(R__b, this);
   } else {
      TSTLhitStar::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TSTLhitStar::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TSTLhitStar.
      TClass *R__cl = ::TSTLhitStar::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNhits", &fNhits);
      R__insp.Inspect(R__cl, R__parent, "fList2", (void*)&fList2);
      ::ROOT::GenericShowMembers("vector<THit*>", (void*)&fList2, R__insp, strcat(R__parent,"fList2."),false);
      R__parent[R__ncp] = 0;
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSTLhitStar(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitStar : new ::TSTLhitStar;
   }
   static void *newArray_TSTLhitStar(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitStar[nElements] : new ::TSTLhitStar[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSTLhitStar(void *p) {
      delete ((::TSTLhitStar*)p);
   }
   static void deleteArray_TSTLhitStar(void *p) {
      delete [] ((::TSTLhitStar*)p);
   }
   static void destruct_TSTLhitStar(void *p) {
      typedef ::TSTLhitStar current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSTLhitStar

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

   if (R__b.IsReading()) {
      TSTLhitStarList::Class()->ReadBuffer(R__b, this);
   } else {
      TSTLhitStarList::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TSTLhitStarList::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TSTLhitStarList.
      TClass *R__cl = ::TSTLhitStarList::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNhits", &fNhits);
      R__insp.Inspect(R__cl, R__parent, "fList2", (void*)&fList2);
      ::ROOT::GenericShowMembers("list<THit*>", (void*)&fList2, R__insp, strcat(R__parent,"fList2."),false);
      R__parent[R__ncp] = 0;
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSTLhitStarList(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitStarList : new ::TSTLhitStarList;
   }
   static void *newArray_TSTLhitStarList(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitStarList[nElements] : new ::TSTLhitStarList[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSTLhitStarList(void *p) {
      delete ((::TSTLhitStarList*)p);
   }
   static void deleteArray_TSTLhitStarList(void *p) {
      delete [] ((::TSTLhitStarList*)p);
   }
   static void destruct_TSTLhitStarList(void *p) {
      typedef ::TSTLhitStarList current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSTLhitStarList

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

   if (R__b.IsReading()) {
      TSTLhitStarDeque::Class()->ReadBuffer(R__b, this);
   } else {
      TSTLhitStarDeque::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TSTLhitStarDeque::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TSTLhitStarDeque.
      TClass *R__cl = ::TSTLhitStarDeque::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNhits", &fNhits);
      R__insp.Inspect(R__cl, R__parent, "fList2", (void*)&fList2);
      ::ROOT::GenericShowMembers("deque<THit*>", (void*)&fList2, R__insp, strcat(R__parent,"fList2."),false);
      R__parent[R__ncp] = 0;
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSTLhitStarDeque(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitStarDeque : new ::TSTLhitStarDeque;
   }
   static void *newArray_TSTLhitStarDeque(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitStarDeque[nElements] : new ::TSTLhitStarDeque[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSTLhitStarDeque(void *p) {
      delete ((::TSTLhitStarDeque*)p);
   }
   static void deleteArray_TSTLhitStarDeque(void *p) {
      delete [] ((::TSTLhitStarDeque*)p);
   }
   static void destruct_TSTLhitStarDeque(void *p) {
      typedef ::TSTLhitStarDeque current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSTLhitStarDeque

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

   if (R__b.IsReading()) {
      TSTLhitStarSet::Class()->ReadBuffer(R__b, this);
   } else {
      TSTLhitStarSet::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TSTLhitStarSet::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TSTLhitStarSet.
      TClass *R__cl = ::TSTLhitStarSet::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNhits", &fNhits);
      R__insp.Inspect(R__cl, R__parent, "fList2", (void*)&fList2);
      ::ROOT::GenericShowMembers("set<THit*>", (void*)&fList2, R__insp, strcat(R__parent,"fList2."),false);
      R__parent[R__ncp] = 0;
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSTLhitStarSet(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitStarSet : new ::TSTLhitStarSet;
   }
   static void *newArray_TSTLhitStarSet(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitStarSet[nElements] : new ::TSTLhitStarSet[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSTLhitStarSet(void *p) {
      delete ((::TSTLhitStarSet*)p);
   }
   static void deleteArray_TSTLhitStarSet(void *p) {
      delete [] ((::TSTLhitStarSet*)p);
   }
   static void destruct_TSTLhitStarSet(void *p) {
      typedef ::TSTLhitStarSet current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSTLhitStarSet

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

   if (R__b.IsReading()) {
      TSTLhitStarMultiSet::Class()->ReadBuffer(R__b, this);
   } else {
      TSTLhitStarMultiSet::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TSTLhitStarMultiSet::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TSTLhitStarMultiSet.
      TClass *R__cl = ::TSTLhitStarMultiSet::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNhits", &fNhits);
      R__insp.Inspect(R__cl, R__parent, "fList2", (void*)&fList2);
      ::ROOT::GenericShowMembers("multiset<THit*>", (void*)&fList2, R__insp, strcat(R__parent,"fList2."),false);
      R__parent[R__ncp] = 0;
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSTLhitStarMultiSet(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitStarMultiSet : new ::TSTLhitStarMultiSet;
   }
   static void *newArray_TSTLhitStarMultiSet(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitStarMultiSet[nElements] : new ::TSTLhitStarMultiSet[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSTLhitStarMultiSet(void *p) {
      delete ((::TSTLhitStarMultiSet*)p);
   }
   static void deleteArray_TSTLhitStarMultiSet(void *p) {
      delete [] ((::TSTLhitStarMultiSet*)p);
   }
   static void destruct_TSTLhitStarMultiSet(void *p) {
      typedef ::TSTLhitStarMultiSet current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSTLhitStarMultiSet

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

   if (R__b.IsReading()) {
      TSTLhitStarMap::Class()->ReadBuffer(R__b, this);
   } else {
      TSTLhitStarMap::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TSTLhitStarMap::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TSTLhitStarMap.
      TClass *R__cl = ::TSTLhitStarMap::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNhits", &fNhits);
      R__insp.Inspect(R__cl, R__parent, "fList2", (void*)&fList2);
      ::ROOT::GenericShowMembers("map<int,THit*>", (void*)&fList2, R__insp, strcat(R__parent,"fList2."),false);
      R__parent[R__ncp] = 0;
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSTLhitStarMap(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitStarMap : new ::TSTLhitStarMap;
   }
   static void *newArray_TSTLhitStarMap(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitStarMap[nElements] : new ::TSTLhitStarMap[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSTLhitStarMap(void *p) {
      delete ((::TSTLhitStarMap*)p);
   }
   static void deleteArray_TSTLhitStarMap(void *p) {
      delete [] ((::TSTLhitStarMap*)p);
   }
   static void destruct_TSTLhitStarMap(void *p) {
      typedef ::TSTLhitStarMap current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSTLhitStarMap

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

   if (R__b.IsReading()) {
      TSTLhitStarMultiMap::Class()->ReadBuffer(R__b, this);
   } else {
      TSTLhitStarMultiMap::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TSTLhitStarMultiMap::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TSTLhitStarMultiMap.
      TClass *R__cl = ::TSTLhitStarMultiMap::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNhits", &fNhits);
      R__insp.Inspect(R__cl, R__parent, "fList2", (void*)&fList2);
      ::ROOT::GenericShowMembers("multimap<int,THit*>", (void*)&fList2, R__insp, strcat(R__parent,"fList2."),false);
      R__parent[R__ncp] = 0;
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSTLhitStarMultiMap(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitStarMultiMap : new ::TSTLhitStarMultiMap;
   }
   static void *newArray_TSTLhitStarMultiMap(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TSTLhitStarMultiMap[nElements] : new ::TSTLhitStarMultiMap[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSTLhitStarMultiMap(void *p) {
      delete ((::TSTLhitStarMultiMap*)p);
   }
   static void deleteArray_TSTLhitStarMultiMap(void *p) {
      delete [] ((::TSTLhitStarMultiMap*)p);
   }
   static void destruct_TSTLhitStarMultiMap(void *p) {
      typedef ::TSTLhitStarMultiMap current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSTLhitStarMultiMap

//______________________________________________________________________________
namespace ROOT {
   void pairlEintcOTHitmUgR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent)
   {
      // Inspect the data members of an object of class pair<int,THit*>.
      typedef ::ROOT::Shadow::pairlEintcOTHitmUgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const pair<int,THit*>*)0x0)->GetClass();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "first", &sobj->first);
      R__insp.Inspect(R__cl, R__parent, "*second", &sobj->second);
   }

}

namespace ROOT {
   // Wrappers around operator new
   static void *new_pairlEintcOTHitmUgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) pair<int,THit*> : new pair<int,THit*>;
   }
   static void *newArray_pairlEintcOTHitmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) pair<int,THit*>[nElements] : new pair<int,THit*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_pairlEintcOTHitmUgR(void *p) {
      delete ((pair<int,THit*>*)p);
   }
   static void deleteArray_pairlEintcOTHitmUgR(void *p) {
      delete [] ((pair<int,THit*>*)p);
   }
   static void destruct_pairlEintcOTHitmUgR(void *p) {
      typedef pair<int,THit*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class pair<int,THit*>

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

   if (R__b.IsReading()) {
      TCloneshit::Class()->ReadBuffer(R__b, this);
   } else {
      TCloneshit::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TCloneshit::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TCloneshit.
      TClass *R__cl = ::TCloneshit::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNhits", &fNhits);
      R__insp.Inspect(R__cl, R__parent, "*fList3", &fList3);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TCloneshit(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TCloneshit : new ::TCloneshit;
   }
   static void *newArray_TCloneshit(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TCloneshit[nElements] : new ::TCloneshit[nElements];
   }
   // Wrapper around operator delete
   static void delete_TCloneshit(void *p) {
      delete ((::TCloneshit*)p);
   }
   static void deleteArray_TCloneshit(void *p) {
      delete [] ((::TCloneshit*)p);
   }
   static void destruct_TCloneshit(void *p) {
      typedef ::TCloneshit current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TCloneshit

namespace ROOT {
   void dequelETHitmUgR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void dequelETHitmUgR_Dictionary();
   static void *new_dequelETHitmUgR(void *p = 0);
   static void *newArray_dequelETHitmUgR(Long_t size, void *p);
   static void delete_dequelETHitmUgR(void *p);
   static void deleteArray_dequelETHitmUgR(void *p);
   static void destruct_dequelETHitmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const deque<THit*>*)
   {
      deque<THit*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(deque<THit*>),0);
      static ::ROOT::TGenericClassInfo 
         instance("deque<THit*>", ::TStreamerInfo::Class_Version(), "prec_stl/deque", 35,
                  typeid(deque<THit*>), DefineBehavior(ptr, ptr),
                  0, &dequelETHitmUgR_Dictionary, isa_proxy, 0,
                  sizeof(deque<THit*>) );
      instance.SetNew(&new_dequelETHitmUgR);
      instance.SetNewArray(&newArray_dequelETHitmUgR);
      instance.SetDelete(&delete_dequelETHitmUgR);
      instance.SetDeleteArray(&deleteArray_dequelETHitmUgR);
      instance.SetDestructor(&destruct_dequelETHitmUgR);
      instance.AdoptStreamer(TCollectionProxy::GenClassStreamer(TCollectionProxy::Pushback< deque<THit*> >()));
      instance.AdoptCollectionProxy(TCollectionProxy::GenProxy(TCollectionProxy::Pushback< deque<THit*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const deque<THit*>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_dequelETHitmUgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) deque<THit*> : new deque<THit*>;
   }
   static void *newArray_dequelETHitmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) deque<THit*>[nElements] : new deque<THit*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_dequelETHitmUgR(void *p) {
      delete ((deque<THit*>*)p);
   }
   static void deleteArray_dequelETHitmUgR(void *p) {
      delete [] ((deque<THit*>*)p);
   }
   static void destruct_dequelETHitmUgR(void *p) {
      typedef deque<THit*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class deque<THit*>

namespace ROOT {
   void dequelETHitgR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void dequelETHitgR_Dictionary();
   static void *new_dequelETHitgR(void *p = 0);
   static void *newArray_dequelETHitgR(Long_t size, void *p);
   static void delete_dequelETHitgR(void *p);
   static void deleteArray_dequelETHitgR(void *p);
   static void destruct_dequelETHitgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const deque<THit>*)
   {
      deque<THit> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(deque<THit>),0);
      static ::ROOT::TGenericClassInfo 
         instance("deque<THit>", ::TStreamerInfo::Class_Version(), "prec_stl/deque", 35,
                  typeid(deque<THit>), DefineBehavior(ptr, ptr),
                  0, &dequelETHitgR_Dictionary, isa_proxy, 0,
                  sizeof(deque<THit>) );
      instance.SetNew(&new_dequelETHitgR);
      instance.SetNewArray(&newArray_dequelETHitgR);
      instance.SetDelete(&delete_dequelETHitgR);
      instance.SetDeleteArray(&deleteArray_dequelETHitgR);
      instance.SetDestructor(&destruct_dequelETHitgR);
      instance.AdoptStreamer(TCollectionProxy::GenClassStreamer(TCollectionProxy::Pushback< deque<THit> >()));
      instance.AdoptCollectionProxy(TCollectionProxy::GenProxy(TCollectionProxy::Pushback< deque<THit> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const deque<THit>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_dequelETHitgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) deque<THit> : new deque<THit>;
   }
   static void *newArray_dequelETHitgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) deque<THit>[nElements] : new deque<THit>[nElements];
   }
   // Wrapper around operator delete
   static void delete_dequelETHitgR(void *p) {
      delete ((deque<THit>*)p);
   }
   static void deleteArray_dequelETHitgR(void *p) {
      delete [] ((deque<THit>*)p);
   }
   static void destruct_dequelETHitgR(void *p) {
      typedef deque<THit> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class deque<THit>

namespace ROOT {
   void listlETHitmUgR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void listlETHitmUgR_Dictionary();
   static void *new_listlETHitmUgR(void *p = 0);
   static void *newArray_listlETHitmUgR(Long_t size, void *p);
   static void delete_listlETHitmUgR(void *p);
   static void deleteArray_listlETHitmUgR(void *p);
   static void destruct_listlETHitmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const list<THit*>*)
   {
      list<THit*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(list<THit*>),0);
      static ::ROOT::TGenericClassInfo 
         instance("list<THit*>", ::TStreamerInfo::Class_Version(), "prec_stl/list", 37,
                  typeid(list<THit*>), DefineBehavior(ptr, ptr),
                  0, &listlETHitmUgR_Dictionary, isa_proxy, 0,
                  sizeof(list<THit*>) );
      instance.SetNew(&new_listlETHitmUgR);
      instance.SetNewArray(&newArray_listlETHitmUgR);
      instance.SetDelete(&delete_listlETHitmUgR);
      instance.SetDeleteArray(&deleteArray_listlETHitmUgR);
      instance.SetDestructor(&destruct_listlETHitmUgR);
      instance.AdoptStreamer(TCollectionProxy::GenClassStreamer(TCollectionProxy::Pushback< list<THit*> >()));
      instance.AdoptCollectionProxy(TCollectionProxy::GenProxy(TCollectionProxy::Pushback< list<THit*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const list<THit*>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_listlETHitmUgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) list<THit*> : new list<THit*>;
   }
   static void *newArray_listlETHitmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) list<THit*>[nElements] : new list<THit*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_listlETHitmUgR(void *p) {
      delete ((list<THit*>*)p);
   }
   static void deleteArray_listlETHitmUgR(void *p) {
      delete [] ((list<THit*>*)p);
   }
   static void destruct_listlETHitmUgR(void *p) {
      typedef list<THit*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class list<THit*>

namespace ROOT {
   void listlETHitgR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void listlETHitgR_Dictionary();
   static void *new_listlETHitgR(void *p = 0);
   static void *newArray_listlETHitgR(Long_t size, void *p);
   static void delete_listlETHitgR(void *p);
   static void deleteArray_listlETHitgR(void *p);
   static void destruct_listlETHitgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const list<THit>*)
   {
      list<THit> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(list<THit>),0);
      static ::ROOT::TGenericClassInfo 
         instance("list<THit>", ::TStreamerInfo::Class_Version(), "prec_stl/list", 37,
                  typeid(list<THit>), DefineBehavior(ptr, ptr),
                  0, &listlETHitgR_Dictionary, isa_proxy, 0,
                  sizeof(list<THit>) );
      instance.SetNew(&new_listlETHitgR);
      instance.SetNewArray(&newArray_listlETHitgR);
      instance.SetDelete(&delete_listlETHitgR);
      instance.SetDeleteArray(&deleteArray_listlETHitgR);
      instance.SetDestructor(&destruct_listlETHitgR);
      instance.AdoptStreamer(TCollectionProxy::GenClassStreamer(TCollectionProxy::Pushback< list<THit> >()));
      instance.AdoptCollectionProxy(TCollectionProxy::GenProxy(TCollectionProxy::Pushback< list<THit> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const list<THit>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_listlETHitgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) list<THit> : new list<THit>;
   }
   static void *newArray_listlETHitgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) list<THit>[nElements] : new list<THit>[nElements];
   }
   // Wrapper around operator delete
   static void delete_listlETHitgR(void *p) {
      delete ((list<THit>*)p);
   }
   static void deleteArray_listlETHitgR(void *p) {
      delete [] ((list<THit>*)p);
   }
   static void destruct_listlETHitgR(void *p) {
      typedef list<THit> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class list<THit>

namespace ROOT {
   void maplEintcOTHitmUgR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void maplEintcOTHitmUgR_Dictionary();
   static void *new_maplEintcOTHitmUgR(void *p = 0);
   static void *newArray_maplEintcOTHitmUgR(Long_t size, void *p);
   static void delete_maplEintcOTHitmUgR(void *p);
   static void deleteArray_maplEintcOTHitmUgR(void *p);
   static void destruct_maplEintcOTHitmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const map<int,THit*>*)
   {
      map<int,THit*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<int,THit*>),0);
      static ::ROOT::TGenericClassInfo 
         instance("map<int,THit*>", ::TStreamerInfo::Class_Version(), "prec_stl/map", 56,
                  typeid(map<int,THit*>), DefineBehavior(ptr, ptr),
                  0, &maplEintcOTHitmUgR_Dictionary, isa_proxy, 0,
                  sizeof(map<int,THit*>) );
      instance.SetNew(&new_maplEintcOTHitmUgR);
      instance.SetNewArray(&newArray_maplEintcOTHitmUgR);
      instance.SetDelete(&delete_maplEintcOTHitmUgR);
      instance.SetDeleteArray(&deleteArray_maplEintcOTHitmUgR);
      instance.SetDestructor(&destruct_maplEintcOTHitmUgR);
      instance.AdoptStreamer(TCollectionProxy::GenClassStreamer(TCollectionProxy::MapInsert< map<int,THit*> >()));
      instance.AdoptCollectionProxy(TCollectionProxy::GenProxy(TCollectionProxy::MapInsert< map<int,THit*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<int,THit*>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_maplEintcOTHitmUgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<int,THit*> : new map<int,THit*>;
   }
   static void *newArray_maplEintcOTHitmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<int,THit*>[nElements] : new map<int,THit*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplEintcOTHitmUgR(void *p) {
      delete ((map<int,THit*>*)p);
   }
   static void deleteArray_maplEintcOTHitmUgR(void *p) {
      delete [] ((map<int,THit*>*)p);
   }
   static void destruct_maplEintcOTHitmUgR(void *p) {
      typedef map<int,THit*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class map<int,THit*>

namespace ROOT {
   void maplEintcOTHitgR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void maplEintcOTHitgR_Dictionary();
   static void *new_maplEintcOTHitgR(void *p = 0);
   static void *newArray_maplEintcOTHitgR(Long_t size, void *p);
   static void delete_maplEintcOTHitgR(void *p);
   static void deleteArray_maplEintcOTHitgR(void *p);
   static void destruct_maplEintcOTHitgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const map<int,THit>*)
   {
      map<int,THit> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<int,THit>),0);
      static ::ROOT::TGenericClassInfo 
         instance("map<int,THit>", ::TStreamerInfo::Class_Version(), "prec_stl/map", 56,
                  typeid(map<int,THit>), DefineBehavior(ptr, ptr),
                  0, &maplEintcOTHitgR_Dictionary, isa_proxy, 0,
                  sizeof(map<int,THit>) );
      instance.SetNew(&new_maplEintcOTHitgR);
      instance.SetNewArray(&newArray_maplEintcOTHitgR);
      instance.SetDelete(&delete_maplEintcOTHitgR);
      instance.SetDeleteArray(&deleteArray_maplEintcOTHitgR);
      instance.SetDestructor(&destruct_maplEintcOTHitgR);
      instance.AdoptStreamer(TCollectionProxy::GenClassStreamer(TCollectionProxy::MapInsert< map<int,THit> >()));
      instance.AdoptCollectionProxy(TCollectionProxy::GenProxy(TCollectionProxy::MapInsert< map<int,THit> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<int,THit>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_maplEintcOTHitgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<int,THit> : new map<int,THit>;
   }
   static void *newArray_maplEintcOTHitgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<int,THit>[nElements] : new map<int,THit>[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplEintcOTHitgR(void *p) {
      delete ((map<int,THit>*)p);
   }
   static void deleteArray_maplEintcOTHitgR(void *p) {
      delete [] ((map<int,THit>*)p);
   }
   static void destruct_maplEintcOTHitgR(void *p) {
      typedef map<int,THit> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class map<int,THit>

namespace ROOT {
   void multimaplEintcOTHitmUgR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void multimaplEintcOTHitmUgR_Dictionary();
   static void *new_multimaplEintcOTHitmUgR(void *p = 0);
   static void *newArray_multimaplEintcOTHitmUgR(Long_t size, void *p);
   static void delete_multimaplEintcOTHitmUgR(void *p);
   static void deleteArray_multimaplEintcOTHitmUgR(void *p);
   static void destruct_multimaplEintcOTHitmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const multimap<int,THit*>*)
   {
      multimap<int,THit*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(multimap<int,THit*>),0);
      static ::ROOT::TGenericClassInfo 
         instance("multimap<int,THit*>", ::TStreamerInfo::Class_Version(), "prec_stl/multimap", 56,
                  typeid(multimap<int,THit*>), DefineBehavior(ptr, ptr),
                  0, &multimaplEintcOTHitmUgR_Dictionary, isa_proxy, 0,
                  sizeof(multimap<int,THit*>) );
      instance.SetNew(&new_multimaplEintcOTHitmUgR);
      instance.SetNewArray(&newArray_multimaplEintcOTHitmUgR);
      instance.SetDelete(&delete_multimaplEintcOTHitmUgR);
      instance.SetDeleteArray(&deleteArray_multimaplEintcOTHitmUgR);
      instance.SetDestructor(&destruct_multimaplEintcOTHitmUgR);
      instance.AdoptStreamer(TCollectionProxy::GenClassStreamer(TCollectionProxy::MapInsert< multimap<int,THit*> >()));
      instance.AdoptCollectionProxy(TCollectionProxy::GenProxy(TCollectionProxy::MapInsert< multimap<int,THit*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const multimap<int,THit*>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_multimaplEintcOTHitmUgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) multimap<int,THit*> : new multimap<int,THit*>;
   }
   static void *newArray_multimaplEintcOTHitmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) multimap<int,THit*>[nElements] : new multimap<int,THit*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_multimaplEintcOTHitmUgR(void *p) {
      delete ((multimap<int,THit*>*)p);
   }
   static void deleteArray_multimaplEintcOTHitmUgR(void *p) {
      delete [] ((multimap<int,THit*>*)p);
   }
   static void destruct_multimaplEintcOTHitmUgR(void *p) {
      typedef multimap<int,THit*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class multimap<int,THit*>

namespace ROOT {
   void multimaplEintcOTHitgR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void multimaplEintcOTHitgR_Dictionary();
   static void *new_multimaplEintcOTHitgR(void *p = 0);
   static void *newArray_multimaplEintcOTHitgR(Long_t size, void *p);
   static void delete_multimaplEintcOTHitgR(void *p);
   static void deleteArray_multimaplEintcOTHitgR(void *p);
   static void destruct_multimaplEintcOTHitgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const multimap<int,THit>*)
   {
      multimap<int,THit> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(multimap<int,THit>),0);
      static ::ROOT::TGenericClassInfo 
         instance("multimap<int,THit>", ::TStreamerInfo::Class_Version(), "prec_stl/multimap", 56,
                  typeid(multimap<int,THit>), DefineBehavior(ptr, ptr),
                  0, &multimaplEintcOTHitgR_Dictionary, isa_proxy, 0,
                  sizeof(multimap<int,THit>) );
      instance.SetNew(&new_multimaplEintcOTHitgR);
      instance.SetNewArray(&newArray_multimaplEintcOTHitgR);
      instance.SetDelete(&delete_multimaplEintcOTHitgR);
      instance.SetDeleteArray(&deleteArray_multimaplEintcOTHitgR);
      instance.SetDestructor(&destruct_multimaplEintcOTHitgR);
      instance.AdoptStreamer(TCollectionProxy::GenClassStreamer(TCollectionProxy::MapInsert< multimap<int,THit> >()));
      instance.AdoptCollectionProxy(TCollectionProxy::GenProxy(TCollectionProxy::MapInsert< multimap<int,THit> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const multimap<int,THit>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_multimaplEintcOTHitgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) multimap<int,THit> : new multimap<int,THit>;
   }
   static void *newArray_multimaplEintcOTHitgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) multimap<int,THit>[nElements] : new multimap<int,THit>[nElements];
   }
   // Wrapper around operator delete
   static void delete_multimaplEintcOTHitgR(void *p) {
      delete ((multimap<int,THit>*)p);
   }
   static void deleteArray_multimaplEintcOTHitgR(void *p) {
      delete [] ((multimap<int,THit>*)p);
   }
   static void destruct_multimaplEintcOTHitgR(void *p) {
      typedef multimap<int,THit> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class multimap<int,THit>

namespace ROOT {
   void multisetlETHitmUgR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void multisetlETHitmUgR_Dictionary();
   static void *new_multisetlETHitmUgR(void *p = 0);
   static void *newArray_multisetlETHitmUgR(Long_t size, void *p);
   static void delete_multisetlETHitmUgR(void *p);
   static void deleteArray_multisetlETHitmUgR(void *p);
   static void destruct_multisetlETHitmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const multiset<THit*>*)
   {
      multiset<THit*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(multiset<THit*>),0);
      static ::ROOT::TGenericClassInfo 
         instance("multiset<THit*>", ::TStreamerInfo::Class_Version(), "prec_stl/multiset", 42,
                  typeid(multiset<THit*>), DefineBehavior(ptr, ptr),
                  0, &multisetlETHitmUgR_Dictionary, isa_proxy, 0,
                  sizeof(multiset<THit*>) );
      instance.SetNew(&new_multisetlETHitmUgR);
      instance.SetNewArray(&newArray_multisetlETHitmUgR);
      instance.SetDelete(&delete_multisetlETHitmUgR);
      instance.SetDeleteArray(&deleteArray_multisetlETHitmUgR);
      instance.SetDestructor(&destruct_multisetlETHitmUgR);
      instance.AdoptStreamer(TCollectionProxy::GenClassStreamer(TCollectionProxy::Insert< multiset<THit*> >()));
      instance.AdoptCollectionProxy(TCollectionProxy::GenProxy(TCollectionProxy::Insert< multiset<THit*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const multiset<THit*>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_multisetlETHitmUgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) multiset<THit*> : new multiset<THit*>;
   }
   static void *newArray_multisetlETHitmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) multiset<THit*>[nElements] : new multiset<THit*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_multisetlETHitmUgR(void *p) {
      delete ((multiset<THit*>*)p);
   }
   static void deleteArray_multisetlETHitmUgR(void *p) {
      delete [] ((multiset<THit*>*)p);
   }
   static void destruct_multisetlETHitmUgR(void *p) {
      typedef multiset<THit*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class multiset<THit*>

namespace ROOT {
   void multisetlETHitgR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void multisetlETHitgR_Dictionary();
   static void *new_multisetlETHitgR(void *p = 0);
   static void *newArray_multisetlETHitgR(Long_t size, void *p);
   static void delete_multisetlETHitgR(void *p);
   static void deleteArray_multisetlETHitgR(void *p);
   static void destruct_multisetlETHitgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const multiset<THit>*)
   {
      multiset<THit> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(multiset<THit>),0);
      static ::ROOT::TGenericClassInfo 
         instance("multiset<THit>", ::TStreamerInfo::Class_Version(), "prec_stl/multiset", 42,
                  typeid(multiset<THit>), DefineBehavior(ptr, ptr),
                  0, &multisetlETHitgR_Dictionary, isa_proxy, 0,
                  sizeof(multiset<THit>) );
      instance.SetNew(&new_multisetlETHitgR);
      instance.SetNewArray(&newArray_multisetlETHitgR);
      instance.SetDelete(&delete_multisetlETHitgR);
      instance.SetDeleteArray(&deleteArray_multisetlETHitgR);
      instance.SetDestructor(&destruct_multisetlETHitgR);
      instance.AdoptStreamer(TCollectionProxy::GenClassStreamer(TCollectionProxy::Insert< multiset<THit> >()));
      instance.AdoptCollectionProxy(TCollectionProxy::GenProxy(TCollectionProxy::Insert< multiset<THit> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const multiset<THit>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_multisetlETHitgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) multiset<THit> : new multiset<THit>;
   }
   static void *newArray_multisetlETHitgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) multiset<THit>[nElements] : new multiset<THit>[nElements];
   }
   // Wrapper around operator delete
   static void delete_multisetlETHitgR(void *p) {
      delete ((multiset<THit>*)p);
   }
   static void deleteArray_multisetlETHitgR(void *p) {
      delete [] ((multiset<THit>*)p);
   }
   static void destruct_multisetlETHitgR(void *p) {
      typedef multiset<THit> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class multiset<THit>

namespace ROOT {
   void setlETHitmUgR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void setlETHitmUgR_Dictionary();
   static void *new_setlETHitmUgR(void *p = 0);
   static void *newArray_setlETHitmUgR(Long_t size, void *p);
   static void delete_setlETHitmUgR(void *p);
   static void deleteArray_setlETHitmUgR(void *p);
   static void destruct_setlETHitmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const set<THit*>*)
   {
      set<THit*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(set<THit*>),0);
      static ::ROOT::TGenericClassInfo 
         instance("set<THit*>", ::TStreamerInfo::Class_Version(), "prec_stl/set", 42,
                  typeid(set<THit*>), DefineBehavior(ptr, ptr),
                  0, &setlETHitmUgR_Dictionary, isa_proxy, 0,
                  sizeof(set<THit*>) );
      instance.SetNew(&new_setlETHitmUgR);
      instance.SetNewArray(&newArray_setlETHitmUgR);
      instance.SetDelete(&delete_setlETHitmUgR);
      instance.SetDeleteArray(&deleteArray_setlETHitmUgR);
      instance.SetDestructor(&destruct_setlETHitmUgR);
      instance.AdoptStreamer(TCollectionProxy::GenClassStreamer(TCollectionProxy::Insert< set<THit*> >()));
      instance.AdoptCollectionProxy(TCollectionProxy::GenProxy(TCollectionProxy::Insert< set<THit*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const set<THit*>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_setlETHitmUgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) set<THit*> : new set<THit*>;
   }
   static void *newArray_setlETHitmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) set<THit*>[nElements] : new set<THit*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_setlETHitmUgR(void *p) {
      delete ((set<THit*>*)p);
   }
   static void deleteArray_setlETHitmUgR(void *p) {
      delete [] ((set<THit*>*)p);
   }
   static void destruct_setlETHitmUgR(void *p) {
      typedef set<THit*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class set<THit*>

namespace ROOT {
   void setlETHitgR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void setlETHitgR_Dictionary();
   static void *new_setlETHitgR(void *p = 0);
   static void *newArray_setlETHitgR(Long_t size, void *p);
   static void delete_setlETHitgR(void *p);
   static void deleteArray_setlETHitgR(void *p);
   static void destruct_setlETHitgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const set<THit>*)
   {
      set<THit> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(set<THit>),0);
      static ::ROOT::TGenericClassInfo 
         instance("set<THit>", ::TStreamerInfo::Class_Version(), "prec_stl/set", 42,
                  typeid(set<THit>), DefineBehavior(ptr, ptr),
                  0, &setlETHitgR_Dictionary, isa_proxy, 0,
                  sizeof(set<THit>) );
      instance.SetNew(&new_setlETHitgR);
      instance.SetNewArray(&newArray_setlETHitgR);
      instance.SetDelete(&delete_setlETHitgR);
      instance.SetDeleteArray(&deleteArray_setlETHitgR);
      instance.SetDestructor(&destruct_setlETHitgR);
      instance.AdoptStreamer(TCollectionProxy::GenClassStreamer(TCollectionProxy::Insert< set<THit> >()));
      instance.AdoptCollectionProxy(TCollectionProxy::GenProxy(TCollectionProxy::Insert< set<THit> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const set<THit>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_setlETHitgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) set<THit> : new set<THit>;
   }
   static void *newArray_setlETHitgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) set<THit>[nElements] : new set<THit>[nElements];
   }
   // Wrapper around operator delete
   static void delete_setlETHitgR(void *p) {
      delete ((set<THit>*)p);
   }
   static void deleteArray_setlETHitgR(void *p) {
      delete [] ((set<THit>*)p);
   }
   static void destruct_setlETHitgR(void *p) {
      typedef set<THit> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class set<THit>

namespace ROOT {
   void vectorlETHitmUgR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void vectorlETHitmUgR_Dictionary();
   static void *new_vectorlETHitmUgR(void *p = 0);
   static void *newArray_vectorlETHitmUgR(Long_t size, void *p);
   static void delete_vectorlETHitmUgR(void *p);
   static void deleteArray_vectorlETHitmUgR(void *p);
   static void destruct_vectorlETHitmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<THit*>*)
   {
      vector<THit*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<THit*>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<THit*>", ::TStreamerInfo::Class_Version(), "prec_stl/vector", 42,
                  typeid(vector<THit*>), DefineBehavior(ptr, ptr),
                  0, &vectorlETHitmUgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<THit*>) );
      instance.SetNew(&new_vectorlETHitmUgR);
      instance.SetNewArray(&newArray_vectorlETHitmUgR);
      instance.SetDelete(&delete_vectorlETHitmUgR);
      instance.SetDeleteArray(&deleteArray_vectorlETHitmUgR);
      instance.SetDestructor(&destruct_vectorlETHitmUgR);
      instance.AdoptStreamer(TCollectionProxy::GenClassStreamer(TCollectionProxy::Pushback< vector<THit*> >()));
      instance.AdoptCollectionProxy(TCollectionProxy::GenProxy(TCollectionProxy::Pushback< vector<THit*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<THit*>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlETHitmUgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<THit*> : new vector<THit*>;
   }
   static void *newArray_vectorlETHitmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<THit*>[nElements] : new vector<THit*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlETHitmUgR(void *p) {
      delete ((vector<THit*>*)p);
   }
   static void deleteArray_vectorlETHitmUgR(void *p) {
      delete [] ((vector<THit*>*)p);
   }
   static void destruct_vectorlETHitmUgR(void *p) {
      typedef vector<THit*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<THit*>

namespace ROOT {
   void vectorlETHitgR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void vectorlETHitgR_Dictionary();
   static void *new_vectorlETHitgR(void *p = 0);
   static void *newArray_vectorlETHitgR(Long_t size, void *p);
   static void delete_vectorlETHitgR(void *p);
   static void deleteArray_vectorlETHitgR(void *p);
   static void destruct_vectorlETHitgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<THit>*)
   {
      vector<THit> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<THit>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<THit>", ::TStreamerInfo::Class_Version(), "prec_stl/vector", 42,
                  typeid(vector<THit>), DefineBehavior(ptr, ptr),
                  0, &vectorlETHitgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<THit>) );
      instance.SetNew(&new_vectorlETHitgR);
      instance.SetNewArray(&newArray_vectorlETHitgR);
      instance.SetDelete(&delete_vectorlETHitgR);
      instance.SetDeleteArray(&deleteArray_vectorlETHitgR);
      instance.SetDestructor(&destruct_vectorlETHitgR);
      instance.AdoptStreamer(TCollectionProxy::GenClassStreamer(TCollectionProxy::Pushback< vector<THit> >()));
      instance.AdoptCollectionProxy(TCollectionProxy::GenProxy(TCollectionProxy::Pushback< vector<THit> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<THit>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlETHitgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<THit> : new vector<THit>;
   }
   static void *newArray_vectorlETHitgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<THit>[nElements] : new vector<THit>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlETHitgR(void *p) {
      delete ((vector<THit>*)p);
   }
   static void deleteArray_vectorlETHitgR(void *p) {
      delete [] ((vector<THit>*)p);
   }
   static void destruct_vectorlETHitgR(void *p) {
      typedef vector<THit> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<THit>

/********************************************************
* TBenchDict.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

extern "C" void G__cpp_reset_tagtableTBenchDict();

extern "C" void G__set_cpp_environmentTBenchDict() {
  G__add_compiledheader("TROOT.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TBench.h");
  G__cpp_reset_tagtableTBenchDict();
}
#include <new>
extern "C" int G__cpp_dllrevTBenchDict() { return(30051515); }

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

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

static int G__TBenchDict_513_2_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THit* p = NULL;
   long gvp = G__getgvp();
   //m: 1
   if ((gvp == G__PVOID) || (gvp == 0)) {
     p = new THit(*(THit*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) THit(*(THit*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_THit);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TBenchDict_513_3_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THit* p = NULL;
   long gvp = G__getgvp();
   //m: 1
   if ((gvp == G__PVOID) || (gvp == 0)) {
     p = new THit((int) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) THit((int) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_THit);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__TBenchDict_513_5_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THit*) G__getstructoffset())->Get((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TBenchDict_513_6_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const THit*) G__getstructoffset())->operator==(*(THit*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TBenchDict_513_7_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const THit*) G__getstructoffset())->operator<(*(THit*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__TBenchDict_513_4_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THit*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref, (char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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


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

static int G__TBenchDict_514_2_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TObjHit* p = NULL;
   long gvp = G__getgvp();
   //m: 1
   if ((gvp == G__PVOID) || (gvp == 0)) {
     p = new TObjHit((int) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TObjHit((int) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TObjHit);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__TBenchDict_514_8_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TObjHit*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref, (char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

{
   TObjHit* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TObjHit(*(TObjHit*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TObjHit);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TObjHit G__TTObjHit;
static int G__TBenchDict_514_6_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   long gvp = 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 == G__PVOID) {
       delete[] (TObjHit*) soff;
     } else {
       G__setgvp(G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TObjHit*) (soff+(sizeof(TObjHit)*i)))->~G__TTObjHit();
       }
       G__setgvp(gvp);
     }
   } else {
     if (gvp == G__PVOID) {
       delete (TObjHit*) soff;
     } else {
       G__setgvp(G__PVOID);
       ((TObjHit*) (soff))->~G__TTObjHit();
       G__setgvp(gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__TBenchDict_515_2_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSTLhit* p = NULL;
   long gvp = G__getgvp();
   //m: 1
   if ((gvp == G__PVOID) || (gvp == 0)) {
     p = new TSTLhit((int) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TSTLhit((int) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhit);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__TBenchDict_515_5_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhit*) G__getstructoffset())->MakeTree((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
, *(float*) G__Floatref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TBenchDict_515_6_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhit*) G__getstructoffset())->ReadTree());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__TBenchDict_515_2_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSTLhit*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref, (char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

{
   TSTLhit* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TSTLhit(*(TSTLhit*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhit);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


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

static int G__TBenchDict_520_2_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSTLhitList* p = NULL;
   long gvp = G__getgvp();
   //m: 1
   if ((gvp == G__PVOID) || (gvp == 0)) {
     p = new TSTLhitList((int) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TSTLhitList((int) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitList);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__TBenchDict_520_5_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitList*) G__getstructoffset())->MakeTree((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
, *(float*) G__Floatref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TBenchDict_520_6_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitList*) G__getstructoffset())->ReadTree());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__TBenchDict_520_2_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSTLhitList*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref, (char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

{
   TSTLhitList* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TSTLhitList(*(TSTLhitList*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitList);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


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

static int G__TBenchDict_524_2_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSTLhitDeque* p = NULL;
   long gvp = G__getgvp();
   //m: 1
   if ((gvp == G__PVOID) || (gvp == 0)) {
     p = new TSTLhitDeque((int) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TSTLhitDeque((int) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitDeque);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__TBenchDict_524_5_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitDeque*) G__getstructoffset())->MakeTree((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
, *(float*) G__Floatref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TBenchDict_524_6_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitDeque*) G__getstructoffset())->ReadTree());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__TBenchDict_524_2_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSTLhitDeque*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref, (char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

{
   TSTLhitDeque* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TSTLhitDeque(*(TSTLhitDeque*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitDeque);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


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

static int G__TBenchDict_528_2_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSTLhitMultiset* p = NULL;
   long gvp = G__getgvp();
   //m: 1
   if ((gvp == G__PVOID) || (gvp == 0)) {
     p = new TSTLhitMultiset((int) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TSTLhitMultiset((int) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMultiset);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__TBenchDict_528_5_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitMultiset*) G__getstructoffset())->MakeTree((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
, *(float*) G__Floatref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TBenchDict_528_6_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitMultiset*) G__getstructoffset())->ReadTree());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__TBenchDict_528_2_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSTLhitMultiset*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref, (char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

{
   TSTLhitMultiset* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TSTLhitMultiset(*(TSTLhitMultiset*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMultiset);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


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

static int G__TBenchDict_534_2_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSTLhitSet* p = NULL;
   long gvp = G__getgvp();
   //m: 1
   if ((gvp == G__PVOID) || (gvp == 0)) {
     p = new TSTLhitSet((int) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TSTLhitSet((int) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitSet);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__TBenchDict_534_5_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitSet*) G__getstructoffset())->MakeTree((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
, *(float*) G__Floatref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TBenchDict_534_6_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitSet*) G__getstructoffset())->ReadTree());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__TBenchDict_534_2_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSTLhitSet*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref, (char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

{
   TSTLhitSet* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TSTLhitSet(*(TSTLhitSet*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitSet);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


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

static int G__TBenchDict_539_2_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSTLhitMap* p = NULL;
   long gvp = G__getgvp();
   //m: 1
   if ((gvp == G__PVOID) || (gvp == 0)) {
     p = new TSTLhitMap((int) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TSTLhitMap((int) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMap);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__TBenchDict_539_5_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitMap*) G__getstructoffset())->MakeTree((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
, *(float*) G__Floatref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TBenchDict_539_6_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitMap*) G__getstructoffset())->ReadTree());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__TBenchDict_539_2_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSTLhitMap*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref, (char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

{
   TSTLhitMap* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TSTLhitMap(*(TSTLhitMap*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMap);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


/* pair<int,THit> */
static int G__TBenchDict_543_1_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   pair<int,THit>* p = NULL;
   long gvp = G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == G__PVOID) || (gvp == 0)) {
       p = new pair<int,THit>[n];
     } else {
       p = new((void*) gvp) pair<int,THit>[n];
     }
   } else {
     if ((gvp == G__PVOID) || (gvp == 0)) {
       p = new pair<int,THit>;
     } else {
       p = new((void*) gvp) pair<int,THit>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_pairlEintcOTHitgR);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TBenchDict_543_2_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   pair<int,THit>* p = NULL;
   long gvp = G__getgvp();
   //m: 2
   if ((gvp == G__PVOID) || (gvp == 0)) {
     p = new pair<int,THit>(*(int*) G__Intref(&libp->para[0]), *(THit*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) pair<int,THit>(*(int*) G__Intref(&libp->para[0]), *(THit*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_pairlEintcOTHitgR);
   return(1 || funcname || hash || result7 || libp) ;
}

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

{
   pair<int,THit>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new pair<int,THit>(*(pair<int,THit>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_pairlEintcOTHitgR);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__TBenchDict_547_2_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSTLhitMultiMap* p = NULL;
   long gvp = G__getgvp();
   //m: 1
   if ((gvp == G__PVOID) || (gvp == 0)) {
     p = new TSTLhitMultiMap((int) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TSTLhitMultiMap((int) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMultiMap);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__TBenchDict_547_5_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitMultiMap*) G__getstructoffset())->MakeTree((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
, *(float*) G__Floatref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TBenchDict_547_6_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitMultiMap*) G__getstructoffset())->ReadTree());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__TBenchDict_547_2_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSTLhitMultiMap*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref, (char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

{
   TSTLhitMultiMap* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TSTLhitMultiMap(*(TSTLhitMultiMap*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMultiMap);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


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

static int G__TBenchDict_551_2_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSTLhitStar* p = NULL;
   long gvp = G__getgvp();
   //m: 1
   if ((gvp == G__PVOID) || (gvp == 0)) {
     p = new TSTLhitStar((int) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TSTLhitStar((int) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStar);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__TBenchDict_551_5_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitStar*) G__getstructoffset())->MakeTree((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
, *(float*) G__Floatref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TBenchDict_551_6_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitStar*) G__getstructoffset())->ReadTree());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__TBenchDict_551_2_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSTLhitStar*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref, (char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

{
   TSTLhitStar* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TSTLhitStar(*(TSTLhitStar*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStar);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


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

static int G__TBenchDict_556_2_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSTLhitStarList* p = NULL;
   long gvp = G__getgvp();
   //m: 1
   if ((gvp == G__PVOID) || (gvp == 0)) {
     p = new TSTLhitStarList((int) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TSTLhitStarList((int) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarList);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__TBenchDict_556_5_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitStarList*) G__getstructoffset())->MakeTree((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
, *(float*) G__Floatref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TBenchDict_556_6_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitStarList*) G__getstructoffset())->ReadTree());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__TBenchDict_556_2_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSTLhitStarList*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref, (char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

{
   TSTLhitStarList* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TSTLhitStarList(*(TSTLhitStarList*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarList);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


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

static int G__TBenchDict_560_2_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSTLhitStarDeque* p = NULL;
   long gvp = G__getgvp();
   //m: 1
   if ((gvp == G__PVOID) || (gvp == 0)) {
     p = new TSTLhitStarDeque((int) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TSTLhitStarDeque((int) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarDeque);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__TBenchDict_560_5_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitStarDeque*) G__getstructoffset())->MakeTree((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
, *(float*) G__Floatref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TBenchDict_560_6_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitStarDeque*) G__getstructoffset())->ReadTree());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__TBenchDict_560_2_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSTLhitStarDeque*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref, (char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

{
   TSTLhitStarDeque* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TSTLhitStarDeque(*(TSTLhitStarDeque*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarDeque);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


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

static int G__TBenchDict_564_2_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSTLhitStarSet* p = NULL;
   long gvp = G__getgvp();
   //m: 1
   if ((gvp == G__PVOID) || (gvp == 0)) {
     p = new TSTLhitStarSet((int) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TSTLhitStarSet((int) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarSet);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__TBenchDict_564_5_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitStarSet*) G__getstructoffset())->MakeTree((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
, *(float*) G__Floatref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TBenchDict_564_6_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitStarSet*) G__getstructoffset())->ReadTree());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__TBenchDict_564_2_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSTLhitStarSet*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref, (char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

{
   TSTLhitStarSet* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TSTLhitStarSet(*(TSTLhitStarSet*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarSet);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


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

static int G__TBenchDict_571_2_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSTLhitStarMultiSet* p = NULL;
   long gvp = G__getgvp();
   //m: 1
   if ((gvp == G__PVOID) || (gvp == 0)) {
     p = new TSTLhitStarMultiSet((int) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TSTLhitStarMultiSet((int) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMultiSet);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__TBenchDict_571_5_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitStarMultiSet*) G__getstructoffset())->MakeTree((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
, *(float*) G__Floatref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TBenchDict_571_6_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitStarMultiSet*) G__getstructoffset())->ReadTree());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__TBenchDict_571_2_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSTLhitStarMultiSet*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref, (char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

{
   TSTLhitStarMultiSet* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TSTLhitStarMultiSet(*(TSTLhitStarMultiSet*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMultiSet);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


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

static int G__TBenchDict_575_2_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSTLhitStarMap* p = NULL;
   long gvp = G__getgvp();
   //m: 1
   if ((gvp == G__PVOID) || (gvp == 0)) {
     p = new TSTLhitStarMap((int) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TSTLhitStarMap((int) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMap);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__TBenchDict_575_5_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitStarMap*) G__getstructoffset())->MakeTree((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
, *(float*) G__Floatref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TBenchDict_575_6_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitStarMap*) G__getstructoffset())->ReadTree());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__TBenchDict_575_2_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSTLhitStarMap*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref, (char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

{
   TSTLhitStarMap* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TSTLhitStarMap(*(TSTLhitStarMap*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMap);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


/* pair<int,THit*> */
static int G__TBenchDict_579_1_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   pair<int,THit*>* p = NULL;
   long gvp = G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == G__PVOID) || (gvp == 0)) {
       p = new pair<int,THit*>[n];
     } else {
       p = new((void*) gvp) pair<int,THit*>[n];
     }
   } else {
     if ((gvp == G__PVOID) || (gvp == 0)) {
       p = new pair<int,THit*>;
     } else {
       p = new((void*) gvp) pair<int,THit*>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_pairlEintcOTHitmUgR);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TBenchDict_579_2_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   pair<int,THit*>* p = NULL;
   long gvp = G__getgvp();
   //m: 2
   if ((gvp == G__PVOID) || (gvp == 0)) {
     p = new pair<int,THit*>(*(int*) G__Intref(&libp->para[0]), libp->para[1].ref ? *(THit**) libp->para[1].ref : *(THit**) (&G__Mlong(libp->para[1])));
   } else {
     p = new((void*) gvp) pair<int,THit*>(*(int*) G__Intref(&libp->para[0]), libp->para[1].ref ? *(THit**) libp->para[1].ref : *(THit**) (&G__Mlong(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_pairlEintcOTHitmUgR);
   return(1 || funcname || hash || result7 || libp) ;
}

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

{
   pair<int,THit*>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new pair<int,THit*>(*(pair<int,THit*>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_pairlEintcOTHitmUgR);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__TBenchDict_583_2_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSTLhitStarMultiMap* p = NULL;
   long gvp = G__getgvp();
   //m: 1
   if ((gvp == G__PVOID) || (gvp == 0)) {
     p = new TSTLhitStarMultiMap((int) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TSTLhitStarMultiMap((int) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMultiMap);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__TBenchDict_583_5_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitStarMultiMap*) G__getstructoffset())->MakeTree((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
, *(float*) G__Floatref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TBenchDict_583_6_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSTLhitStarMultiMap*) G__getstructoffset())->ReadTree());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__TBenchDict_583_2_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSTLhitStarMultiMap*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref, (char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

{
   TSTLhitStarMultiMap* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TSTLhitStarMultiMap(*(TSTLhitStarMultiMap*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMultiMap);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


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

static int G__TBenchDict_587_2_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TCloneshit* p = NULL;
   long gvp = G__getgvp();
   //m: 1
   if ((gvp == G__PVOID) || (gvp == 0)) {
     p = new TCloneshit((int) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TCloneshit((int) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TCloneshit);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__TBenchDict_587_5_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TCloneshit*) G__getstructoffset())->MakeTree((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
, *(float*) G__Floatref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TBenchDict_587_6_0(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TCloneshit*) G__getstructoffset())->ReadTree());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__TBenchDict_587_2_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TCloneshit*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref, (char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

{
   TCloneshit* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TCloneshit(*(TCloneshit*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TBenchDictLN_TCloneshit);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


/* Setting up global function */

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

/* THit */

/* TObjHit */

/* TSTLhit */

/* TSTLhitList */

/* TSTLhitDeque */

/* TSTLhitMultiset */

/* TSTLhitSet */

/* TSTLhitMap */

/* pair<int,THit> */

/* TSTLhitMultiMap */

/* TSTLhitStar */

/* TSTLhitStarList */

/* TSTLhitStarDeque */

/* TSTLhitStarSet */

/* TSTLhitStarMultiSet */

/* TSTLhitStarMap */

/* pair<int,THit*> */

/* TSTLhitStarMultiMap */

/* TCloneshit */

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

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

size_t G__get_sizep2memfuncTBenchDict()
{
  G__Sizep2memfuncTBenchDict 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_inheritanceTBenchDict() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__TBenchDictLN_TObjHit))) {
     TObjHit *G__Lderived;
     G__Lderived=(TObjHit*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__TBenchDictLN_TObjHit),G__get_linked_tagnum(&G__TBenchDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       THit *G__Lpbase=(THit*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__TBenchDictLN_TObjHit),G__get_linked_tagnum(&G__TBenchDictLN_THit),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
}

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

   /* 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("Version_t",115,-1,0,-1);
   G__setnewtype(-1,"Class version identifier (short)",0);
   G__search_typename2("Option_t",99,-1,256,-1);
   G__setnewtype(-1,"Option string (const char)",0);
   G__search_typename2("vector<TStreamerInfo*>",117,G__get_linked_tagnum(&G__TBenchDictLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__TBenchDictLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__TBenchDictLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__TBenchDictLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__TBenchDictLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<THit>",117,G__get_linked_tagnum(&G__TBenchDictLN_vectorlETHitcOallocatorlETHitgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__TBenchDictLN_reverse_iteratorlEvectorlETHitcOallocatorlETHitgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__TBenchDictLN_vectorlETHitcOallocatorlETHitgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__TBenchDictLN_reverse_iteratorlEvectorlETHitcOallocatorlETHitgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__TBenchDictLN_vectorlETHitcOallocatorlETHitgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<THit>",117,G__get_linked_tagnum(&G__TBenchDictLN_listlETHitcOallocatorlETHitgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("deque<THit>",117,G__get_linked_tagnum(&G__TBenchDictLN_dequelETHitcOallocatorlETHitgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("multiset<THit>",117,G__get_linked_tagnum(&G__TBenchDictLN_multisetlETHitcOlesslETHitgRcOallocatorlETHitgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("multiset<THit,less<THit>>",117,G__get_linked_tagnum(&G__TBenchDictLN_multisetlETHitcOlesslETHitgRcOallocatorlETHitgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<THit>",117,G__get_linked_tagnum(&G__TBenchDictLN_setlETHitcOlesslETHitgRcOallocatorlETHitgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<THit,less<THit>>",117,G__get_linked_tagnum(&G__TBenchDictLN_setlETHitcOlesslETHitgRcOallocatorlETHitgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,THit>",117,G__get_linked_tagnum(&G__TBenchDictLN_maplEintcOTHitcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,THit,less<int>>",117,G__get_linked_tagnum(&G__TBenchDictLN_maplEintcOTHitcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("multimap<int,THit>",117,G__get_linked_tagnum(&G__TBenchDictLN_multimaplEintcOTHitcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("multimap<int,THit,less<int>>",117,G__get_linked_tagnum(&G__TBenchDictLN_multimaplEintcOTHitcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<THit*>",117,G__get_linked_tagnum(&G__TBenchDictLN_vectorlETHitmUcOallocatorlETHitmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__TBenchDictLN_reverse_iteratorlEvectorlETHitmUcOallocatorlETHitmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__TBenchDictLN_vectorlETHitmUcOallocatorlETHitmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__TBenchDictLN_reverse_iteratorlEvectorlETHitmUcOallocatorlETHitmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__TBenchDictLN_vectorlETHitmUcOallocatorlETHitmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<THit*>",117,G__get_linked_tagnum(&G__TBenchDictLN_listlETHitmUcOallocatorlETHitmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("deque<THit*>",117,G__get_linked_tagnum(&G__TBenchDictLN_dequelETHitmUcOallocatorlETHitmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<THit*>",117,G__get_linked_tagnum(&G__TBenchDictLN_setlETHitmUcOlesslETHitmUgRcOallocatorlETHitmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<THit*,less<THit*>>",117,G__get_linked_tagnum(&G__TBenchDictLN_setlETHitmUcOlesslETHitmUgRcOallocatorlETHitmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("multiset<THit*>",117,G__get_linked_tagnum(&G__TBenchDictLN_multisetlETHitmUcOlesslETHitmUgRcOallocatorlETHitmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("multiset<THit*,less<THit*>>",117,G__get_linked_tagnum(&G__TBenchDictLN_multisetlETHitmUcOlesslETHitmUgRcOallocatorlETHitmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,THit*>",117,G__get_linked_tagnum(&G__TBenchDictLN_maplEintcOTHitmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,THit*,less<int>>",117,G__get_linked_tagnum(&G__TBenchDictLN_maplEintcOTHitmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("multimap<int,THit*>",117,G__get_linked_tagnum(&G__TBenchDictLN_multimaplEintcOTHitmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("multimap<int,THit*,less<int>>",117,G__get_linked_tagnum(&G__TBenchDictLN_multimaplEintcOTHitmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
}

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

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

   /* THit */
static void G__setup_memvarTHit(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TBenchDictLN_THit));
   { THit *p; p=(THit*)0x1000; if (p) { }
   G__memvar_setup((void*)NULL,102,0,0,-1,-1,-1,2,"fX=",0,"x position at center");
   G__memvar_setup((void*)NULL,102,0,0,-1,-1,-1,2,"fY=",0,"y position at center");
   G__memvar_setup((void*)NULL,102,0,0,-1,-1,-1,2,"fZ=",0,"z position at center");
   G__memvar_setup((void*)NULL,105,0,0,-1,-1,-1,2,"fNpulses=",0,"Number of pulses");
   G__memvar_setup((void*)NULL,73,0,0,-1,-1,-1,2,"fPulses=",0,"[fNpulses]");
   G__memvar_setup((void*)NULL,105,0,0,-1,-1,-1,2,"fTime[10]=",0,"time at the 10 layers");
   G__memvar_setup((void*)NULL,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__TBenchDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TObjHit */
static void G__setup_memvarTObjHit(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TBenchDictLN_TObjHit));
   { TObjHit *p; p=(TObjHit*)0x1000; if (p) { }
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__TBenchDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSTLhit */
static void G__setup_memvarTSTLhit(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhit));
   { TSTLhit *p; p=(TSTLhit*)0x1000; if (p) { }
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNhits=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__TBenchDictLN_vectorlETHitcOallocatorlETHitgRsPgR),G__defined_typename("vector<THit>"),-1,2,"fList1=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__TBenchDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSTLhitList */
static void G__setup_memvarTSTLhitList(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitList));
   { TSTLhitList *p; p=(TSTLhitList*)0x1000; if (p) { }
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNhits=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__TBenchDictLN_listlETHitcOallocatorlETHitgRsPgR),G__defined_typename("list<THit>"),-1,2,"fList1=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__TBenchDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSTLhitDeque */
static void G__setup_memvarTSTLhitDeque(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitDeque));
   { TSTLhitDeque *p; p=(TSTLhitDeque*)0x1000; if (p) { }
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNhits=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__TBenchDictLN_dequelETHitcOallocatorlETHitgRsPgR),G__defined_typename("deque<THit>"),-1,2,"fList1=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__TBenchDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSTLhitMultiset */
static void G__setup_memvarTSTLhitMultiset(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMultiset));
   { TSTLhitMultiset *p; p=(TSTLhitMultiset*)0x1000; if (p) { }
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNhits=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__TBenchDictLN_multisetlETHitcOlesslETHitgRcOallocatorlETHitgRsPgR),G__defined_typename("multiset<THit>"),-1,2,"fList1=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__TBenchDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSTLhitSet */
static void G__setup_memvarTSTLhitSet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitSet));
   { TSTLhitSet *p; p=(TSTLhitSet*)0x1000; if (p) { }
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNhits=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__TBenchDictLN_setlETHitcOlesslETHitgRcOallocatorlETHitgRsPgR),G__defined_typename("set<THit>"),-1,2,"fList1=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__TBenchDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSTLhitMap */
static void G__setup_memvarTSTLhitMap(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMap));
   { TSTLhitMap *p; p=(TSTLhitMap*)0x1000; if (p) { }
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNhits=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__TBenchDictLN_maplEintcOTHitcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitgRsPgRsPgR),G__defined_typename("map<int,THit>"),-1,2,"fList1=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__TBenchDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* pair<int,THit> */
static void G__setup_memvarpairlEintcOTHitgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TBenchDictLN_pairlEintcOTHitgR));
   { pair<int,THit> *p; p=(pair<int,THit>*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->first)-(long)(p)),105,0,0,-1,-1,-1,1,"first=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->second)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__TBenchDictLN_THit),-1,-1,1,"second=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSTLhitMultiMap */
static void G__setup_memvarTSTLhitMultiMap(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMultiMap));
   { TSTLhitMultiMap *p; p=(TSTLhitMultiMap*)0x1000; if (p) { }
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNhits=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__TBenchDictLN_multimaplEintcOTHitcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitgRsPgRsPgR),G__defined_typename("multimap<int,THit>"),-1,2,"fList1=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__TBenchDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSTLhitStar */
static void G__setup_memvarTSTLhitStar(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStar));
   { TSTLhitStar *p; p=(TSTLhitStar*)0x1000; if (p) { }
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNhits=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__TBenchDictLN_vectorlETHitmUcOallocatorlETHitmUgRsPgR),G__defined_typename("vector<THit*>"),-1,2,"fList2=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__TBenchDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSTLhitStarList */
static void G__setup_memvarTSTLhitStarList(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarList));
   { TSTLhitStarList *p; p=(TSTLhitStarList*)0x1000; if (p) { }
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNhits=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__TBenchDictLN_listlETHitmUcOallocatorlETHitmUgRsPgR),G__defined_typename("list<THit*>"),-1,2,"fList2=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__TBenchDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSTLhitStarDeque */
static void G__setup_memvarTSTLhitStarDeque(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarDeque));
   { TSTLhitStarDeque *p; p=(TSTLhitStarDeque*)0x1000; if (p) { }
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNhits=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__TBenchDictLN_dequelETHitmUcOallocatorlETHitmUgRsPgR),G__defined_typename("deque<THit*>"),-1,2,"fList2=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__TBenchDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSTLhitStarSet */
static void G__setup_memvarTSTLhitStarSet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarSet));
   { TSTLhitStarSet *p; p=(TSTLhitStarSet*)0x1000; if (p) { }
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNhits=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__TBenchDictLN_setlETHitmUcOlesslETHitmUgRcOallocatorlETHitmUgRsPgR),G__defined_typename("set<THit*>"),-1,2,"fList2=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__TBenchDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSTLhitStarMultiSet */
static void G__setup_memvarTSTLhitStarMultiSet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMultiSet));
   { TSTLhitStarMultiSet *p; p=(TSTLhitStarMultiSet*)0x1000; if (p) { }
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNhits=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__TBenchDictLN_multisetlETHitmUcOlesslETHitmUgRcOallocatorlETHitmUgRsPgR),G__defined_typename("multiset<THit*>"),-1,2,"fList2=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__TBenchDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSTLhitStarMap */
static void G__setup_memvarTSTLhitStarMap(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMap));
   { TSTLhitStarMap *p; p=(TSTLhitStarMap*)0x1000; if (p) { }
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNhits=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__TBenchDictLN_maplEintcOTHitmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitmUgRsPgRsPgR),G__defined_typename("map<int,THit*>"),-1,2,"fList2=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__TBenchDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* pair<int,THit*> */
static void G__setup_memvarpairlEintcOTHitmUgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TBenchDictLN_pairlEintcOTHitmUgR));
   { pair<int,THit*> *p; p=(pair<int,THit*>*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->first)-(long)(p)),105,0,0,-1,-1,-1,1,"first=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->second)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__TBenchDictLN_THit),-1,-1,1,"second=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSTLhitStarMultiMap */
static void G__setup_memvarTSTLhitStarMultiMap(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMultiMap));
   { TSTLhitStarMultiMap *p; p=(TSTLhitStarMultiMap*)0x1000; if (p) { }
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNhits=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__TBenchDictLN_multimaplEintcOTHitmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitmUgRsPgRsPgR),G__defined_typename("multimap<int,THit*>"),-1,2,"fList2=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__TBenchDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TCloneshit */
static void G__setup_memvarTCloneshit(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TBenchDictLN_TCloneshit));
   { TCloneshit *p; p=(TCloneshit*)0x1000; if (p) { }
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNhits=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__TBenchDictLN_TClonesArray),-1,-1,2,"fList3=",0,"->");
   G__memvar_setup((void*)NULL,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__TBenchDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

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

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTHit(void) {
   /* THit */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TBenchDictLN_THit));
   G__memfunc_setup("THit",377,G__TBenchDict_513_1_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_THit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THit",377,G__TBenchDict_513_2_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_THit), -1, 0, 1, 1, 1, 0, "u 'THit' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THit",377,G__TBenchDict_513_3_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_THit), -1, 0, 1, 1, 1, 0, "i - - 0 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__TBenchDict_513_4_0, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get",288,G__TBenchDict_513_5_0, 105, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__TBenchDict_513_6_0, 103, -1, -1, 0, 1, 1, 1, 8, "u 'THit' - 11 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator<",936,G__TBenchDict_513_7_0, 103, -1, -1, 0, 1, 1, 1, 8, "u 'THit' - 11 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__TBenchDict_513_8_0, 117, G__get_linked_tagnum(&G__TBenchDictLN_THit), -1, 1, 1, 1, 1, 0, "u 'THit' - 11 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__TBenchDict_513_9_0, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (TClass* (*)())(&THit::Class), 0);
   G__memfunc_setup("Class_Name",982,G__TBenchDict_513_0_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&THit::Class_Name), 0);
   G__memfunc_setup("Class_Version",1339,G__TBenchDict_513_1_1, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (Version_t (*)())(&THit::Class_Version), 0);
   G__memfunc_setup("Dictionary",1046,G__TBenchDict_513_2_1, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (void (*)())(&THit::Dictionary), 0);
   G__memfunc_setup("IsA",253,G__TBenchDict_513_3_1, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__TBenchDict_513_4_1, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__TBenchDict_513_5_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__TBenchDict_513_6_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__TBenchDict_513_7_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&THit::DeclFileName), 0);
   G__memfunc_setup("ImplFileLine",1178,G__TBenchDict_513_8_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&THit::ImplFileLine), 0);
   G__memfunc_setup("ImplFileName",1171,G__TBenchDict_513_9_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&THit::ImplFileName), 0);
   G__memfunc_setup("DeclFileLine",1152,G__TBenchDict_513_0_2, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&THit::DeclFileLine), 0);
   // automatic destructor
   G__memfunc_setup("~THit", 503, G__TBenchDict_513_1_2, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTObjHit(void) {
   /* TObjHit */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TBenchDictLN_TObjHit));
   G__memfunc_setup("TObjHit",660,G__TBenchDict_514_1_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TObjHit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TObjHit",660,G__TBenchDict_514_2_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TObjHit), -1, 0, 1, 1, 1, 0, "i - - 0 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__TBenchDict_514_3_0, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (TClass* (*)())(&TObjHit::Class), 0);
   G__memfunc_setup("Class_Name",982,G__TBenchDict_514_4_0, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TObjHit::Class_Name), 0);
   G__memfunc_setup("Class_Version",1339,G__TBenchDict_514_5_0, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (Version_t (*)())(&TObjHit::Class_Version), 0);
   G__memfunc_setup("Dictionary",1046,G__TBenchDict_514_6_0, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (void (*)())(&TObjHit::Dictionary), 0);
   G__memfunc_setup("IsA",253,G__TBenchDict_514_7_0, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__TBenchDict_514_8_0, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__TBenchDict_514_9_0, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__TBenchDict_514_0_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__TBenchDict_514_1_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TObjHit::DeclFileName), 0);
   G__memfunc_setup("ImplFileLine",1178,G__TBenchDict_514_2_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TObjHit::ImplFileLine), 0);
   G__memfunc_setup("ImplFileName",1171,G__TBenchDict_514_3_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TObjHit::ImplFileName), 0);
   G__memfunc_setup("DeclFileLine",1152,G__TBenchDict_514_4_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TObjHit::DeclFileLine), 0);
   // automatic copy constructor
   G__memfunc_setup("TObjHit", 660, G__TBenchDict_514_5_1, (int) ('i'), G__get_linked_tagnum(&G__TBenchDictLN_TObjHit), -1, 0, 1, 1, 1, 0, "u 'TObjHit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TObjHit", 786, G__TBenchDict_514_6_1, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__TBenchDict_514_7_1, (int) ('u'), G__get_linked_tagnum(&G__TBenchDictLN_TObjHit), -1, 1, 1, 1, 1, 0, "u 'TObjHit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSTLhit(void) {
   /* TSTLhit */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhit));
   G__memfunc_setup("TSTLhit",652,G__TBenchDict_515_1_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSTLhit",652,G__TBenchDict_515_2_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhit), -1, 0, 1, 1, 1, 0, "i - - 0 - nmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__TBenchDict_515_3_0, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 \"\" option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeEvent",896,G__TBenchDict_515_4_0, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - ievent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTree",782,G__TBenchDict_515_5_0, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"i - - 0 - mode i - - 0 - nevents "
"i - - 0 - compression i - - 0 - split "
"f - - 1 - cx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadTree",780,G__TBenchDict_515_6_0, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__TBenchDict_515_7_0, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (TClass* (*)())(&TSTLhit::Class), 0);
   G__memfunc_setup("Class_Name",982,G__TBenchDict_515_8_0, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhit::Class_Name), 0);
   G__memfunc_setup("Class_Version",1339,G__TBenchDict_515_9_0, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (Version_t (*)())(&TSTLhit::Class_Version), 0);
   G__memfunc_setup("Dictionary",1046,G__TBenchDict_515_0_1, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (void (*)())(&TSTLhit::Dictionary), 0);
   G__memfunc_setup("IsA",253,G__TBenchDict_515_1_1, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__TBenchDict_515_2_1, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__TBenchDict_515_3_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__TBenchDict_515_4_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__TBenchDict_515_5_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhit::DeclFileName), 0);
   G__memfunc_setup("ImplFileLine",1178,G__TBenchDict_515_6_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhit::ImplFileLine), 0);
   G__memfunc_setup("ImplFileName",1171,G__TBenchDict_515_7_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhit::ImplFileName), 0);
   G__memfunc_setup("DeclFileLine",1152,G__TBenchDict_515_8_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhit::DeclFileLine), 0);
   // automatic copy constructor
   G__memfunc_setup("TSTLhit", 652, G__TBenchDict_515_9_1, (int) ('i'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhit), -1, 0, 1, 1, 1, 0, "u 'TSTLhit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSTLhit", 778, G__TBenchDict_515_0_2, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__TBenchDict_515_1_2, (int) ('u'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhit), -1, 1, 1, 1, 1, 0, "u 'TSTLhit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSTLhitList(void) {
   /* TSTLhitList */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitList));
   G__memfunc_setup("TSTLhitList",1064,G__TBenchDict_520_1_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSTLhitList",1064,G__TBenchDict_520_2_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitList), -1, 0, 1, 1, 1, 0, "i - - 0 - nmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__TBenchDict_520_3_0, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 \"\" option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeEvent",896,G__TBenchDict_520_4_0, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - ievent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTree",782,G__TBenchDict_520_5_0, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"i - - 0 - mode i - - 0 - nevents "
"i - - 0 - compression i - - 0 - split "
"f - - 1 - cx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadTree",780,G__TBenchDict_520_6_0, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__TBenchDict_520_7_0, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (TClass* (*)())(&TSTLhitList::Class), 0);
   G__memfunc_setup("Class_Name",982,G__TBenchDict_520_8_0, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitList::Class_Name), 0);
   G__memfunc_setup("Class_Version",1339,G__TBenchDict_520_9_0, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (Version_t (*)())(&TSTLhitList::Class_Version), 0);
   G__memfunc_setup("Dictionary",1046,G__TBenchDict_520_0_1, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (void (*)())(&TSTLhitList::Dictionary), 0);
   G__memfunc_setup("IsA",253,G__TBenchDict_520_1_1, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__TBenchDict_520_2_1, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__TBenchDict_520_3_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__TBenchDict_520_4_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__TBenchDict_520_5_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitList::DeclFileName), 0);
   G__memfunc_setup("ImplFileLine",1178,G__TBenchDict_520_6_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitList::ImplFileLine), 0);
   G__memfunc_setup("ImplFileName",1171,G__TBenchDict_520_7_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitList::ImplFileName), 0);
   G__memfunc_setup("DeclFileLine",1152,G__TBenchDict_520_8_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitList::DeclFileLine), 0);
   // automatic copy constructor
   G__memfunc_setup("TSTLhitList", 1064, G__TBenchDict_520_9_1, (int) ('i'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitList), -1, 0, 1, 1, 1, 0, "u 'TSTLhitList' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSTLhitList", 1190, G__TBenchDict_520_0_2, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__TBenchDict_520_1_2, (int) ('u'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitList), -1, 1, 1, 1, 1, 0, "u 'TSTLhitList' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSTLhitDeque(void) {
   /* TSTLhitDeque */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitDeque));
   G__memfunc_setup("TSTLhitDeque",1152,G__TBenchDict_524_1_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitDeque), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSTLhitDeque",1152,G__TBenchDict_524_2_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitDeque), -1, 0, 1, 1, 1, 0, "i - - 0 - nmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__TBenchDict_524_3_0, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 \"\" option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeEvent",896,G__TBenchDict_524_4_0, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - ievent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTree",782,G__TBenchDict_524_5_0, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"i - - 0 - mode i - - 0 - nevents "
"i - - 0 - compression i - - 0 - split "
"f - - 1 - cx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadTree",780,G__TBenchDict_524_6_0, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__TBenchDict_524_7_0, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (TClass* (*)())(&TSTLhitDeque::Class), 0);
   G__memfunc_setup("Class_Name",982,G__TBenchDict_524_8_0, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitDeque::Class_Name), 0);
   G__memfunc_setup("Class_Version",1339,G__TBenchDict_524_9_0, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (Version_t (*)())(&TSTLhitDeque::Class_Version), 0);
   G__memfunc_setup("Dictionary",1046,G__TBenchDict_524_0_1, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (void (*)())(&TSTLhitDeque::Dictionary), 0);
   G__memfunc_setup("IsA",253,G__TBenchDict_524_1_1, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__TBenchDict_524_2_1, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__TBenchDict_524_3_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__TBenchDict_524_4_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__TBenchDict_524_5_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitDeque::DeclFileName), 0);
   G__memfunc_setup("ImplFileLine",1178,G__TBenchDict_524_6_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitDeque::ImplFileLine), 0);
   G__memfunc_setup("ImplFileName",1171,G__TBenchDict_524_7_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitDeque::ImplFileName), 0);
   G__memfunc_setup("DeclFileLine",1152,G__TBenchDict_524_8_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitDeque::DeclFileLine), 0);
   // automatic copy constructor
   G__memfunc_setup("TSTLhitDeque", 1152, G__TBenchDict_524_9_1, (int) ('i'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitDeque), -1, 0, 1, 1, 1, 0, "u 'TSTLhitDeque' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSTLhitDeque", 1278, G__TBenchDict_524_0_2, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__TBenchDict_524_1_2, (int) ('u'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitDeque), -1, 1, 1, 1, 1, 0, "u 'TSTLhitDeque' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSTLhitMultiset(void) {
   /* TSTLhitMultiset */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMultiset));
   G__memfunc_setup("TSTLhitMultiset",1507,G__TBenchDict_528_1_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMultiset), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSTLhitMultiset",1507,G__TBenchDict_528_2_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMultiset), -1, 0, 1, 1, 1, 0, "i - - 0 - nmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__TBenchDict_528_3_0, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 \"\" option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeEvent",896,G__TBenchDict_528_4_0, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - ievent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTree",782,G__TBenchDict_528_5_0, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"i - - 0 - mode i - - 0 - nevents "
"i - - 0 - compression i - - 0 - split "
"f - - 1 - cx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadTree",780,G__TBenchDict_528_6_0, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__TBenchDict_528_7_0, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (TClass* (*)())(&TSTLhitMultiset::Class), 0);
   G__memfunc_setup("Class_Name",982,G__TBenchDict_528_8_0, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitMultiset::Class_Name), 0);
   G__memfunc_setup("Class_Version",1339,G__TBenchDict_528_9_0, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (Version_t (*)())(&TSTLhitMultiset::Class_Version), 0);
   G__memfunc_setup("Dictionary",1046,G__TBenchDict_528_0_1, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (void (*)())(&TSTLhitMultiset::Dictionary), 0);
   G__memfunc_setup("IsA",253,G__TBenchDict_528_1_1, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__TBenchDict_528_2_1, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__TBenchDict_528_3_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__TBenchDict_528_4_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__TBenchDict_528_5_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitMultiset::DeclFileName), 0);
   G__memfunc_setup("ImplFileLine",1178,G__TBenchDict_528_6_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitMultiset::ImplFileLine), 0);
   G__memfunc_setup("ImplFileName",1171,G__TBenchDict_528_7_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitMultiset::ImplFileName), 0);
   G__memfunc_setup("DeclFileLine",1152,G__TBenchDict_528_8_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitMultiset::DeclFileLine), 0);
   // automatic copy constructor
   G__memfunc_setup("TSTLhitMultiset", 1507, G__TBenchDict_528_9_1, (int) ('i'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMultiset), -1, 0, 1, 1, 1, 0, "u 'TSTLhitMultiset' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSTLhitMultiset", 1633, G__TBenchDict_528_0_2, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__TBenchDict_528_1_2, (int) ('u'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMultiset), -1, 1, 1, 1, 1, 0, "u 'TSTLhitMultiset' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSTLhitSet(void) {
   /* TSTLhitSet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitSet));
   G__memfunc_setup("TSTLhitSet",952,G__TBenchDict_534_1_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitSet), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSTLhitSet",952,G__TBenchDict_534_2_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitSet), -1, 0, 1, 1, 1, 0, "i - - 0 - nmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__TBenchDict_534_3_0, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 \"\" option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeEvent",896,G__TBenchDict_534_4_0, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - ievent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTree",782,G__TBenchDict_534_5_0, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"i - - 0 - mode i - - 0 - nevents "
"i - - 0 - compression i - - 0 - split "
"f - - 1 - cx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadTree",780,G__TBenchDict_534_6_0, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__TBenchDict_534_7_0, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (TClass* (*)())(&TSTLhitSet::Class), 0);
   G__memfunc_setup("Class_Name",982,G__TBenchDict_534_8_0, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitSet::Class_Name), 0);
   G__memfunc_setup("Class_Version",1339,G__TBenchDict_534_9_0, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (Version_t (*)())(&TSTLhitSet::Class_Version), 0);
   G__memfunc_setup("Dictionary",1046,G__TBenchDict_534_0_1, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (void (*)())(&TSTLhitSet::Dictionary), 0);
   G__memfunc_setup("IsA",253,G__TBenchDict_534_1_1, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__TBenchDict_534_2_1, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__TBenchDict_534_3_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__TBenchDict_534_4_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__TBenchDict_534_5_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitSet::DeclFileName), 0);
   G__memfunc_setup("ImplFileLine",1178,G__TBenchDict_534_6_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitSet::ImplFileLine), 0);
   G__memfunc_setup("ImplFileName",1171,G__TBenchDict_534_7_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitSet::ImplFileName), 0);
   G__memfunc_setup("DeclFileLine",1152,G__TBenchDict_534_8_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitSet::DeclFileLine), 0);
   // automatic copy constructor
   G__memfunc_setup("TSTLhitSet", 952, G__TBenchDict_534_9_1, (int) ('i'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitSet), -1, 0, 1, 1, 1, 0, "u 'TSTLhitSet' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSTLhitSet", 1078, G__TBenchDict_534_0_2, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__TBenchDict_534_1_2, (int) ('u'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitSet), -1, 1, 1, 1, 1, 0, "u 'TSTLhitSet' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSTLhitMap(void) {
   /* TSTLhitMap */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMap));
   G__memfunc_setup("TSTLhitMap",938,G__TBenchDict_539_1_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMap), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSTLhitMap",938,G__TBenchDict_539_2_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMap), -1, 0, 1, 1, 1, 0, "i - - 0 - nmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__TBenchDict_539_3_0, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 \"\" option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeEvent",896,G__TBenchDict_539_4_0, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - ievent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTree",782,G__TBenchDict_539_5_0, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"i - - 0 - mode i - - 0 - nevents "
"i - - 0 - compression i - - 0 - split "
"f - - 1 - cx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadTree",780,G__TBenchDict_539_6_0, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__TBenchDict_539_7_0, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (TClass* (*)())(&TSTLhitMap::Class), 0);
   G__memfunc_setup("Class_Name",982,G__TBenchDict_539_8_0, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitMap::Class_Name), 0);
   G__memfunc_setup("Class_Version",1339,G__TBenchDict_539_9_0, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (Version_t (*)())(&TSTLhitMap::Class_Version), 0);
   G__memfunc_setup("Dictionary",1046,G__TBenchDict_539_0_1, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (void (*)())(&TSTLhitMap::Dictionary), 0);
   G__memfunc_setup("IsA",253,G__TBenchDict_539_1_1, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__TBenchDict_539_2_1, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__TBenchDict_539_3_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__TBenchDict_539_4_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__TBenchDict_539_5_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitMap::DeclFileName), 0);
   G__memfunc_setup("ImplFileLine",1178,G__TBenchDict_539_6_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitMap::ImplFileLine), 0);
   G__memfunc_setup("ImplFileName",1171,G__TBenchDict_539_7_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitMap::ImplFileName), 0);
   G__memfunc_setup("DeclFileLine",1152,G__TBenchDict_539_8_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitMap::DeclFileLine), 0);
   // automatic copy constructor
   G__memfunc_setup("TSTLhitMap", 938, G__TBenchDict_539_9_1, (int) ('i'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMap), -1, 0, 1, 1, 1, 0, "u 'TSTLhitMap' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSTLhitMap", 1064, G__TBenchDict_539_0_2, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__TBenchDict_539_1_2, (int) ('u'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMap), -1, 1, 1, 1, 1, 0, "u 'TSTLhitMap' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncpairlEintcOTHitgR(void) {
   /* pair<int,THit> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TBenchDictLN_pairlEintcOTHitgR));
   G__memfunc_setup("pair<int,THit>",1302,G__TBenchDict_543_1_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_pairlEintcOTHitgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pair<int,THit>",1302,G__TBenchDict_543_2_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_pairlEintcOTHitgR), -1, 0, 2, 1, 1, 0, 
"i - - 11 - a u 'THit' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__TBenchDictLN_pairlEintcOTHitgR), -1, 1, 1, 1, 4, 0, "u 'pair<int,THit>' - 11 - x", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("pair<int,THit>", 1302, G__TBenchDict_543_4_0, (int) ('i'), G__get_linked_tagnum(&G__TBenchDictLN_pairlEintcOTHitgR), -1, 0, 1, 1, 1, 0, "u 'pair<int,THit>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~pair<int,THit>", 1428, G__TBenchDict_543_5_0, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSTLhitMultiMap(void) {
   /* TSTLhitMultiMap */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMultiMap));
   G__memfunc_setup("TSTLhitMultiMap",1461,G__TBenchDict_547_1_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMultiMap), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSTLhitMultiMap",1461,G__TBenchDict_547_2_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMultiMap), -1, 0, 1, 1, 1, 0, "i - - 0 - nmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__TBenchDict_547_3_0, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 \"\" option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeEvent",896,G__TBenchDict_547_4_0, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - ievent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTree",782,G__TBenchDict_547_5_0, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"i - - 0 - mode i - - 0 - nevents "
"i - - 0 - compression i - - 0 - split "
"f - - 1 - cx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadTree",780,G__TBenchDict_547_6_0, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__TBenchDict_547_7_0, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (TClass* (*)())(&TSTLhitMultiMap::Class), 0);
   G__memfunc_setup("Class_Name",982,G__TBenchDict_547_8_0, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitMultiMap::Class_Name), 0);
   G__memfunc_setup("Class_Version",1339,G__TBenchDict_547_9_0, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (Version_t (*)())(&TSTLhitMultiMap::Class_Version), 0);
   G__memfunc_setup("Dictionary",1046,G__TBenchDict_547_0_1, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (void (*)())(&TSTLhitMultiMap::Dictionary), 0);
   G__memfunc_setup("IsA",253,G__TBenchDict_547_1_1, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__TBenchDict_547_2_1, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__TBenchDict_547_3_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__TBenchDict_547_4_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__TBenchDict_547_5_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitMultiMap::DeclFileName), 0);
   G__memfunc_setup("ImplFileLine",1178,G__TBenchDict_547_6_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitMultiMap::ImplFileLine), 0);
   G__memfunc_setup("ImplFileName",1171,G__TBenchDict_547_7_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitMultiMap::ImplFileName), 0);
   G__memfunc_setup("DeclFileLine",1152,G__TBenchDict_547_8_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitMultiMap::DeclFileLine), 0);
   // automatic copy constructor
   G__memfunc_setup("TSTLhitMultiMap", 1461, G__TBenchDict_547_9_1, (int) ('i'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMultiMap), -1, 0, 1, 1, 1, 0, "u 'TSTLhitMultiMap' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSTLhitMultiMap", 1587, G__TBenchDict_547_0_2, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__TBenchDict_547_1_2, (int) ('u'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMultiMap), -1, 1, 1, 1, 1, 0, "u 'TSTLhitMultiMap' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSTLhitStar(void) {
   /* TSTLhitStar */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStar));
   G__memfunc_setup("TSTLhitStar",1062,G__TBenchDict_551_1_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStar), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSTLhitStar",1062,G__TBenchDict_551_2_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStar), -1, 0, 1, 1, 1, 0, "i - - 0 - nmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__TBenchDict_551_3_0, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 \"\" option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeEvent",896,G__TBenchDict_551_4_0, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - ievent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTree",782,G__TBenchDict_551_5_0, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"i - - 0 - mode i - - 0 - nevents "
"i - - 0 - compression i - - 0 - split "
"f - - 1 - cx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadTree",780,G__TBenchDict_551_6_0, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__TBenchDict_551_7_0, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (TClass* (*)())(&TSTLhitStar::Class), 0);
   G__memfunc_setup("Class_Name",982,G__TBenchDict_551_8_0, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitStar::Class_Name), 0);
   G__memfunc_setup("Class_Version",1339,G__TBenchDict_551_9_0, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (Version_t (*)())(&TSTLhitStar::Class_Version), 0);
   G__memfunc_setup("Dictionary",1046,G__TBenchDict_551_0_1, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (void (*)())(&TSTLhitStar::Dictionary), 0);
   G__memfunc_setup("IsA",253,G__TBenchDict_551_1_1, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__TBenchDict_551_2_1, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__TBenchDict_551_3_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__TBenchDict_551_4_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__TBenchDict_551_5_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitStar::DeclFileName), 0);
   G__memfunc_setup("ImplFileLine",1178,G__TBenchDict_551_6_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitStar::ImplFileLine), 0);
   G__memfunc_setup("ImplFileName",1171,G__TBenchDict_551_7_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitStar::ImplFileName), 0);
   G__memfunc_setup("DeclFileLine",1152,G__TBenchDict_551_8_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitStar::DeclFileLine), 0);
   // automatic copy constructor
   G__memfunc_setup("TSTLhitStar", 1062, G__TBenchDict_551_9_1, (int) ('i'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStar), -1, 0, 1, 1, 1, 0, "u 'TSTLhitStar' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSTLhitStar", 1188, G__TBenchDict_551_0_2, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__TBenchDict_551_1_2, (int) ('u'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStar), -1, 1, 1, 1, 1, 0, "u 'TSTLhitStar' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSTLhitStarList(void) {
   /* TSTLhitStarList */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarList));
   G__memfunc_setup("TSTLhitStarList",1474,G__TBenchDict_556_1_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSTLhitStarList",1474,G__TBenchDict_556_2_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarList), -1, 0, 1, 1, 1, 0, "i - - 0 - nmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__TBenchDict_556_3_0, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 \"\" option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeEvent",896,G__TBenchDict_556_4_0, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - ievent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTree",782,G__TBenchDict_556_5_0, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"i - - 0 - mode i - - 0 - nevents "
"i - - 0 - compression i - - 0 - split "
"f - - 1 - cx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadTree",780,G__TBenchDict_556_6_0, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__TBenchDict_556_7_0, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (TClass* (*)())(&TSTLhitStarList::Class), 0);
   G__memfunc_setup("Class_Name",982,G__TBenchDict_556_8_0, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitStarList::Class_Name), 0);
   G__memfunc_setup("Class_Version",1339,G__TBenchDict_556_9_0, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (Version_t (*)())(&TSTLhitStarList::Class_Version), 0);
   G__memfunc_setup("Dictionary",1046,G__TBenchDict_556_0_1, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (void (*)())(&TSTLhitStarList::Dictionary), 0);
   G__memfunc_setup("IsA",253,G__TBenchDict_556_1_1, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__TBenchDict_556_2_1, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__TBenchDict_556_3_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__TBenchDict_556_4_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__TBenchDict_556_5_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitStarList::DeclFileName), 0);
   G__memfunc_setup("ImplFileLine",1178,G__TBenchDict_556_6_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitStarList::ImplFileLine), 0);
   G__memfunc_setup("ImplFileName",1171,G__TBenchDict_556_7_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitStarList::ImplFileName), 0);
   G__memfunc_setup("DeclFileLine",1152,G__TBenchDict_556_8_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitStarList::DeclFileLine), 0);
   // automatic copy constructor
   G__memfunc_setup("TSTLhitStarList", 1474, G__TBenchDict_556_9_1, (int) ('i'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarList), -1, 0, 1, 1, 1, 0, "u 'TSTLhitStarList' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSTLhitStarList", 1600, G__TBenchDict_556_0_2, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__TBenchDict_556_1_2, (int) ('u'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarList), -1, 1, 1, 1, 1, 0, "u 'TSTLhitStarList' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSTLhitStarDeque(void) {
   /* TSTLhitStarDeque */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarDeque));
   G__memfunc_setup("TSTLhitStarDeque",1562,G__TBenchDict_560_1_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarDeque), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSTLhitStarDeque",1562,G__TBenchDict_560_2_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarDeque), -1, 0, 1, 1, 1, 0, "i - - 0 - nmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__TBenchDict_560_3_0, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 \"\" option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeEvent",896,G__TBenchDict_560_4_0, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - ievent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTree",782,G__TBenchDict_560_5_0, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"i - - 0 - mode i - - 0 - nevents "
"i - - 0 - compression i - - 0 - split "
"f - - 1 - cx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadTree",780,G__TBenchDict_560_6_0, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__TBenchDict_560_7_0, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (TClass* (*)())(&TSTLhitStarDeque::Class), 0);
   G__memfunc_setup("Class_Name",982,G__TBenchDict_560_8_0, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitStarDeque::Class_Name), 0);
   G__memfunc_setup("Class_Version",1339,G__TBenchDict_560_9_0, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (Version_t (*)())(&TSTLhitStarDeque::Class_Version), 0);
   G__memfunc_setup("Dictionary",1046,G__TBenchDict_560_0_1, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (void (*)())(&TSTLhitStarDeque::Dictionary), 0);
   G__memfunc_setup("IsA",253,G__TBenchDict_560_1_1, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__TBenchDict_560_2_1, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__TBenchDict_560_3_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__TBenchDict_560_4_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__TBenchDict_560_5_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitStarDeque::DeclFileName), 0);
   G__memfunc_setup("ImplFileLine",1178,G__TBenchDict_560_6_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitStarDeque::ImplFileLine), 0);
   G__memfunc_setup("ImplFileName",1171,G__TBenchDict_560_7_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitStarDeque::ImplFileName), 0);
   G__memfunc_setup("DeclFileLine",1152,G__TBenchDict_560_8_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitStarDeque::DeclFileLine), 0);
   // automatic copy constructor
   G__memfunc_setup("TSTLhitStarDeque", 1562, G__TBenchDict_560_9_1, (int) ('i'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarDeque), -1, 0, 1, 1, 1, 0, "u 'TSTLhitStarDeque' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSTLhitStarDeque", 1688, G__TBenchDict_560_0_2, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__TBenchDict_560_1_2, (int) ('u'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarDeque), -1, 1, 1, 1, 1, 0, "u 'TSTLhitStarDeque' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSTLhitStarSet(void) {
   /* TSTLhitStarSet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarSet));
   G__memfunc_setup("TSTLhitStarSet",1362,G__TBenchDict_564_1_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarSet), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSTLhitStarSet",1362,G__TBenchDict_564_2_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarSet), -1, 0, 1, 1, 1, 0, "i - - 0 - nmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__TBenchDict_564_3_0, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 \"\" option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeEvent",896,G__TBenchDict_564_4_0, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - ievent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTree",782,G__TBenchDict_564_5_0, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"i - - 0 - mode i - - 0 - nevents "
"i - - 0 - compression i - - 0 - split "
"f - - 1 - cx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadTree",780,G__TBenchDict_564_6_0, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__TBenchDict_564_7_0, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (TClass* (*)())(&TSTLhitStarSet::Class), 0);
   G__memfunc_setup("Class_Name",982,G__TBenchDict_564_8_0, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitStarSet::Class_Name), 0);
   G__memfunc_setup("Class_Version",1339,G__TBenchDict_564_9_0, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (Version_t (*)())(&TSTLhitStarSet::Class_Version), 0);
   G__memfunc_setup("Dictionary",1046,G__TBenchDict_564_0_1, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (void (*)())(&TSTLhitStarSet::Dictionary), 0);
   G__memfunc_setup("IsA",253,G__TBenchDict_564_1_1, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__TBenchDict_564_2_1, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__TBenchDict_564_3_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__TBenchDict_564_4_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__TBenchDict_564_5_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitStarSet::DeclFileName), 0);
   G__memfunc_setup("ImplFileLine",1178,G__TBenchDict_564_6_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitStarSet::ImplFileLine), 0);
   G__memfunc_setup("ImplFileName",1171,G__TBenchDict_564_7_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitStarSet::ImplFileName), 0);
   G__memfunc_setup("DeclFileLine",1152,G__TBenchDict_564_8_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitStarSet::DeclFileLine), 0);
   // automatic copy constructor
   G__memfunc_setup("TSTLhitStarSet", 1362, G__TBenchDict_564_9_1, (int) ('i'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarSet), -1, 0, 1, 1, 1, 0, "u 'TSTLhitStarSet' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSTLhitStarSet", 1488, G__TBenchDict_564_0_2, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__TBenchDict_564_1_2, (int) ('u'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarSet), -1, 1, 1, 1, 1, 0, "u 'TSTLhitStarSet' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSTLhitStarMultiSet(void) {
   /* TSTLhitStarMultiSet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMultiSet));
   G__memfunc_setup("TSTLhitStarMultiSet",1885,G__TBenchDict_571_1_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMultiSet), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSTLhitStarMultiSet",1885,G__TBenchDict_571_2_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMultiSet), -1, 0, 1, 1, 1, 0, "i - - 0 - nmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__TBenchDict_571_3_0, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 \"\" option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeEvent",896,G__TBenchDict_571_4_0, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - ievent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTree",782,G__TBenchDict_571_5_0, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"i - - 0 - mode i - - 0 - nevents "
"i - - 0 - compression i - - 0 - split "
"f - - 1 - cx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadTree",780,G__TBenchDict_571_6_0, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__TBenchDict_571_7_0, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (TClass* (*)())(&TSTLhitStarMultiSet::Class), 0);
   G__memfunc_setup("Class_Name",982,G__TBenchDict_571_8_0, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitStarMultiSet::Class_Name), 0);
   G__memfunc_setup("Class_Version",1339,G__TBenchDict_571_9_0, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (Version_t (*)())(&TSTLhitStarMultiSet::Class_Version), 0);
   G__memfunc_setup("Dictionary",1046,G__TBenchDict_571_0_1, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (void (*)())(&TSTLhitStarMultiSet::Dictionary), 0);
   G__memfunc_setup("IsA",253,G__TBenchDict_571_1_1, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__TBenchDict_571_2_1, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__TBenchDict_571_3_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__TBenchDict_571_4_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__TBenchDict_571_5_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitStarMultiSet::DeclFileName), 0);
   G__memfunc_setup("ImplFileLine",1178,G__TBenchDict_571_6_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitStarMultiSet::ImplFileLine), 0);
   G__memfunc_setup("ImplFileName",1171,G__TBenchDict_571_7_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitStarMultiSet::ImplFileName), 0);
   G__memfunc_setup("DeclFileLine",1152,G__TBenchDict_571_8_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitStarMultiSet::DeclFileLine), 0);
   // automatic copy constructor
   G__memfunc_setup("TSTLhitStarMultiSet", 1885, G__TBenchDict_571_9_1, (int) ('i'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMultiSet), -1, 0, 1, 1, 1, 0, "u 'TSTLhitStarMultiSet' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSTLhitStarMultiSet", 2011, G__TBenchDict_571_0_2, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__TBenchDict_571_1_2, (int) ('u'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMultiSet), -1, 1, 1, 1, 1, 0, "u 'TSTLhitStarMultiSet' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSTLhitStarMap(void) {
   /* TSTLhitStarMap */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMap));
   G__memfunc_setup("TSTLhitStarMap",1348,G__TBenchDict_575_1_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMap), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSTLhitStarMap",1348,G__TBenchDict_575_2_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMap), -1, 0, 1, 1, 1, 0, "i - - 0 - nmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__TBenchDict_575_3_0, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 \"\" option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeEvent",896,G__TBenchDict_575_4_0, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - ievent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTree",782,G__TBenchDict_575_5_0, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"i - - 0 - mode i - - 0 - nevents "
"i - - 0 - compression i - - 0 - split "
"f - - 1 - cx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadTree",780,G__TBenchDict_575_6_0, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__TBenchDict_575_7_0, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (TClass* (*)())(&TSTLhitStarMap::Class), 0);
   G__memfunc_setup("Class_Name",982,G__TBenchDict_575_8_0, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitStarMap::Class_Name), 0);
   G__memfunc_setup("Class_Version",1339,G__TBenchDict_575_9_0, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (Version_t (*)())(&TSTLhitStarMap::Class_Version), 0);
   G__memfunc_setup("Dictionary",1046,G__TBenchDict_575_0_1, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (void (*)())(&TSTLhitStarMap::Dictionary), 0);
   G__memfunc_setup("IsA",253,G__TBenchDict_575_1_1, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__TBenchDict_575_2_1, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__TBenchDict_575_3_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__TBenchDict_575_4_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__TBenchDict_575_5_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitStarMap::DeclFileName), 0);
   G__memfunc_setup("ImplFileLine",1178,G__TBenchDict_575_6_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitStarMap::ImplFileLine), 0);
   G__memfunc_setup("ImplFileName",1171,G__TBenchDict_575_7_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitStarMap::ImplFileName), 0);
   G__memfunc_setup("DeclFileLine",1152,G__TBenchDict_575_8_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitStarMap::DeclFileLine), 0);
   // automatic copy constructor
   G__memfunc_setup("TSTLhitStarMap", 1348, G__TBenchDict_575_9_1, (int) ('i'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMap), -1, 0, 1, 1, 1, 0, "u 'TSTLhitStarMap' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSTLhitStarMap", 1474, G__TBenchDict_575_0_2, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__TBenchDict_575_1_2, (int) ('u'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMap), -1, 1, 1, 1, 1, 0, "u 'TSTLhitStarMap' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncpairlEintcOTHitmUgR(void) {
   /* pair<int,THit*> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TBenchDictLN_pairlEintcOTHitmUgR));
   G__memfunc_setup("pair<int,THit*>",1344,G__TBenchDict_579_1_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_pairlEintcOTHitmUgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pair<int,THit*>",1344,G__TBenchDict_579_2_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_pairlEintcOTHitmUgR), -1, 0, 2, 1, 1, 0, 
"i - - 11 - a U 'THit' - 41 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__TBenchDictLN_pairlEintcOTHitmUgR), -1, 1, 1, 1, 4, 0, "u 'pair<int,THit*>' - 11 - x", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("pair<int,THit*>", 1344, G__TBenchDict_579_4_0, (int) ('i'), G__get_linked_tagnum(&G__TBenchDictLN_pairlEintcOTHitmUgR), -1, 0, 1, 1, 1, 0, "u 'pair<int,THit*>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~pair<int,THit*>", 1470, G__TBenchDict_579_5_0, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSTLhitStarMultiMap(void) {
   /* TSTLhitStarMultiMap */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMultiMap));
   G__memfunc_setup("TSTLhitStarMultiMap",1871,G__TBenchDict_583_1_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMultiMap), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSTLhitStarMultiMap",1871,G__TBenchDict_583_2_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMultiMap), -1, 0, 1, 1, 1, 0, "i - - 0 - nmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__TBenchDict_583_3_0, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 \"\" option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeEvent",896,G__TBenchDict_583_4_0, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - ievent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTree",782,G__TBenchDict_583_5_0, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"i - - 0 - mode i - - 0 - nevents "
"i - - 0 - compression i - - 0 - split "
"f - - 1 - cx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadTree",780,G__TBenchDict_583_6_0, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__TBenchDict_583_7_0, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (TClass* (*)())(&TSTLhitStarMultiMap::Class), 0);
   G__memfunc_setup("Class_Name",982,G__TBenchDict_583_8_0, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitStarMultiMap::Class_Name), 0);
   G__memfunc_setup("Class_Version",1339,G__TBenchDict_583_9_0, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (Version_t (*)())(&TSTLhitStarMultiMap::Class_Version), 0);
   G__memfunc_setup("Dictionary",1046,G__TBenchDict_583_0_1, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (void (*)())(&TSTLhitStarMultiMap::Dictionary), 0);
   G__memfunc_setup("IsA",253,G__TBenchDict_583_1_1, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__TBenchDict_583_2_1, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__TBenchDict_583_3_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__TBenchDict_583_4_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__TBenchDict_583_5_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitStarMultiMap::DeclFileName), 0);
   G__memfunc_setup("ImplFileLine",1178,G__TBenchDict_583_6_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitStarMultiMap::ImplFileLine), 0);
   G__memfunc_setup("ImplFileName",1171,G__TBenchDict_583_7_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TSTLhitStarMultiMap::ImplFileName), 0);
   G__memfunc_setup("DeclFileLine",1152,G__TBenchDict_583_8_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TSTLhitStarMultiMap::DeclFileLine), 0);
   // automatic copy constructor
   G__memfunc_setup("TSTLhitStarMultiMap", 1871, G__TBenchDict_583_9_1, (int) ('i'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMultiMap), -1, 0, 1, 1, 1, 0, "u 'TSTLhitStarMultiMap' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSTLhitStarMultiMap", 1997, G__TBenchDict_583_0_2, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__TBenchDict_583_1_2, (int) ('u'), G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMultiMap), -1, 1, 1, 1, 1, 0, "u 'TSTLhitStarMultiMap' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTCloneshit(void) {
   /* TCloneshit */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TBenchDictLN_TCloneshit));
   G__memfunc_setup("TCloneshit",1021,G__TBenchDict_587_1_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TCloneshit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TCloneshit",1021,G__TBenchDict_587_2_0, 105, G__get_linked_tagnum(&G__TBenchDictLN_TCloneshit), -1, 0, 1, 1, 1, 0, "i - - 0 - nmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__TBenchDict_587_3_0, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 \"\" option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeEvent",896,G__TBenchDict_587_4_0, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - ievent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTree",782,G__TBenchDict_587_5_0, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"i - - 0 - mode i - - 0 - nevents "
"i - - 0 - compression i - - 0 - split "
"f - - 1 - cx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadTree",780,G__TBenchDict_587_6_0, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__TBenchDict_587_7_0, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (TClass* (*)())(&TCloneshit::Class), 0);
   G__memfunc_setup("Class_Name",982,G__TBenchDict_587_8_0, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TCloneshit::Class_Name), 0);
   G__memfunc_setup("Class_Version",1339,G__TBenchDict_587_9_0, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (Version_t (*)())(&TCloneshit::Class_Version), 0);
   G__memfunc_setup("Dictionary",1046,G__TBenchDict_587_0_1, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (void (*)())(&TCloneshit::Dictionary), 0);
   G__memfunc_setup("IsA",253,G__TBenchDict_587_1_1, 85, G__get_linked_tagnum(&G__TBenchDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__TBenchDict_587_2_1, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__TBenchDict_587_3_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__TBenchDict_587_4_1, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__TBenchDict_587_5_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TCloneshit::DeclFileName), 0);
   G__memfunc_setup("ImplFileLine",1178,G__TBenchDict_587_6_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TCloneshit::ImplFileLine), 0);
   G__memfunc_setup("ImplFileName",1171,G__TBenchDict_587_7_1, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TCloneshit::ImplFileName), 0);
   G__memfunc_setup("DeclFileLine",1152,G__TBenchDict_587_8_1, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TCloneshit::DeclFileLine), 0);
   // automatic copy constructor
   G__memfunc_setup("TCloneshit", 1021, G__TBenchDict_587_9_1, (int) ('i'), G__get_linked_tagnum(&G__TBenchDictLN_TCloneshit), -1, 0, 1, 1, 1, 0, "u 'TCloneshit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TCloneshit", 1147, G__TBenchDict_587_0_2, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__TBenchDict_587_1_2, (int) ('u'), G__get_linked_tagnum(&G__TBenchDictLN_TCloneshit), -1, 1, 1, 1, 1, 0, "u 'TCloneshit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}


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

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

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

}

static void G__cpp_setup_global1() {

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

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

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {
}

static void G__cpp_setup_func4() {
}

static void G__cpp_setup_func5() {
}

static void G__cpp_setup_func6() {
}

static void G__cpp_setup_func7() {
}

static void G__cpp_setup_func8() {
}

static void G__cpp_setup_func9() {
}

static void G__cpp_setup_func10() {
}

static void G__cpp_setup_func11() {
}

static void G__cpp_setup_func12() {
}

static void G__cpp_setup_func13() {
}

static void G__cpp_setup_func14() {
}

static void G__cpp_setup_func15() {
}

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() {
}

static void G__cpp_setup_func22() {
}

static void G__cpp_setup_func23() {
}

static void G__cpp_setup_func24() {
}

static void G__cpp_setup_func25() {
}

static void G__cpp_setup_func26() {
}

static void G__cpp_setup_func27() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcTBenchDict() {
  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();
  G__cpp_setup_func22();
  G__cpp_setup_func23();
  G__cpp_setup_func24();
  G__cpp_setup_func25();
  G__cpp_setup_func26();
  G__cpp_setup_func27();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__TBenchDictLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR = { "vector<TStreamerInfo*,allocator<TStreamerInfo*> >" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TStreamerInfo*,allocator<TStreamerInfo*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_TClonesArray = { "TClonesArray" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_THit = { "THit" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_TObjHit = { "TObjHit" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_TSTLhit = { "TSTLhit" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_vectorlETHitcOallocatorlETHitgRsPgR = { "vector<THit,allocator<THit> >" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_reverse_iteratorlEvectorlETHitcOallocatorlETHitgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<THit,allocator<THit> >::iterator>" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_TSTLhitList = { "TSTLhitList" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_listlETHitcOallocatorlETHitgRsPgR = { "list<THit,allocator<THit> >" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_TSTLhitDeque = { "TSTLhitDeque" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_dequelETHitcOallocatorlETHitgRsPgR = { "deque<THit,allocator<THit> >" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_TSTLhitMultiset = { "TSTLhitMultiset" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_multisetlETHitcOlesslETHitgRcOallocatorlETHitgRsPgR = { "multiset<THit,less<THit>,allocator<THit> >" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_TSTLhitSet = { "TSTLhitSet" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_setlETHitcOlesslETHitgRcOallocatorlETHitgRsPgR = { "set<THit,less<THit>,allocator<THit> >" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_TSTLhitMap = { "TSTLhitMap" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_maplEintcOTHitcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitgRsPgRsPgR = { "map<int,THit,less<int>,allocator<pair<const int,THit> > >" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_pairlEintcOTHitgR = { "pair<int,THit>" , 115 , -1 };
G__linked_taginfo G__TBenchDictLN_TSTLhitMultiMap = { "TSTLhitMultiMap" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_multimaplEintcOTHitcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitgRsPgRsPgR = { "multimap<int,THit,less<int>,allocator<pair<const int,THit> > >" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_TSTLhitStar = { "TSTLhitStar" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_vectorlETHitmUcOallocatorlETHitmUgRsPgR = { "vector<THit*,allocator<THit*> >" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_reverse_iteratorlEvectorlETHitmUcOallocatorlETHitmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<THit*,allocator<THit*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_TSTLhitStarList = { "TSTLhitStarList" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_listlETHitmUcOallocatorlETHitmUgRsPgR = { "list<THit*,allocator<THit*> >" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_TSTLhitStarDeque = { "TSTLhitStarDeque" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_dequelETHitmUcOallocatorlETHitmUgRsPgR = { "deque<THit*,allocator<THit*> >" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_TSTLhitStarSet = { "TSTLhitStarSet" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_setlETHitmUcOlesslETHitmUgRcOallocatorlETHitmUgRsPgR = { "set<THit*,less<THit*>,allocator<THit*> >" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_TSTLhitStarMultiSet = { "TSTLhitStarMultiSet" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_multisetlETHitmUcOlesslETHitmUgRcOallocatorlETHitmUgRsPgR = { "multiset<THit*,less<THit*>,allocator<THit*> >" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_TSTLhitStarMap = { "TSTLhitStarMap" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_maplEintcOTHitmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitmUgRsPgRsPgR = { "map<int,THit*,less<int>,allocator<pair<const int,THit*> > >" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_pairlEintcOTHitmUgR = { "pair<int,THit*>" , 115 , -1 };
G__linked_taginfo G__TBenchDictLN_TSTLhitStarMultiMap = { "TSTLhitStarMultiMap" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_multimaplEintcOTHitmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitmUgRsPgRsPgR = { "multimap<int,THit*,less<int>,allocator<pair<const int,THit*> > >" , 99 , -1 };
G__linked_taginfo G__TBenchDictLN_TCloneshit = { "TCloneshit" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableTBenchDict() {
  G__TBenchDictLN_TClass.tagnum = -1 ;
  G__TBenchDictLN_TBuffer.tagnum = -1 ;
  G__TBenchDictLN_TMemberInspector.tagnum = -1 ;
  G__TBenchDictLN_TObject.tagnum = -1 ;
  G__TBenchDictLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR.tagnum = -1 ;
  G__TBenchDictLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__TBenchDictLN_TClonesArray.tagnum = -1 ;
  G__TBenchDictLN_THit.tagnum = -1 ;
  G__TBenchDictLN_TObjHit.tagnum = -1 ;
  G__TBenchDictLN_TSTLhit.tagnum = -1 ;
  G__TBenchDictLN_vectorlETHitcOallocatorlETHitgRsPgR.tagnum = -1 ;
  G__TBenchDictLN_reverse_iteratorlEvectorlETHitcOallocatorlETHitgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__TBenchDictLN_TSTLhitList.tagnum = -1 ;
  G__TBenchDictLN_listlETHitcOallocatorlETHitgRsPgR.tagnum = -1 ;
  G__TBenchDictLN_TSTLhitDeque.tagnum = -1 ;
  G__TBenchDictLN_dequelETHitcOallocatorlETHitgRsPgR.tagnum = -1 ;
  G__TBenchDictLN_TSTLhitMultiset.tagnum = -1 ;
  G__TBenchDictLN_multisetlETHitcOlesslETHitgRcOallocatorlETHitgRsPgR.tagnum = -1 ;
  G__TBenchDictLN_TSTLhitSet.tagnum = -1 ;
  G__TBenchDictLN_setlETHitcOlesslETHitgRcOallocatorlETHitgRsPgR.tagnum = -1 ;
  G__TBenchDictLN_TSTLhitMap.tagnum = -1 ;
  G__TBenchDictLN_maplEintcOTHitcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitgRsPgRsPgR.tagnum = -1 ;
  G__TBenchDictLN_pairlEintcOTHitgR.tagnum = -1 ;
  G__TBenchDictLN_TSTLhitMultiMap.tagnum = -1 ;
  G__TBenchDictLN_multimaplEintcOTHitcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitgRsPgRsPgR.tagnum = -1 ;
  G__TBenchDictLN_TSTLhitStar.tagnum = -1 ;
  G__TBenchDictLN_vectorlETHitmUcOallocatorlETHitmUgRsPgR.tagnum = -1 ;
  G__TBenchDictLN_reverse_iteratorlEvectorlETHitmUcOallocatorlETHitmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__TBenchDictLN_TSTLhitStarList.tagnum = -1 ;
  G__TBenchDictLN_listlETHitmUcOallocatorlETHitmUgRsPgR.tagnum = -1 ;
  G__TBenchDictLN_TSTLhitStarDeque.tagnum = -1 ;
  G__TBenchDictLN_dequelETHitmUcOallocatorlETHitmUgRsPgR.tagnum = -1 ;
  G__TBenchDictLN_TSTLhitStarSet.tagnum = -1 ;
  G__TBenchDictLN_setlETHitmUcOlesslETHitmUgRcOallocatorlETHitmUgRsPgR.tagnum = -1 ;
  G__TBenchDictLN_TSTLhitStarMultiSet.tagnum = -1 ;
  G__TBenchDictLN_multisetlETHitmUcOlesslETHitmUgRcOallocatorlETHitmUgRsPgR.tagnum = -1 ;
  G__TBenchDictLN_TSTLhitStarMap.tagnum = -1 ;
  G__TBenchDictLN_maplEintcOTHitmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitmUgRsPgRsPgR.tagnum = -1 ;
  G__TBenchDictLN_pairlEintcOTHitmUgR.tagnum = -1 ;
  G__TBenchDictLN_TSTLhitStarMultiMap.tagnum = -1 ;
  G__TBenchDictLN_multimaplEintcOTHitmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitmUgRsPgRsPgR.tagnum = -1 ;
  G__TBenchDictLN_TCloneshit.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableTBenchDict() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum(&G__TBenchDictLN_TClass);
   G__get_linked_tagnum(&G__TBenchDictLN_TBuffer);
   G__get_linked_tagnum(&G__TBenchDictLN_TMemberInspector);
   G__get_linked_tagnum(&G__TBenchDictLN_TObject);
   G__get_linked_tagnum(&G__TBenchDictLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR);
   G__get_linked_tagnum(&G__TBenchDictLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum(&G__TBenchDictLN_TClonesArray);
   G__tagtable_setup(G__get_linked_tagnum(&G__TBenchDictLN_THit),sizeof(THit),-1,429824,"the hit class",G__setup_memvarTHit,G__setup_memfuncTHit);
   G__tagtable_setup(G__get_linked_tagnum(&G__TBenchDictLN_TObjHit),sizeof(TObjHit),-1,324864,"the hit class",G__setup_memvarTObjHit,G__setup_memfuncTObjHit);
   G__tagtable_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhit),sizeof(TSTLhit),-1,296192,"STL vector of THit",G__setup_memvarTSTLhit,G__setup_memfuncTSTLhit);
   G__get_linked_tagnum(&G__TBenchDictLN_vectorlETHitcOallocatorlETHitgRsPgR);
   G__get_linked_tagnum(&G__TBenchDictLN_reverse_iteratorlEvectorlETHitcOallocatorlETHitgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitList),sizeof(TSTLhitList),-1,296192,"STL vector of THit",G__setup_memvarTSTLhitList,G__setup_memfuncTSTLhitList);
   G__get_linked_tagnum(&G__TBenchDictLN_listlETHitcOallocatorlETHitgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitDeque),sizeof(TSTLhitDeque),-1,296192,"STL vector of THit",G__setup_memvarTSTLhitDeque,G__setup_memfuncTSTLhitDeque);
   G__get_linked_tagnum(&G__TBenchDictLN_dequelETHitcOallocatorlETHitgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMultiset),sizeof(TSTLhitMultiset),-1,296192,"STL vector of THit",G__setup_memvarTSTLhitMultiset,G__setup_memfuncTSTLhitMultiset);
   G__get_linked_tagnum(&G__TBenchDictLN_multisetlETHitcOlesslETHitgRcOallocatorlETHitgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitSet),sizeof(TSTLhitSet),-1,296192,"STL vector of THit",G__setup_memvarTSTLhitSet,G__setup_memfuncTSTLhitSet);
   G__get_linked_tagnum(&G__TBenchDictLN_setlETHitcOlesslETHitgRcOallocatorlETHitgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMap),sizeof(TSTLhitMap),-1,296192,"STL vector of THit",G__setup_memvarTSTLhitMap,G__setup_memfuncTSTLhitMap);
   G__get_linked_tagnum(&G__TBenchDictLN_maplEintcOTHitcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum(&G__TBenchDictLN_pairlEintcOTHitgR),sizeof(pair<int,THit>),-1,297216,(char*)NULL,G__setup_memvarpairlEintcOTHitgR,G__setup_memfuncpairlEintcOTHitgR);
   G__tagtable_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitMultiMap),sizeof(TSTLhitMultiMap),-1,296192,"STL vector of THit",G__setup_memvarTSTLhitMultiMap,G__setup_memfuncTSTLhitMultiMap);
   G__get_linked_tagnum(&G__TBenchDictLN_multimaplEintcOTHitcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStar),sizeof(TSTLhitStar),-1,296192,"STL vector of pointers to THit",G__setup_memvarTSTLhitStar,G__setup_memfuncTSTLhitStar);
   G__get_linked_tagnum(&G__TBenchDictLN_vectorlETHitmUcOallocatorlETHitmUgRsPgR);
   G__get_linked_tagnum(&G__TBenchDictLN_reverse_iteratorlEvectorlETHitmUcOallocatorlETHitmUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarList),sizeof(TSTLhitStarList),-1,296192,"STL vector of pointers to THit",G__setup_memvarTSTLhitStarList,G__setup_memfuncTSTLhitStarList);
   G__get_linked_tagnum(&G__TBenchDictLN_listlETHitmUcOallocatorlETHitmUgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarDeque),sizeof(TSTLhitStarDeque),-1,296192,"STL vector of pointers to THit",G__setup_memvarTSTLhitStarDeque,G__setup_memfuncTSTLhitStarDeque);
   G__get_linked_tagnum(&G__TBenchDictLN_dequelETHitmUcOallocatorlETHitmUgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarSet),sizeof(TSTLhitStarSet),-1,296192,"STL vector of pointers to THit",G__setup_memvarTSTLhitStarSet,G__setup_memfuncTSTLhitStarSet);
   G__get_linked_tagnum(&G__TBenchDictLN_setlETHitmUcOlesslETHitmUgRcOallocatorlETHitmUgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMultiSet),sizeof(TSTLhitStarMultiSet),-1,296192,"STL vector of pointers to THit",G__setup_memvarTSTLhitStarMultiSet,G__setup_memfuncTSTLhitStarMultiSet);
   G__get_linked_tagnum(&G__TBenchDictLN_multisetlETHitmUcOlesslETHitmUgRcOallocatorlETHitmUgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMap),sizeof(TSTLhitStarMap),-1,296192,"STL vector of pointers to THit",G__setup_memvarTSTLhitStarMap,G__setup_memfuncTSTLhitStarMap);
   G__get_linked_tagnum(&G__TBenchDictLN_maplEintcOTHitmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitmUgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum(&G__TBenchDictLN_pairlEintcOTHitmUgR),sizeof(pair<int,THit*>),-1,297216,(char*)NULL,G__setup_memvarpairlEintcOTHitmUgR,G__setup_memfuncpairlEintcOTHitmUgR);
   G__tagtable_setup(G__get_linked_tagnum(&G__TBenchDictLN_TSTLhitStarMultiMap),sizeof(TSTLhitStarMultiMap),-1,296192,"STL vector of pointers to THit",G__setup_memvarTSTLhitStarMultiMap,G__setup_memfuncTSTLhitStarMultiMap);
   G__get_linked_tagnum(&G__TBenchDictLN_multimaplEintcOTHitmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTHitmUgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum(&G__TBenchDictLN_TCloneshit),sizeof(TCloneshit),-1,296192,"TClonesArray of TObjHit",G__setup_memvarTCloneshit,G__setup_memfuncTCloneshit);
}
extern "C" void G__cpp_setupTBenchDict(void) {
  G__check_setup_version(30051515,"G__cpp_setupTBenchDict()");
  G__set_cpp_environmentTBenchDict();
  G__cpp_setup_tagtableTBenchDict();

  G__cpp_setup_inheritanceTBenchDict();

  G__cpp_setup_typetableTBenchDict();

  G__cpp_setup_memvarTBenchDict();

  G__cpp_setup_memfuncTBenchDict();
  G__cpp_setup_globalTBenchDict();
  G__cpp_setup_funcTBenchDict();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncTBenchDict();
  return;
}
class G__cpp_setup_initTBenchDict {
  public:
    G__cpp_setup_initTBenchDict() { G__add_setup_func("TBenchDict",(G__incsetup)(&G__cpp_setupTBenchDict)); G__call_setup_funcs(); }
   ~G__cpp_setup_initTBenchDict() { G__remove_setup_func("TBenchDict"); }
};
G__cpp_setup_initTBenchDict G__cpp_setup_initializerTBenchDict;

