G__Cont.cxx

Go to the documentation of this file.

//
// File generated by core/utils/src/rootcint_tmp at Wed Apr 20 13:27:03 2011

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

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

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

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

#ifndef G__ROOT
#define G__ROOT
#endif

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

// START OF SHADOWS

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

namespace ROOT {
   void TVirtualCollectionProxy_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TVirtualCollectionProxy_Dictionary();
   static void delete_TVirtualCollectionProxy(void *p);
   static void deleteArray_TVirtualCollectionProxy(void *p);
   static void destruct_TVirtualCollectionProxy(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TVirtualCollectionProxy*)
   {
      ::TVirtualCollectionProxy *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TVirtualCollectionProxy),0);
      static ::ROOT::TGenericClassInfo 
         instance("TVirtualCollectionProxy", "include/TVirtualCollectionProxy.h", 41,
                  typeid(::TVirtualCollectionProxy), DefineBehavior(ptr, ptr),
                  0, &TVirtualCollectionProxy_Dictionary, isa_proxy, 1,
                  sizeof(::TVirtualCollectionProxy) );
      instance.SetDelete(&delete_TVirtualCollectionProxy);
      instance.SetDeleteArray(&deleteArray_TVirtualCollectionProxy);
      instance.SetDestructor(&destruct_TVirtualCollectionProxy);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TVirtualCollectionProxy*)
   {
      return GenerateInitInstanceLocal((::TVirtualCollectionProxy*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TVirtualCollectionProxy*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TVirtualCollectionProxy_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TVirtualCollectionProxy*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TList_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TList(void *p = 0);
   static void *newArray_TList(Long_t size, void *p);
   static void delete_TList(void *p);
   static void deleteArray_TList(void *p);
   static void destruct_TList(void *p);
   static void streamer_TList(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TList*)
   {
      ::TList *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TList >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TList", ::TList::Class_Version(), "include/TList.h", 47,
                  typeid(::TList), DefineBehavior(ptr, ptr),
                  &::TList::Dictionary, isa_proxy, 1,
                  sizeof(::TList) );
      instance.SetNew(&new_TList);
      instance.SetNewArray(&newArray_TList);
      instance.SetDelete(&delete_TList);
      instance.SetDeleteArray(&deleteArray_TList);
      instance.SetDestructor(&destruct_TList);
      instance.SetStreamerFunc(&streamer_TList);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TList*)
   {
      return GenerateInitInstanceLocal((::TList*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TList*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TObjArray_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TObjArray(void *p = 0);
   static void *newArray_TObjArray(Long_t size, void *p);
   static void delete_TObjArray(void *p);
   static void deleteArray_TObjArray(void *p);
   static void destruct_TObjArray(void *p);
   static void streamer_TObjArray(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TObjArray*)
   {
      ::TObjArray *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TObjArray >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TObjArray", ::TObjArray::Class_Version(), "include/TObjArray.h", 39,
                  typeid(::TObjArray), DefineBehavior(ptr, ptr),
                  &::TObjArray::Dictionary, isa_proxy, 1,
                  sizeof(::TObjArray) );
      instance.SetNew(&new_TObjArray);
      instance.SetNewArray(&newArray_TObjArray);
      instance.SetDelete(&delete_TObjArray);
      instance.SetDeleteArray(&deleteArray_TObjArray);
      instance.SetDestructor(&destruct_TObjArray);
      instance.SetStreamerFunc(&streamer_TObjArray);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TObjArray*)
   {
      return GenerateInitInstanceLocal((::TObjArray*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TObjArray*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TClonesArray_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TClonesArray(void *p = 0);
   static void *newArray_TClonesArray(Long_t size, void *p);
   static void delete_TClonesArray(void *p);
   static void deleteArray_TClonesArray(void *p);
   static void destruct_TClonesArray(void *p);
   static void streamer_TClonesArray(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TClonesArray*)
   {
      ::TClonesArray *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TClonesArray >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TClonesArray", ::TClonesArray::Class_Version(), "include/TClonesArray.h", 32,
                  typeid(::TClonesArray), DefineBehavior(ptr, ptr),
                  &::TClonesArray::Dictionary, isa_proxy, 1,
                  sizeof(::TClonesArray) );
      instance.SetNew(&new_TClonesArray);
      instance.SetNewArray(&newArray_TClonesArray);
      instance.SetDelete(&delete_TClonesArray);
      instance.SetDeleteArray(&deleteArray_TClonesArray);
      instance.SetDestructor(&destruct_TClonesArray);
      instance.SetStreamerFunc(&streamer_TClonesArray);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TClonesArray*)
   {
      return GenerateInitInstanceLocal((::TClonesArray*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TClonesArray*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TRefTable_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRefTable(void *p = 0);
   static void *newArray_TRefTable(Long_t size, void *p);
   static void delete_TRefTable(void *p);
   static void deleteArray_TRefTable(void *p);
   static void destruct_TRefTable(void *p);
   static void streamer_TRefTable(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRefTable*)
   {
      ::TRefTable *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRefTable >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRefTable", ::TRefTable::Class_Version(), "include/TRefTable.h", 37,
                  typeid(::TRefTable), DefineBehavior(ptr, ptr),
                  &::TRefTable::Dictionary, isa_proxy, 1,
                  sizeof(::TRefTable) );
      instance.SetNew(&new_TRefTable);
      instance.SetNewArray(&newArray_TRefTable);
      instance.SetDelete(&delete_TRefTable);
      instance.SetDeleteArray(&deleteArray_TRefTable);
      instance.SetDestructor(&destruct_TRefTable);
      instance.SetStreamerFunc(&streamer_TRefTable);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRefTable*)
   {
      return GenerateInitInstanceLocal((::TRefTable*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRefTable*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TArray_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TArray(void *p);
   static void deleteArray_TArray(void *p);
   static void destruct_TArray(void *p);
   static void streamer_TArray(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TArray*)
   {
      ::TArray *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TArray >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TArray", ::TArray::Class_Version(), "include/TArray.h", 33,
                  typeid(::TArray), DefineBehavior(ptr, ptr),
                  &::TArray::Dictionary, isa_proxy, 2,
                  sizeof(::TArray) );
      instance.SetDelete(&delete_TArray);
      instance.SetDeleteArray(&deleteArray_TArray);
      instance.SetDestructor(&destruct_TArray);
      instance.SetStreamerFunc(&streamer_TArray);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TArray*)
   {
      return GenerateInitInstanceLocal((::TArray*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TArray*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TArrayC_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TArrayC(void *p = 0);
   static void *newArray_TArrayC(Long_t size, void *p);
   static void delete_TArrayC(void *p);
   static void deleteArray_TArrayC(void *p);
   static void destruct_TArrayC(void *p);
   static void streamer_TArrayC(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TArrayC*)
   {
      ::TArrayC *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TArrayC >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TArrayC", ::TArrayC::Class_Version(), "include/TArrayC.h", 29,
                  typeid(::TArrayC), DefineBehavior(ptr, ptr),
                  &::TArrayC::Dictionary, isa_proxy, 3,
                  sizeof(::TArrayC) );
      instance.SetNew(&new_TArrayC);
      instance.SetNewArray(&newArray_TArrayC);
      instance.SetDelete(&delete_TArrayC);
      instance.SetDeleteArray(&deleteArray_TArrayC);
      instance.SetDestructor(&destruct_TArrayC);
      instance.SetStreamerFunc(&streamer_TArrayC);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TArrayC*)
   {
      return GenerateInitInstanceLocal((::TArrayC*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TArrayC*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TArrayD_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TArrayD(void *p = 0);
   static void *newArray_TArrayD(Long_t size, void *p);
   static void delete_TArrayD(void *p);
   static void deleteArray_TArrayD(void *p);
   static void destruct_TArrayD(void *p);
   static void streamer_TArrayD(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TArrayD*)
   {
      ::TArrayD *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TArrayD >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TArrayD", ::TArrayD::Class_Version(), "include/TArrayD.h", 29,
                  typeid(::TArrayD), DefineBehavior(ptr, ptr),
                  &::TArrayD::Dictionary, isa_proxy, 3,
                  sizeof(::TArrayD) );
      instance.SetNew(&new_TArrayD);
      instance.SetNewArray(&newArray_TArrayD);
      instance.SetDelete(&delete_TArrayD);
      instance.SetDeleteArray(&deleteArray_TArrayD);
      instance.SetDestructor(&destruct_TArrayD);
      instance.SetStreamerFunc(&streamer_TArrayD);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TArrayD*)
   {
      return GenerateInitInstanceLocal((::TArrayD*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TArrayD*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TArrayF_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TArrayF(void *p = 0);
   static void *newArray_TArrayF(Long_t size, void *p);
   static void delete_TArrayF(void *p);
   static void deleteArray_TArrayF(void *p);
   static void destruct_TArrayF(void *p);
   static void streamer_TArrayF(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TArrayF*)
   {
      ::TArrayF *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TArrayF >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TArrayF", ::TArrayF::Class_Version(), "include/TArrayF.h", 29,
                  typeid(::TArrayF), DefineBehavior(ptr, ptr),
                  &::TArrayF::Dictionary, isa_proxy, 3,
                  sizeof(::TArrayF) );
      instance.SetNew(&new_TArrayF);
      instance.SetNewArray(&newArray_TArrayF);
      instance.SetDelete(&delete_TArrayF);
      instance.SetDeleteArray(&deleteArray_TArrayF);
      instance.SetDestructor(&destruct_TArrayF);
      instance.SetStreamerFunc(&streamer_TArrayF);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TArrayF*)
   {
      return GenerateInitInstanceLocal((::TArrayF*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TArrayF*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TArrayI_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TArrayI(void *p = 0);
   static void *newArray_TArrayI(Long_t size, void *p);
   static void delete_TArrayI(void *p);
   static void deleteArray_TArrayI(void *p);
   static void destruct_TArrayI(void *p);
   static void streamer_TArrayI(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TArrayI*)
   {
      ::TArrayI *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TArrayI >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TArrayI", ::TArrayI::Class_Version(), "include/TArrayI.h", 29,
                  typeid(::TArrayI), DefineBehavior(ptr, ptr),
                  &::TArrayI::Dictionary, isa_proxy, 3,
                  sizeof(::TArrayI) );
      instance.SetNew(&new_TArrayI);
      instance.SetNewArray(&newArray_TArrayI);
      instance.SetDelete(&delete_TArrayI);
      instance.SetDeleteArray(&deleteArray_TArrayI);
      instance.SetDestructor(&destruct_TArrayI);
      instance.SetStreamerFunc(&streamer_TArrayI);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TArrayI*)
   {
      return GenerateInitInstanceLocal((::TArrayI*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TArrayI*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TArrayL64_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TArrayL64(void *p = 0);
   static void *newArray_TArrayL64(Long_t size, void *p);
   static void delete_TArrayL64(void *p);
   static void deleteArray_TArrayL64(void *p);
   static void destruct_TArrayL64(void *p);
   static void streamer_TArrayL64(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TArrayL64*)
   {
      ::TArrayL64 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TArrayL64 >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TArrayL64", ::TArrayL64::Class_Version(), "include/TArrayL64.h", 29,
                  typeid(::TArrayL64), DefineBehavior(ptr, ptr),
                  &::TArrayL64::Dictionary, isa_proxy, 3,
                  sizeof(::TArrayL64) );
      instance.SetNew(&new_TArrayL64);
      instance.SetNewArray(&newArray_TArrayL64);
      instance.SetDelete(&delete_TArrayL64);
      instance.SetDeleteArray(&deleteArray_TArrayL64);
      instance.SetDestructor(&destruct_TArrayL64);
      instance.SetStreamerFunc(&streamer_TArrayL64);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TArrayL64*)
   {
      return GenerateInitInstanceLocal((::TArrayL64*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TArrayL64*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TArrayL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TArrayL(void *p = 0);
   static void *newArray_TArrayL(Long_t size, void *p);
   static void delete_TArrayL(void *p);
   static void deleteArray_TArrayL(void *p);
   static void destruct_TArrayL(void *p);
   static void streamer_TArrayL(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TArrayL*)
   {
      ::TArrayL *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TArrayL >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TArrayL", ::TArrayL::Class_Version(), "include/TArrayL.h", 29,
                  typeid(::TArrayL), DefineBehavior(ptr, ptr),
                  &::TArrayL::Dictionary, isa_proxy, 3,
                  sizeof(::TArrayL) );
      instance.SetNew(&new_TArrayL);
      instance.SetNewArray(&newArray_TArrayL);
      instance.SetDelete(&delete_TArrayL);
      instance.SetDeleteArray(&deleteArray_TArrayL);
      instance.SetDestructor(&destruct_TArrayL);
      instance.SetStreamerFunc(&streamer_TArrayL);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TArrayL*)
   {
      return GenerateInitInstanceLocal((::TArrayL*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TArrayL*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TArrayS_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TArrayS(void *p = 0);
   static void *newArray_TArrayS(Long_t size, void *p);
   static void delete_TArrayS(void *p);
   static void deleteArray_TArrayS(void *p);
   static void destruct_TArrayS(void *p);
   static void streamer_TArrayS(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TArrayS*)
   {
      ::TArrayS *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TArrayS >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TArrayS", ::TArrayS::Class_Version(), "include/TArrayS.h", 29,
                  typeid(::TArrayS), DefineBehavior(ptr, ptr),
                  &::TArrayS::Dictionary, isa_proxy, 3,
                  sizeof(::TArrayS) );
      instance.SetNew(&new_TArrayS);
      instance.SetNewArray(&newArray_TArrayS);
      instance.SetDelete(&delete_TArrayS);
      instance.SetDeleteArray(&deleteArray_TArrayS);
      instance.SetDestructor(&destruct_TArrayS);
      instance.SetStreamerFunc(&streamer_TArrayS);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TArrayS*)
   {
      return GenerateInitInstanceLocal((::TArrayS*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TArrayS*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TBits_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TBits(void *p = 0);
   static void *newArray_TBits(Long_t size, void *p);
   static void delete_TBits(void *p);
   static void deleteArray_TBits(void *p);
   static void destruct_TBits(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TBits*)
   {
      ::TBits *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TBits >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TBits", ::TBits::Class_Version(), "include/TBits.h", 33,
                  typeid(::TBits), DefineBehavior(ptr, ptr),
                  &::TBits::Dictionary, isa_proxy, 4,
                  sizeof(::TBits) );
      instance.SetNew(&new_TBits);
      instance.SetNewArray(&newArray_TBits);
      instance.SetDelete(&delete_TBits);
      instance.SetDeleteArray(&deleteArray_TBits);
      instance.SetDestructor(&destruct_TBits);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TBits*)
   {
      return GenerateInitInstanceLocal((::TBits*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TBits*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TBitscLcLTReference_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TBitscLcLTReference_Dictionary();
   static void delete_TBitscLcLTReference(void *p);
   static void deleteArray_TBitscLcLTReference(void *p);
   static void destruct_TBitscLcLTReference(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TBits::TReference*)
   {
      ::TBits::TReference *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TBits::TReference),0);
      static ::ROOT::TGenericClassInfo 
         instance("TBits::TReference", "include/TBits.h", 55,
                  typeid(::TBits::TReference), DefineBehavior(ptr, ptr),
                  0, &TBitscLcLTReference_Dictionary, isa_proxy, 1,
                  sizeof(::TBits::TReference) );
      instance.SetDelete(&delete_TBitscLcLTReference);
      instance.SetDeleteArray(&deleteArray_TBitscLcLTReference);
      instance.SetDestructor(&destruct_TBitscLcLTReference);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TBits::TReference*)
   {
      return GenerateInitInstanceLocal((::TBits::TReference*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TBits::TReference*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TBitscLcLTReference_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TBits::TReference*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TCollection_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TCollection(void *p);
   static void deleteArray_TCollection(void *p);
   static void destruct_TCollection(void *p);
   static void streamer_TCollection(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TCollection*)
   {
      ::TCollection *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TCollection >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TCollection", ::TCollection::Class_Version(), "include/TCollection.h", 47,
                  typeid(::TCollection), DefineBehavior(ptr, ptr),
                  &::TCollection::Dictionary, isa_proxy, 1,
                  sizeof(::TCollection) );
      instance.SetDelete(&delete_TCollection);
      instance.SetDeleteArray(&deleteArray_TCollection);
      instance.SetDestructor(&destruct_TCollection);
      instance.SetStreamerFunc(&streamer_TCollection);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TCollection*)
   {
      return GenerateInitInstanceLocal((::TCollection*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TCollection*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TIterator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TIterator(void *p);
   static void deleteArray_TIterator(void *p);
   static void destruct_TIterator(void *p);
   static void streamer_TIterator(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TIterator*)
   {
      ::TIterator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TIterator >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TIterator", ::TIterator::Class_Version(), "include/TIterator.h", 32,
                  typeid(::TIterator), DefineBehavior(ptr, ptr),
                  &::TIterator::Dictionary, isa_proxy, 0,
                  sizeof(::TIterator) );
      instance.SetDelete(&delete_TIterator);
      instance.SetDeleteArray(&deleteArray_TIterator);
      instance.SetDestructor(&destruct_TIterator);
      instance.SetStreamerFunc(&streamer_TIterator);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TIterator*)
   {
      return GenerateInitInstanceLocal((::TIterator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TIterator*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TObjectTable_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TObjectTable(void *p = 0);
   static void *newArray_TObjectTable(Long_t size, void *p);
   static void delete_TObjectTable(void *p);
   static void deleteArray_TObjectTable(void *p);
   static void destruct_TObjectTable(void *p);
   static void streamer_TObjectTable(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TObjectTable*)
   {
      ::TObjectTable *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TObjectTable >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TObjectTable", ::TObjectTable::Class_Version(), "include/TObjectTable.h", 37,
                  typeid(::TObjectTable), DefineBehavior(ptr, ptr),
                  &::TObjectTable::Dictionary, isa_proxy, 0,
                  sizeof(::TObjectTable) );
      instance.SetNew(&new_TObjectTable);
      instance.SetNewArray(&newArray_TObjectTable);
      instance.SetDelete(&delete_TObjectTable);
      instance.SetDeleteArray(&deleteArray_TObjectTable);
      instance.SetDestructor(&destruct_TObjectTable);
      instance.SetStreamerFunc(&streamer_TObjectTable);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TObjectTable*)
   {
      return GenerateInitInstanceLocal((::TObjectTable*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TObjectTable*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TIter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TIter(void *p);
   static void deleteArray_TIter(void *p);
   static void destruct_TIter(void *p);
   static void streamer_TIter(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TIter*)
   {
      ::TIter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TIter >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TIter", ::TIter::Class_Version(), "include/TCollection.h", 138,
                  typeid(::TIter), DefineBehavior(ptr, ptr),
                  &::TIter::Dictionary, isa_proxy, 0,
                  sizeof(::TIter) );
      instance.SetDelete(&delete_TIter);
      instance.SetDeleteArray(&deleteArray_TIter);
      instance.SetDestructor(&destruct_TIter);
      instance.SetStreamerFunc(&streamer_TIter);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TIter*)
   {
      return GenerateInitInstanceLocal((::TIter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TIter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSeqCollection_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TSeqCollection(void *p);
   static void deleteArray_TSeqCollection(void *p);
   static void destruct_TSeqCollection(void *p);
   static void streamer_TSeqCollection(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSeqCollection*)
   {
      ::TSeqCollection *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSeqCollection >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSeqCollection", ::TSeqCollection::Class_Version(), "include/TSeqCollection.h", 30,
                  typeid(::TSeqCollection), DefineBehavior(ptr, ptr),
                  &::TSeqCollection::Dictionary, isa_proxy, 0,
                  sizeof(::TSeqCollection) );
      instance.SetDelete(&delete_TSeqCollection);
      instance.SetDeleteArray(&deleteArray_TSeqCollection);
      instance.SetDestructor(&destruct_TSeqCollection);
      instance.SetStreamerFunc(&streamer_TSeqCollection);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSeqCollection*)
   {
      return GenerateInitInstanceLocal((::TSeqCollection*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSeqCollection*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TBtreeIter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TBtreeIter(void *p);
   static void deleteArray_TBtreeIter(void *p);
   static void destruct_TBtreeIter(void *p);
   static void streamer_TBtreeIter(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TBtreeIter*)
   {
      ::TBtreeIter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TBtreeIter >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TBtreeIter", ::TBtreeIter::Class_Version(), "include/TBtree.h", 341,
                  typeid(::TBtreeIter), DefineBehavior(ptr, ptr),
                  &::TBtreeIter::Dictionary, isa_proxy, 0,
                  sizeof(::TBtreeIter) );
      instance.SetDelete(&delete_TBtreeIter);
      instance.SetDeleteArray(&deleteArray_TBtreeIter);
      instance.SetDestructor(&destruct_TBtreeIter);
      instance.SetStreamerFunc(&streamer_TBtreeIter);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TBtreeIter*)
   {
      return GenerateInitInstanceLocal((::TBtreeIter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TBtreeIter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TBtree_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TBtree(void *p = 0);
   static void *newArray_TBtree(Long_t size, void *p);
   static void delete_TBtree(void *p);
   static void deleteArray_TBtree(void *p);
   static void destruct_TBtree(void *p);
   static void streamer_TBtree(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TBtree*)
   {
      ::TBtree *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TBtree >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TBtree", ::TBtree::Class_Version(), "include/TBtree.h", 42,
                  typeid(::TBtree), DefineBehavior(ptr, ptr),
                  &::TBtree::Dictionary, isa_proxy, 1,
                  sizeof(::TBtree) );
      instance.SetNew(&new_TBtree);
      instance.SetNewArray(&newArray_TBtree);
      instance.SetDelete(&delete_TBtree);
      instance.SetDeleteArray(&deleteArray_TBtree);
      instance.SetDestructor(&destruct_TBtree);
      instance.SetStreamerFunc(&streamer_TBtree);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TBtree*)
   {
      return GenerateInitInstanceLocal((::TBtree*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TBtree*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TClassTable_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TClassTable(void *p);
   static void deleteArray_TClassTable(void *p);
   static void destruct_TClassTable(void *p);
   static void streamer_TClassTable(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TClassTable*)
   {
      ::TClassTable *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TClassTable >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TClassTable", ::TClassTable::Class_Version(), "include/TClassTable.h", 46,
                  typeid(::TClassTable), DefineBehavior(ptr, ptr),
                  &::TClassTable::Dictionary, isa_proxy, 0,
                  sizeof(::TClassTable) );
      instance.SetDelete(&delete_TClassTable);
      instance.SetDeleteArray(&deleteArray_TClassTable);
      instance.SetDestructor(&destruct_TClassTable);
      instance.SetStreamerFunc(&streamer_TClassTable);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TClassTable*)
   {
      return GenerateInitInstanceLocal((::TClassTable*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TClassTable*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TObjArrayIter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TObjArrayIter(void *p);
   static void deleteArray_TObjArrayIter(void *p);
   static void destruct_TObjArrayIter(void *p);
   static void streamer_TObjArrayIter(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TObjArrayIter*)
   {
      ::TObjArrayIter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TObjArrayIter >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TObjArrayIter", ::TObjArrayIter::Class_Version(), "include/TObjArray.h", 126,
                  typeid(::TObjArrayIter), DefineBehavior(ptr, ptr),
                  &::TObjArrayIter::Dictionary, isa_proxy, 0,
                  sizeof(::TObjArrayIter) );
      instance.SetDelete(&delete_TObjArrayIter);
      instance.SetDeleteArray(&deleteArray_TObjArrayIter);
      instance.SetDestructor(&destruct_TObjArrayIter);
      instance.SetStreamerFunc(&streamer_TObjArrayIter);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TObjArrayIter*)
   {
      return GenerateInitInstanceLocal((::TObjArrayIter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TObjArrayIter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TExMapIter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TExMapIter(void *p);
   static void deleteArray_TExMapIter(void *p);
   static void destruct_TExMapIter(void *p);
   static void streamer_TExMapIter(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TExMapIter*)
   {
      ::TExMapIter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TExMapIter >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TExMapIter", ::TExMapIter::Class_Version(), "include/TExMap.h", 87,
                  typeid(::TExMapIter), DefineBehavior(ptr, ptr),
                  &::TExMapIter::Dictionary, isa_proxy, 0,
                  sizeof(::TExMapIter) );
      instance.SetDelete(&delete_TExMapIter);
      instance.SetDeleteArray(&deleteArray_TExMapIter);
      instance.SetDestructor(&destruct_TExMapIter);
      instance.SetStreamerFunc(&streamer_TExMapIter);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TExMapIter*)
   {
      return GenerateInitInstanceLocal((::TExMapIter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TExMapIter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TExMap_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TExMap(void *p = 0);
   static void *newArray_TExMap(Long_t size, void *p);
   static void delete_TExMap(void *p);
   static void deleteArray_TExMap(void *p);
   static void destruct_TExMap(void *p);
   static void streamer_TExMap(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TExMap*)
   {
      ::TExMap *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TExMap >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TExMap", ::TExMap::Class_Version(), "include/TExMap.h", 35,
                  typeid(::TExMap), DefineBehavior(ptr, ptr),
                  &::TExMap::Dictionary, isa_proxy, 1,
                  sizeof(::TExMap) );
      instance.SetNew(&new_TExMap);
      instance.SetNewArray(&newArray_TExMap);
      instance.SetDelete(&delete_TExMap);
      instance.SetDeleteArray(&deleteArray_TExMap);
      instance.SetDestructor(&destruct_TExMap);
      instance.SetStreamerFunc(&streamer_TExMap);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TExMap*)
   {
      return GenerateInitInstanceLocal((::TExMap*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TExMap*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TListIter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TListIter(void *p);
   static void deleteArray_TListIter(void *p);
   static void destruct_TListIter(void *p);
   static void streamer_TListIter(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TListIter*)
   {
      ::TListIter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TListIter >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TListIter", ::TListIter::Class_Version(), "include/TList.h", 190,
                  typeid(::TListIter), DefineBehavior(ptr, ptr),
                  &::TListIter::Dictionary, isa_proxy, 0,
                  sizeof(::TListIter) );
      instance.SetDelete(&delete_TListIter);
      instance.SetDeleteArray(&deleteArray_TListIter);
      instance.SetDestructor(&destruct_TListIter);
      instance.SetStreamerFunc(&streamer_TListIter);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TListIter*)
   {
      return GenerateInitInstanceLocal((::TListIter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TListIter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void THashTable_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_THashTable(void *p = 0);
   static void *newArray_THashTable(Long_t size, void *p);
   static void delete_THashTable(void *p);
   static void deleteArray_THashTable(void *p);
   static void destruct_THashTable(void *p);
   static void streamer_THashTable(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THashTable*)
   {
      ::THashTable *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THashTable >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THashTable", ::THashTable::Class_Version(), "include/THashTable.h", 39,
                  typeid(::THashTable), DefineBehavior(ptr, ptr),
                  &::THashTable::Dictionary, isa_proxy, 0,
                  sizeof(::THashTable) );
      instance.SetNew(&new_THashTable);
      instance.SetNewArray(&newArray_THashTable);
      instance.SetDelete(&delete_THashTable);
      instance.SetDeleteArray(&deleteArray_THashTable);
      instance.SetDestructor(&destruct_THashTable);
      instance.SetStreamerFunc(&streamer_THashTable);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THashTable*)
   {
      return GenerateInitInstanceLocal((::THashTable*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THashTable*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void THashList_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_THashList(void *p = 0);
   static void *newArray_THashList(Long_t size, void *p);
   static void delete_THashList(void *p);
   static void deleteArray_THashList(void *p);
   static void destruct_THashList(void *p);
   static void streamer_THashList(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THashList*)
   {
      ::THashList *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THashList >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THashList", ::THashList::Class_Version(), "include/THashList.h", 36,
                  typeid(::THashList), DefineBehavior(ptr, ptr),
                  &::THashList::Dictionary, isa_proxy, 0,
                  sizeof(::THashList) );
      instance.SetNew(&new_THashList);
      instance.SetNewArray(&newArray_THashList);
      instance.SetDelete(&delete_THashList);
      instance.SetDeleteArray(&deleteArray_THashList);
      instance.SetDestructor(&destruct_THashList);
      instance.SetStreamerFunc(&streamer_THashList);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THashList*)
   {
      return GenerateInitInstanceLocal((::THashList*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THashList*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void THashTableIter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_THashTableIter(void *p);
   static void deleteArray_THashTableIter(void *p);
   static void destruct_THashTableIter(void *p);
   static void streamer_THashTableIter(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THashTableIter*)
   {
      ::THashTableIter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THashTableIter >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THashTableIter", ::THashTableIter::Class_Version(), "include/THashTable.h", 105,
                  typeid(::THashTableIter), DefineBehavior(ptr, ptr),
                  &::THashTableIter::Dictionary, isa_proxy, 0,
                  sizeof(::THashTableIter) );
      instance.SetDelete(&delete_THashTableIter);
      instance.SetDeleteArray(&deleteArray_THashTableIter);
      instance.SetDestructor(&destruct_THashTableIter);
      instance.SetStreamerFunc(&streamer_THashTableIter);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THashTableIter*)
   {
      return GenerateInitInstanceLocal((::THashTableIter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THashTableIter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMapIter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMapIter(void *p);
   static void deleteArray_TMapIter(void *p);
   static void destruct_TMapIter(void *p);
   static void streamer_TMapIter(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMapIter*)
   {
      ::TMapIter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMapIter >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMapIter", ::TMapIter::Class_Version(), "include/TMap.h", 149,
                  typeid(::TMapIter), DefineBehavior(ptr, ptr),
                  &::TMapIter::Dictionary, isa_proxy, 0,
                  sizeof(::TMapIter) );
      instance.SetDelete(&delete_TMapIter);
      instance.SetDeleteArray(&deleteArray_TMapIter);
      instance.SetDestructor(&destruct_TMapIter);
      instance.SetStreamerFunc(&streamer_TMapIter);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMapIter*)
   {
      return GenerateInitInstanceLocal((::TMapIter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMapIter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TPair_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TPair(void *p);
   static void deleteArray_TPair(void *p);
   static void destruct_TPair(void *p);
   static void streamer_TPair(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPair*)
   {
      ::TPair *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPair >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TPair", ::TPair::Class_Version(), "include/TMap.h", 104,
                  typeid(::TPair), DefineBehavior(ptr, ptr),
                  &::TPair::Dictionary, isa_proxy, 0,
                  sizeof(::TPair) );
      instance.SetDelete(&delete_TPair);
      instance.SetDeleteArray(&deleteArray_TPair);
      instance.SetDestructor(&destruct_TPair);
      instance.SetStreamerFunc(&streamer_TPair);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TPair*)
   {
      return GenerateInitInstanceLocal((::TPair*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPair*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMap_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMap(void *p = 0);
   static void *newArray_TMap(Long_t size, void *p);
   static void delete_TMap(void *p);
   static void deleteArray_TMap(void *p);
   static void destruct_TMap(void *p);
   static void streamer_TMap(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMap*)
   {
      ::TMap *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMap >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMap", ::TMap::Class_Version(), "include/TMap.h", 44,
                  typeid(::TMap), DefineBehavior(ptr, ptr),
                  &::TMap::Dictionary, isa_proxy, 1,
                  sizeof(::TMap) );
      instance.SetNew(&new_TMap);
      instance.SetNewArray(&newArray_TMap);
      instance.SetDelete(&delete_TMap);
      instance.SetDeleteArray(&deleteArray_TMap);
      instance.SetDestructor(&destruct_TMap);
      instance.SetStreamerFunc(&streamer_TMap);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMap*)
   {
      return GenerateInitInstanceLocal((::TMap*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMap*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TOrdCollectionIter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TOrdCollectionIter(void *p);
   static void deleteArray_TOrdCollectionIter(void *p);
   static void destruct_TOrdCollectionIter(void *p);
   static void streamer_TOrdCollectionIter(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TOrdCollectionIter*)
   {
      ::TOrdCollectionIter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TOrdCollectionIter >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TOrdCollectionIter", ::TOrdCollectionIter::Class_Version(), "include/TOrdCollection.h", 101,
                  typeid(::TOrdCollectionIter), DefineBehavior(ptr, ptr),
                  &::TOrdCollectionIter::Dictionary, isa_proxy, 0,
                  sizeof(::TOrdCollectionIter) );
      instance.SetDelete(&delete_TOrdCollectionIter);
      instance.SetDeleteArray(&deleteArray_TOrdCollectionIter);
      instance.SetDestructor(&destruct_TOrdCollectionIter);
      instance.SetStreamerFunc(&streamer_TOrdCollectionIter);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TOrdCollectionIter*)
   {
      return GenerateInitInstanceLocal((::TOrdCollectionIter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TOrdCollectionIter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TOrdCollection_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TOrdCollection(void *p = 0);
   static void *newArray_TOrdCollection(Long_t size, void *p);
   static void delete_TOrdCollection(void *p);
   static void deleteArray_TOrdCollection(void *p);
   static void destruct_TOrdCollection(void *p);
   static void streamer_TOrdCollection(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TOrdCollection*)
   {
      ::TOrdCollection *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TOrdCollection >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TOrdCollection", ::TOrdCollection::Class_Version(), "include/TOrdCollection.h", 34,
                  typeid(::TOrdCollection), DefineBehavior(ptr, ptr),
                  &::TOrdCollection::Dictionary, isa_proxy, 0,
                  sizeof(::TOrdCollection) );
      instance.SetNew(&new_TOrdCollection);
      instance.SetNewArray(&newArray_TOrdCollection);
      instance.SetDelete(&delete_TOrdCollection);
      instance.SetDeleteArray(&deleteArray_TOrdCollection);
      instance.SetDestructor(&destruct_TOrdCollection);
      instance.SetStreamerFunc(&streamer_TOrdCollection);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TOrdCollection*)
   {
      return GenerateInitInstanceLocal((::TOrdCollection*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TOrdCollection*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TRefArrayIter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TRefArrayIter(void *p);
   static void deleteArray_TRefArrayIter(void *p);
   static void destruct_TRefArrayIter(void *p);
   static void streamer_TRefArrayIter(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRefArrayIter*)
   {
      ::TRefArrayIter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRefArrayIter >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRefArrayIter", ::TRefArrayIter::Class_Version(), "include/TRefArray.h", 128,
                  typeid(::TRefArrayIter), DefineBehavior(ptr, ptr),
                  &::TRefArrayIter::Dictionary, isa_proxy, 0,
                  sizeof(::TRefArrayIter) );
      instance.SetDelete(&delete_TRefArrayIter);
      instance.SetDeleteArray(&deleteArray_TRefArrayIter);
      instance.SetDestructor(&destruct_TRefArrayIter);
      instance.SetStreamerFunc(&streamer_TRefArrayIter);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRefArrayIter*)
   {
      return GenerateInitInstanceLocal((::TRefArrayIter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRefArrayIter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TRefArray_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TRefArray(void *p = 0);
   static void *newArray_TRefArray(Long_t size, void *p);
   static void delete_TRefArray(void *p);
   static void deleteArray_TRefArray(void *p);
   static void destruct_TRefArray(void *p);
   static void streamer_TRefArray(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TRefArray*)
   {
      ::TRefArray *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TRefArray >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TRefArray", ::TRefArray::Class_Version(), "include/TRefArray.h", 43,
                  typeid(::TRefArray), DefineBehavior(ptr, ptr),
                  &::TRefArray::Dictionary, isa_proxy, 1,
                  sizeof(::TRefArray) );
      instance.SetNew(&new_TRefArray);
      instance.SetNewArray(&newArray_TRefArray);
      instance.SetDelete(&delete_TRefArray);
      instance.SetDeleteArray(&deleteArray_TRefArray);
      instance.SetDestructor(&destruct_TRefArray);
      instance.SetStreamerFunc(&streamer_TRefArray);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TRefArray*)
   {
      return GenerateInitInstanceLocal((::TRefArray*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TRefArray*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void vectorlEintcOallocatorlEintgRsPgRcLcLiterator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEintcOallocatorlEintgRsPgRcLcLiterator_Dictionary();
   static void *new_vectorlEintcOallocatorlEintgRsPgRcLcLiterator(void *p = 0);
   static void *newArray_vectorlEintcOallocatorlEintgRsPgRcLcLiterator(Long_t size, void *p);
   static void delete_vectorlEintcOallocatorlEintgRsPgRcLcLiterator(void *p);
   static void deleteArray_vectorlEintcOallocatorlEintgRsPgRcLcLiterator(void *p);
   static void destruct_vectorlEintcOallocatorlEintgRsPgRcLcLiterator(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::vector<int,allocator<int> >::iterator*)
   {
      ::vector<int,allocator<int> >::iterator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::vector<int,allocator<int> >::iterator),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<int,allocator<int> >::iterator", "prec_stl/vector", 218,
                  typeid(::vector<int,allocator<int> >::iterator), DefineBehavior(ptr, ptr),
                  0, &vectorlEintcOallocatorlEintgRsPgRcLcLiterator_Dictionary, isa_proxy, 0,
                  sizeof(::vector<int,allocator<int> >::iterator) );
      instance.SetNew(&new_vectorlEintcOallocatorlEintgRsPgRcLcLiterator);
      instance.SetNewArray(&newArray_vectorlEintcOallocatorlEintgRsPgRcLcLiterator);
      instance.SetDelete(&delete_vectorlEintcOallocatorlEintgRsPgRcLcLiterator);
      instance.SetDeleteArray(&deleteArray_vectorlEintcOallocatorlEintgRsPgRcLcLiterator);
      instance.SetDestructor(&destruct_vectorlEintcOallocatorlEintgRsPgRcLcLiterator);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::vector<int,allocator<int> >::iterator*)
   {
      return GenerateInitInstanceLocal((::vector<int,allocator<int> >::iterator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::vector<int,allocator<int> >::iterator*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR_Dictionary();
   static void *new_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR(void *p = 0);
   static void *newArray_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR(Long_t size, void *p);
   static void delete_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR(void *p);
   static void deleteArray_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR(void *p);
   static void destruct_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::reverse_iterator<vector<int,allocator<int> >::iterator>*)
   {
      ::reverse_iterator<vector<int,allocator<int> >::iterator> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::reverse_iterator<vector<int,allocator<int> >::iterator>),0);
      static ::ROOT::TGenericClassInfo 
         instance("reverse_iterator<vector<int,allocator<int> >::iterator>", "prec_stl/iterator", 166,
                  typeid(::reverse_iterator<vector<int,allocator<int> >::iterator>), DefineBehavior(ptr, ptr),
                  0, &reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR_Dictionary, isa_proxy, 0,
                  sizeof(::reverse_iterator<vector<int,allocator<int> >::iterator>) );
      instance.SetNew(&new_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
      instance.SetNewArray(&newArray_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
      instance.SetDelete(&delete_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
      instance.SetDeleteArray(&deleteArray_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
      instance.SetDestructor(&destruct_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::reverse_iterator<vector<int,allocator<int> >::iterator>*)
   {
      return GenerateInitInstanceLocal((::reverse_iterator<vector<int,allocator<int> >::iterator>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::reverse_iterator<vector<int,allocator<int> >::iterator>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TSortedList_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TSortedList(void *p = 0);
   static void *newArray_TSortedList(Long_t size, void *p);
   static void delete_TSortedList(void *p);
   static void deleteArray_TSortedList(void *p);
   static void destruct_TSortedList(void *p);
   static void streamer_TSortedList(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSortedList*)
   {
      ::TSortedList *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSortedList >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSortedList", ::TSortedList::Class_Version(), "include/TSortedList.h", 30,
                  typeid(::TSortedList), DefineBehavior(ptr, ptr),
                  &::TSortedList::Dictionary, isa_proxy, 0,
                  sizeof(::TSortedList) );
      instance.SetNew(&new_TSortedList);
      instance.SetNewArray(&newArray_TSortedList);
      instance.SetDelete(&delete_TSortedList);
      instance.SetDeleteArray(&deleteArray_TSortedList);
      instance.SetDestructor(&destruct_TSortedList);
      instance.SetStreamerFunc(&streamer_TSortedList);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSortedList*)
   {
      return GenerateInitInstanceLocal((::TSortedList*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSortedList*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      R__b >> fN;
      R__b.CheckByteCount(R__s, R__c, TArray::IsA());
   } else {
      R__c = R__b.WriteVersion(TArray::IsA(), kTRUE);
      R__b << fN;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TArray(void *p) {
      delete ((::TArray*)p);
   }
   static void deleteArray_TArray(void *p) {
      delete [] ((::TArray*)p);
   }
   static void destruct_TArray(void *p) {
      typedef ::TArray current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TArray(TBuffer &buf, void *obj) {
      ((::TArray*)obj)->::TArray::Streamer(buf);
   }
} // end of namespace ROOT for class ::TArray

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TArrayC(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TArrayC : new ::TArrayC;
   }
   static void *newArray_TArrayC(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TArrayC[nElements] : new ::TArrayC[nElements];
   }
   // Wrapper around operator delete
   static void delete_TArrayC(void *p) {
      delete ((::TArrayC*)p);
   }
   static void deleteArray_TArrayC(void *p) {
      delete [] ((::TArrayC*)p);
   }
   static void destruct_TArrayC(void *p) {
      typedef ::TArrayC current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TArrayC(TBuffer &buf, void *obj) {
      ((::TArrayC*)obj)->::TArrayC::Streamer(buf);
   }
} // end of namespace ROOT for class ::TArrayC

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TArrayD(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TArrayD : new ::TArrayD;
   }
   static void *newArray_TArrayD(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TArrayD[nElements] : new ::TArrayD[nElements];
   }
   // Wrapper around operator delete
   static void delete_TArrayD(void *p) {
      delete ((::TArrayD*)p);
   }
   static void deleteArray_TArrayD(void *p) {
      delete [] ((::TArrayD*)p);
   }
   static void destruct_TArrayD(void *p) {
      typedef ::TArrayD current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TArrayD(TBuffer &buf, void *obj) {
      ((::TArrayD*)obj)->::TArrayD::Streamer(buf);
   }
} // end of namespace ROOT for class ::TArrayD

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TArrayF(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TArrayF : new ::TArrayF;
   }
   static void *newArray_TArrayF(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TArrayF[nElements] : new ::TArrayF[nElements];
   }
   // Wrapper around operator delete
   static void delete_TArrayF(void *p) {
      delete ((::TArrayF*)p);
   }
   static void deleteArray_TArrayF(void *p) {
      delete [] ((::TArrayF*)p);
   }
   static void destruct_TArrayF(void *p) {
      typedef ::TArrayF current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TArrayF(TBuffer &buf, void *obj) {
      ((::TArrayF*)obj)->::TArrayF::Streamer(buf);
   }
} // end of namespace ROOT for class ::TArrayF

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TArrayI(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TArrayI : new ::TArrayI;
   }
   static void *newArray_TArrayI(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TArrayI[nElements] : new ::TArrayI[nElements];
   }
   // Wrapper around operator delete
   static void delete_TArrayI(void *p) {
      delete ((::TArrayI*)p);
   }
   static void deleteArray_TArrayI(void *p) {
      delete [] ((::TArrayI*)p);
   }
   static void destruct_TArrayI(void *p) {
      typedef ::TArrayI current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TArrayI(TBuffer &buf, void *obj) {
      ((::TArrayI*)obj)->::TArrayI::Streamer(buf);
   }
} // end of namespace ROOT for class ::TArrayI

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TArrayL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TArrayL : new ::TArrayL;
   }
   static void *newArray_TArrayL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TArrayL[nElements] : new ::TArrayL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TArrayL(void *p) {
      delete ((::TArrayL*)p);
   }
   static void deleteArray_TArrayL(void *p) {
      delete [] ((::TArrayL*)p);
   }
   static void destruct_TArrayL(void *p) {
      typedef ::TArrayL current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TArrayL(TBuffer &buf, void *obj) {
      ((::TArrayL*)obj)->::TArrayL::Streamer(buf);
   }
} // end of namespace ROOT for class ::TArrayL

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TArrayL64(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TArrayL64 : new ::TArrayL64;
   }
   static void *newArray_TArrayL64(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TArrayL64[nElements] : new ::TArrayL64[nElements];
   }
   // Wrapper around operator delete
   static void delete_TArrayL64(void *p) {
      delete ((::TArrayL64*)p);
   }
   static void deleteArray_TArrayL64(void *p) {
      delete [] ((::TArrayL64*)p);
   }
   static void destruct_TArrayL64(void *p) {
      typedef ::TArrayL64 current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TArrayL64(TBuffer &buf, void *obj) {
      ((::TArrayL64*)obj)->::TArrayL64::Streamer(buf);
   }
} // end of namespace ROOT for class ::TArrayL64

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TArrayS(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TArrayS : new ::TArrayS;
   }
   static void *newArray_TArrayS(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TArrayS[nElements] : new ::TArrayS[nElements];
   }
   // Wrapper around operator delete
   static void delete_TArrayS(void *p) {
      delete ((::TArrayS*)p);
   }
   static void deleteArray_TArrayS(void *p) {
      delete [] ((::TArrayS*)p);
   }
   static void destruct_TArrayS(void *p) {
      typedef ::TArrayS current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TArrayS(TBuffer &buf, void *obj) {
      ((::TArrayS*)obj)->::TArrayS::Streamer(buf);
   }
} // end of namespace ROOT for class ::TArrayS

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TBits::Class(),this);
   } else {
      R__b.WriteClassBuffer(TBits::Class(),this);
   }
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TBits(void *p) {
      return  p ? new(p) ::TBits : new ::TBits;
   }
   static void *newArray_TBits(Long_t nElements, void *p) {
      return p ? new(p) ::TBits[nElements] : new ::TBits[nElements];
   }
   // Wrapper around operator delete
   static void delete_TBits(void *p) {
      delete ((::TBits*)p);
   }
   static void deleteArray_TBits(void *p) {
      delete [] ((::TBits*)p);
   }
   static void destruct_TBits(void *p) {
      typedef ::TBits current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TBits

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TCollection(void *p) {
      delete ((::TCollection*)p);
   }
   static void deleteArray_TCollection(void *p) {
      delete [] ((::TCollection*)p);
   }
   static void destruct_TCollection(void *p) {
      typedef ::TCollection current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TCollection(TBuffer &buf, void *obj) {
      ((::TCollection*)obj)->::TCollection::Streamer(buf);
   }
} // end of namespace ROOT for class ::TCollection

//______________________________________________________________________________
void TBtree::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TBtree.
      TClass *R__cl = ::TBtree::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRoot", &fRoot);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrder", &fOrder);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrder2", &fOrder2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInnerLowWaterMark", &fInnerLowWaterMark);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLeafLowWaterMark", &fLeafLowWaterMark);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInnerMaxIndex", &fInnerMaxIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLeafMaxIndex", &fLeafMaxIndex);
      TSeqCollection::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TBtree(void *p) {
      return  p ? new(p) ::TBtree : new ::TBtree;
   }
   static void *newArray_TBtree(Long_t nElements, void *p) {
      return p ? new(p) ::TBtree[nElements] : new ::TBtree[nElements];
   }
   // Wrapper around operator delete
   static void delete_TBtree(void *p) {
      delete ((::TBtree*)p);
   }
   static void deleteArray_TBtree(void *p) {
      delete [] ((::TBtree*)p);
   }
   static void destruct_TBtree(void *p) {
      typedef ::TBtree current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TBtree(TBuffer &buf, void *obj) {
      ((::TBtree*)obj)->::TBtree::Streamer(buf);
   }
} // end of namespace ROOT for class ::TBtree

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

   TIterator::Streamer(R__b);
}

//______________________________________________________________________________
void TBtreeIter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TBtreeIter.
      TClass *R__cl = ::TBtreeIter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTree", &fTree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurCursor", &fCurCursor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCursor", &fCursor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDirection", &fDirection);
      TIterator::ShowMembers(R__insp);
      R__insp.GenericShowMembers("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>", ( ::iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&> *) (this ), false);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TBtreeIter(void *p) {
      delete ((::TBtreeIter*)p);
   }
   static void deleteArray_TBtreeIter(void *p) {
      delete [] ((::TBtreeIter*)p);
   }
   static void destruct_TBtreeIter(void *p) {
      typedef ::TBtreeIter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TBtreeIter(TBuffer &buf, void *obj) {
      ((::TBtreeIter*)obj)->::TBtreeIter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TBtreeIter

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

   TObject::Streamer(R__b);
}

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TClassTable(void *p) {
      delete ((::TClassTable*)p);
   }
   static void deleteArray_TClassTable(void *p) {
      delete [] ((::TClassTable*)p);
   }
   static void destruct_TClassTable(void *p) {
      typedef ::TClassTable current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TClassTable(TBuffer &buf, void *obj) {
      ((::TClassTable*)obj)->::TClassTable::Streamer(buf);
   }
} // end of namespace ROOT for class ::TClassTable

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TClonesArray(void *p) {
      return  p ? new(p) ::TClonesArray : new ::TClonesArray;
   }
   static void *newArray_TClonesArray(Long_t nElements, void *p) {
      return p ? new(p) ::TClonesArray[nElements] : new ::TClonesArray[nElements];
   }
   // Wrapper around operator delete
   static void delete_TClonesArray(void *p) {
      delete ((::TClonesArray*)p);
   }
   static void deleteArray_TClonesArray(void *p) {
      delete [] ((::TClonesArray*)p);
   }
   static void destruct_TClonesArray(void *p) {
      typedef ::TClonesArray current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TClonesArray(TBuffer &buf, void *obj) {
      ((::TClonesArray*)obj)->::TClonesArray::Streamer(buf);
   }
} // end of namespace ROOT for class ::TClonesArray

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

   TCollection::Streamer(R__b);
}

//______________________________________________________________________________
void THashTable::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class THashTable.
      TClass *R__cl = ::THashTable::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCont", &fCont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEntries", &fEntries);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUsedSlots", &fUsedSlots);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRehashLevel", &fRehashLevel);
      TCollection::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_THashTable(void *p) {
      return  p ? new(p) ::THashTable : new ::THashTable;
   }
   static void *newArray_THashTable(Long_t nElements, void *p) {
      return p ? new(p) ::THashTable[nElements] : new ::THashTable[nElements];
   }
   // Wrapper around operator delete
   static void delete_THashTable(void *p) {
      delete ((::THashTable*)p);
   }
   static void deleteArray_THashTable(void *p) {
      delete [] ((::THashTable*)p);
   }
   static void destruct_THashTable(void *p) {
      typedef ::THashTable current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_THashTable(TBuffer &buf, void *obj) {
      ((::THashTable*)obj)->::THashTable::Streamer(buf);
   }
} // end of namespace ROOT for class ::THashTable

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

   TIterator::Streamer(R__b);
}

//______________________________________________________________________________
void THashTableIter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class THashTableIter.
      TClass *R__cl = ::THashTableIter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTable", &fTable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCursor", &fCursor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fListCursor", &fListCursor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDirection", &fDirection);
      TIterator::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_THashTableIter(void *p) {
      delete ((::THashTableIter*)p);
   }
   static void deleteArray_THashTableIter(void *p) {
      delete [] ((::THashTableIter*)p);
   }
   static void destruct_THashTableIter(void *p) {
      typedef ::THashTableIter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_THashTableIter(TBuffer &buf, void *obj) {
      ((::THashTableIter*)obj)->::THashTableIter::Streamer(buf);
   }
} // end of namespace ROOT for class ::THashTableIter

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

   ::Error("TIter::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TIter(void *p) {
      delete ((::TIter*)p);
   }
   static void deleteArray_TIter(void *p) {
      delete [] ((::TIter*)p);
   }
   static void destruct_TIter(void *p) {
      typedef ::TIter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TIter(TBuffer &buf, void *obj) {
      ((::TIter*)obj)->::TIter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TIter

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

   ::Error("TIterator::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TIterator(void *p) {
      delete ((::TIterator*)p);
   }
   static void deleteArray_TIterator(void *p) {
      delete [] ((::TIterator*)p);
   }
   static void destruct_TIterator(void *p) {
      typedef ::TIterator current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TIterator(TBuffer &buf, void *obj) {
      ((::TIterator*)obj)->::TIterator::Streamer(buf);
   }
} // end of namespace ROOT for class ::TIterator

//______________________________________________________________________________
void TList::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TList.
      TClass *R__cl = ::TList::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFirst", &fFirst);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLast", &fLast);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCache", &fCache);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAscending", &fAscending);
      TSeqCollection::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TList(void *p) {
      return  p ? new(p) ::TList : new ::TList;
   }
   static void *newArray_TList(Long_t nElements, void *p) {
      return p ? new(p) ::TList[nElements] : new ::TList[nElements];
   }
   // Wrapper around operator delete
   static void delete_TList(void *p) {
      delete ((::TList*)p);
   }
   static void deleteArray_TList(void *p) {
      delete [] ((::TList*)p);
   }
   static void destruct_TList(void *p) {
      typedef ::TList current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TList(TBuffer &buf, void *obj) {
      ((::TList*)obj)->::TList::Streamer(buf);
   }
} // end of namespace ROOT for class ::TList

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

   TIterator::Streamer(R__b);
}

//______________________________________________________________________________
void TListIter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TListIter.
      TClass *R__cl = ::TListIter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fList", &fList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurCursor", &fCurCursor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCursor", &fCursor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDirection", &fDirection);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStarted", &fStarted);
      TIterator::ShowMembers(R__insp);
      R__insp.GenericShowMembers("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>", ( ::iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&> *) (this ), false);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TListIter(void *p) {
      delete ((::TListIter*)p);
   }
   static void deleteArray_TListIter(void *p) {
      delete [] ((::TListIter*)p);
   }
   static void destruct_TListIter(void *p) {
      typedef ::TListIter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TListIter(TBuffer &buf, void *obj) {
      ((::TListIter*)obj)->::TListIter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TListIter

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

   TList::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_THashList(void *p) {
      return  p ? new(p) ::THashList : new ::THashList;
   }
   static void *newArray_THashList(Long_t nElements, void *p) {
      return p ? new(p) ::THashList[nElements] : new ::THashList[nElements];
   }
   // Wrapper around operator delete
   static void delete_THashList(void *p) {
      delete ((::THashList*)p);
   }
   static void deleteArray_THashList(void *p) {
      delete [] ((::THashList*)p);
   }
   static void destruct_THashList(void *p) {
      typedef ::THashList current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_THashList(TBuffer &buf, void *obj) {
      ((::THashList*)obj)->::THashList::Streamer(buf);
   }
} // end of namespace ROOT for class ::THashList

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMap(void *p) {
      return  p ? new(p) ::TMap : new ::TMap;
   }
   static void *newArray_TMap(Long_t nElements, void *p) {
      return p ? new(p) ::TMap[nElements] : new ::TMap[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMap(void *p) {
      delete ((::TMap*)p);
   }
   static void deleteArray_TMap(void *p) {
      delete [] ((::TMap*)p);
   }
   static void destruct_TMap(void *p) {
      typedef ::TMap current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMap(TBuffer &buf, void *obj) {
      ((::TMap*)obj)->::TMap::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMap

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

   TIterator::Streamer(R__b);
}

//______________________________________________________________________________
void TMapIter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMapIter.
      TClass *R__cl = ::TMapIter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMap", &fMap);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCursor", &fCursor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDirection", &fDirection);
      TIterator::ShowMembers(R__insp);
      R__insp.GenericShowMembers("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>", ( ::iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&> *) (this ), false);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TMapIter(void *p) {
      delete ((::TMapIter*)p);
   }
   static void deleteArray_TMapIter(void *p) {
      delete [] ((::TMapIter*)p);
   }
   static void destruct_TMapIter(void *p) {
      typedef ::TMapIter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMapIter(TBuffer &buf, void *obj) {
      ((::TMapIter*)obj)->::TMapIter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMapIter

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

   TObject::Streamer(R__b);
}

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TPair(void *p) {
      delete ((::TPair*)p);
   }
   static void deleteArray_TPair(void *p) {
      delete [] ((::TPair*)p);
   }
   static void destruct_TPair(void *p) {
      typedef ::TPair current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TPair(TBuffer &buf, void *obj) {
      ((::TPair*)obj)->::TPair::Streamer(buf);
   }
} // end of namespace ROOT for class ::TPair

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TObjArray(void *p) {
      return  p ? new(p) ::TObjArray : new ::TObjArray;
   }
   static void *newArray_TObjArray(Long_t nElements, void *p) {
      return p ? new(p) ::TObjArray[nElements] : new ::TObjArray[nElements];
   }
   // Wrapper around operator delete
   static void delete_TObjArray(void *p) {
      delete ((::TObjArray*)p);
   }
   static void deleteArray_TObjArray(void *p) {
      delete [] ((::TObjArray*)p);
   }
   static void destruct_TObjArray(void *p) {
      typedef ::TObjArray current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TObjArray(TBuffer &buf, void *obj) {
      ((::TObjArray*)obj)->::TObjArray::Streamer(buf);
   }
} // end of namespace ROOT for class ::TObjArray

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

   TIterator::Streamer(R__b);
}

//______________________________________________________________________________
void TObjArrayIter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TObjArrayIter.
      TClass *R__cl = ::TObjArrayIter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fArray", &fArray);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurCursor", &fCurCursor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCursor", &fCursor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDirection", &fDirection);
      TIterator::ShowMembers(R__insp);
      R__insp.GenericShowMembers("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>", ( ::iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&> *) (this ), false);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TObjArrayIter(void *p) {
      delete ((::TObjArrayIter*)p);
   }
   static void deleteArray_TObjArrayIter(void *p) {
      delete [] ((::TObjArrayIter*)p);
   }
   static void destruct_TObjArrayIter(void *p) {
      typedef ::TObjArrayIter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TObjArrayIter(TBuffer &buf, void *obj) {
      ((::TObjArrayIter*)obj)->::TObjArrayIter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TObjArrayIter

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

   TObject::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TObjectTable(void *p) {
      return  p ? new(p) ::TObjectTable : new ::TObjectTable;
   }
   static void *newArray_TObjectTable(Long_t nElements, void *p) {
      return p ? new(p) ::TObjectTable[nElements] : new ::TObjectTable[nElements];
   }
   // Wrapper around operator delete
   static void delete_TObjectTable(void *p) {
      delete ((::TObjectTable*)p);
   }
   static void deleteArray_TObjectTable(void *p) {
      delete [] ((::TObjectTable*)p);
   }
   static void destruct_TObjectTable(void *p) {
      typedef ::TObjectTable current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TObjectTable(TBuffer &buf, void *obj) {
      ((::TObjectTable*)obj)->::TObjectTable::Streamer(buf);
   }
} // end of namespace ROOT for class ::TObjectTable

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

   TSeqCollection::Streamer(R__b);
}

//______________________________________________________________________________
void TOrdCollection::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TOrdCollection.
      TClass *R__cl = ::TOrdCollection::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCont", &fCont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCapacity", &fCapacity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGapStart", &fGapStart);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGapSize", &fGapSize);
      TSeqCollection::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TOrdCollection(void *p) {
      return  p ? new(p) ::TOrdCollection : new ::TOrdCollection;
   }
   static void *newArray_TOrdCollection(Long_t nElements, void *p) {
      return p ? new(p) ::TOrdCollection[nElements] : new ::TOrdCollection[nElements];
   }
   // Wrapper around operator delete
   static void delete_TOrdCollection(void *p) {
      delete ((::TOrdCollection*)p);
   }
   static void deleteArray_TOrdCollection(void *p) {
      delete [] ((::TOrdCollection*)p);
   }
   static void destruct_TOrdCollection(void *p) {
      typedef ::TOrdCollection current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TOrdCollection(TBuffer &buf, void *obj) {
      ((::TOrdCollection*)obj)->::TOrdCollection::Streamer(buf);
   }
} // end of namespace ROOT for class ::TOrdCollection

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

   TIterator::Streamer(R__b);
}

//______________________________________________________________________________
void TOrdCollectionIter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TOrdCollectionIter.
      TClass *R__cl = ::TOrdCollectionIter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCol", &fCol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurCursor", &fCurCursor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCursor", &fCursor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDirection", &fDirection);
      TIterator::ShowMembers(R__insp);
      R__insp.GenericShowMembers("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>", ( ::iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&> *) (this ), false);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TOrdCollectionIter(void *p) {
      delete ((::TOrdCollectionIter*)p);
   }
   static void deleteArray_TOrdCollectionIter(void *p) {
      delete [] ((::TOrdCollectionIter*)p);
   }
   static void destruct_TOrdCollectionIter(void *p) {
      typedef ::TOrdCollectionIter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TOrdCollectionIter(TBuffer &buf, void *obj) {
      ((::TOrdCollectionIter*)obj)->::TOrdCollectionIter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TOrdCollectionIter

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

   TCollection::Streamer(R__b);
}

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TSeqCollection(void *p) {
      delete ((::TSeqCollection*)p);
   }
   static void deleteArray_TSeqCollection(void *p) {
      delete [] ((::TSeqCollection*)p);
   }
   static void destruct_TSeqCollection(void *p) {
      typedef ::TSeqCollection current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TSeqCollection(TBuffer &buf, void *obj) {
      ((::TSeqCollection*)obj)->::TSeqCollection::Streamer(buf);
   }
} // end of namespace ROOT for class ::TSeqCollection

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

   TList::Streamer(R__b);
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSortedList(void *p) {
      return  p ? new(p) ::TSortedList : new ::TSortedList;
   }
   static void *newArray_TSortedList(Long_t nElements, void *p) {
      return p ? new(p) ::TSortedList[nElements] : new ::TSortedList[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSortedList(void *p) {
      delete ((::TSortedList*)p);
   }
   static void deleteArray_TSortedList(void *p) {
      delete [] ((::TSortedList*)p);
   }
   static void destruct_TSortedList(void *p) {
      typedef ::TSortedList current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TSortedList(TBuffer &buf, void *obj) {
      ((::TSortedList*)obj)->::TSortedList::Streamer(buf);
   }
} // end of namespace ROOT for class ::TSortedList

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TExMap(void *p) {
      return  p ? new(p) ::TExMap : new ::TExMap;
   }
   static void *newArray_TExMap(Long_t nElements, void *p) {
      return p ? new(p) ::TExMap[nElements] : new ::TExMap[nElements];
   }
   // Wrapper around operator delete
   static void delete_TExMap(void *p) {
      delete ((::TExMap*)p);
   }
   static void deleteArray_TExMap(void *p) {
      delete [] ((::TExMap*)p);
   }
   static void destruct_TExMap(void *p) {
      typedef ::TExMap current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TExMap(TBuffer &buf, void *obj) {
      ((::TExMap*)obj)->::TExMap::Streamer(buf);
   }
} // end of namespace ROOT for class ::TExMap

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

   ::Error("TExMapIter::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TExMapIter(void *p) {
      delete ((::TExMapIter*)p);
   }
   static void deleteArray_TExMapIter(void *p) {
      delete [] ((::TExMapIter*)p);
   }
   static void destruct_TExMapIter(void *p) {
      typedef ::TExMapIter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TExMapIter(TBuffer &buf, void *obj) {
      ((::TExMapIter*)obj)->::TExMapIter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TExMapIter

//______________________________________________________________________________
void TRefArray::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TRefArray.
      TClass *R__cl = ::TRefArray::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPID", &fPID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUIDs", &fUIDs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLowerBound", &fLowerBound);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLast", &fLast);
      TSeqCollection::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TRefArray(void *p) {
      return  p ? new(p) ::TRefArray : new ::TRefArray;
   }
   static void *newArray_TRefArray(Long_t nElements, void *p) {
      return p ? new(p) ::TRefArray[nElements] : new ::TRefArray[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRefArray(void *p) {
      delete ((::TRefArray*)p);
   }
   static void deleteArray_TRefArray(void *p) {
      delete [] ((::TRefArray*)p);
   }
   static void destruct_TRefArray(void *p) {
      typedef ::TRefArray current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TRefArray(TBuffer &buf, void *obj) {
      ((::TRefArray*)obj)->::TRefArray::Streamer(buf);
   }
} // end of namespace ROOT for class ::TRefArray

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

   TIterator::Streamer(R__b);
}

//______________________________________________________________________________
void TRefArrayIter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TRefArrayIter.
      TClass *R__cl = ::TRefArrayIter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fArray", &fArray);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurCursor", &fCurCursor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCursor", &fCursor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDirection", &fDirection);
      TIterator::ShowMembers(R__insp);
      R__insp.GenericShowMembers("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>", ( ::iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&> *) (this ), false);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TRefArrayIter(void *p) {
      delete ((::TRefArrayIter*)p);
   }
   static void deleteArray_TRefArrayIter(void *p) {
      delete [] ((::TRefArrayIter*)p);
   }
   static void destruct_TRefArrayIter(void *p) {
      typedef ::TRefArrayIter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TRefArrayIter(TBuffer &buf, void *obj) {
      ((::TRefArrayIter*)obj)->::TRefArrayIter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TRefArrayIter

//______________________________________________________________________________
void TRefTable::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TRefTable.
      TClass *R__cl = ::TRefTable::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumPIDs", &fNumPIDs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAllocSize", &fAllocSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fN", &fN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParentIDs", &fParentIDs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParentID", &fParentID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefaultSize", &fDefaultSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUID", &fUID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUIDContext", &fUIDContext);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParents", &fParents);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOwner", &fOwner);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fProcessGUIDs", (void*)&fProcessGUIDs);
      R__insp.InspectMember("vector<std::string>", (void*)&fProcessGUIDs, "fProcessGUIDs.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMapPIDtoInternal", (void*)&fMapPIDtoInternal);
      R__insp.InspectMember("vector<Int_t>", (void*)&fMapPIDtoInternal, "fMapPIDtoInternal.", true);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TRefTable(void *p) {
      return  p ? new(p) ::TRefTable : new ::TRefTable;
   }
   static void *newArray_TRefTable(Long_t nElements, void *p) {
      return p ? new(p) ::TRefTable[nElements] : new ::TRefTable[nElements];
   }
   // Wrapper around operator delete
   static void delete_TRefTable(void *p) {
      delete ((::TRefTable*)p);
   }
   static void deleteArray_TRefTable(void *p) {
      delete [] ((::TRefTable*)p);
   }
   static void destruct_TRefTable(void *p) {
      typedef ::TRefTable current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TRefTable(TBuffer &buf, void *obj) {
      ((::TRefTable*)obj)->::TRefTable::Streamer(buf);
   }
} // end of namespace ROOT for class ::TRefTable

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TVirtualCollectionProxy(void *p) {
      delete ((::TVirtualCollectionProxy*)p);
   }
   static void deleteArray_TVirtualCollectionProxy(void *p) {
      delete [] ((::TVirtualCollectionProxy*)p);
   }
   static void destruct_TVirtualCollectionProxy(void *p) {
      typedef ::TVirtualCollectionProxy current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TVirtualCollectionProxy

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEintcOallocatorlEintgRsPgRcLcLiterator(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::vector<int,allocator<int> >::iterator : new ::vector<int,allocator<int> >::iterator;
   }
   static void *newArray_vectorlEintcOallocatorlEintgRsPgRcLcLiterator(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::vector<int,allocator<int> >::iterator[nElements] : new ::vector<int,allocator<int> >::iterator[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEintcOallocatorlEintgRsPgRcLcLiterator(void *p) {
      delete ((::vector<int,allocator<int> >::iterator*)p);
   }
   static void deleteArray_vectorlEintcOallocatorlEintgRsPgRcLcLiterator(void *p) {
      delete [] ((::vector<int,allocator<int> >::iterator*)p);
   }
   static void destruct_vectorlEintcOallocatorlEintgRsPgRcLcLiterator(void *p) {
      typedef ::vector<int,allocator<int> >::iterator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::vector<int,allocator<int> >::iterator

namespace ROOT {
   // Wrappers around operator new
   static void *new_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::reverse_iterator<vector<int,allocator<int> >::iterator> : new ::reverse_iterator<vector<int,allocator<int> >::iterator>;
   }
   static void *newArray_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::reverse_iterator<vector<int,allocator<int> >::iterator>[nElements] : new ::reverse_iterator<vector<int,allocator<int> >::iterator>[nElements];
   }
   // Wrapper around operator delete
   static void delete_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR(void *p) {
      delete ((::reverse_iterator<vector<int,allocator<int> >::iterator>*)p);
   }
   static void deleteArray_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR(void *p) {
      delete [] ((::reverse_iterator<vector<int,allocator<int> >::iterator>*)p);
   }
   static void destruct_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR(void *p) {
      typedef ::reverse_iterator<vector<int,allocator<int> >::iterator> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::reverse_iterator<vector<int,allocator<int> >::iterator>

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TBitscLcLTReference(void *p) {
      delete ((::TBits::TReference*)p);
   }
   static void deleteArray_TBitscLcLTReference(void *p) {
      delete [] ((::TBits::TReference*)p);
   }
   static void destruct_TBitscLcLTReference(void *p) {
      typedef ::TBits::TReference current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TBits::TReference

namespace ROOT {
   void vectorlEintgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEintgR_Dictionary();
   static void *new_vectorlEintgR(void *p = 0);
   static void *newArray_vectorlEintgR(Long_t size, void *p);
   static void delete_vectorlEintgR(void *p);
   static void deleteArray_vectorlEintgR(void *p);
   static void destruct_vectorlEintgR(void *p);

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

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

} // end of namespace ROOT

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

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

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

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

} // end of namespace ROOT

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

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

#ifdef G__MEMTEST
#undef malloc
#undef free
#endif

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

extern "C" void G__cpp_reset_tagtableG__Cont();

extern "C" void G__set_cpp_environmentG__Cont() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TArrayC.h");
  G__add_compiledheader("TArrayD.h");
  G__add_compiledheader("TArrayF.h");
  G__add_compiledheader("TArray.h");
  G__add_compiledheader("TArrayI.h");
  G__add_compiledheader("TArrayL64.h");
  G__add_compiledheader("TArrayL.h");
  G__add_compiledheader("TArrayS.h");
  G__add_compiledheader("TBits.h");
  G__add_compiledheader("TBtree.h");
  G__add_compiledheader("TClassTable.h");
  G__add_compiledheader("TClonesArray.h");
  G__add_compiledheader("TCollection.h");
  G__add_compiledheader("TCollectionProxyInfo.h");
  G__add_compiledheader("TExMap.h");
  G__add_compiledheader("THashList.h");
  G__add_compiledheader("THashTable.h");
  G__add_compiledheader("TIterator.h");
  G__add_compiledheader("TList.h");
  G__add_compiledheader("TMap.h");
  G__add_compiledheader("TObjArray.h");
  G__add_compiledheader("TObjectTable.h");
  G__add_compiledheader("TOrdCollection.h");
  G__add_compiledheader("TRefArray.h");
  G__add_compiledheader("TRefTable.h");
  G__add_compiledheader("TSeqCollection.h");
  G__add_compiledheader("TSortedList.h");
  G__add_compiledheader("TVirtualCollectionProxy.h");
  G__cpp_reset_tagtableG__Cont();
}
#include <new>
extern "C" int G__cpp_dllrevG__Cont() { return(30051515); }

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

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

static int G__G__Cont_17_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TVirtualCollectionProxy*) G__getstructoffset())->GetCollectionClass());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Cont_17_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TVirtualCollectionProxy*) G__getstructoffset())->GetIncrement());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Cont_17_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TVirtualCollectionProxy*) G__getstructoffset())->New());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_17_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TVirtualCollectionProxy*) G__getstructoffset())->New((void*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Cont_17_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TVirtualCollectionProxy*) G__getstructoffset())->NewArray((Int_t) G__int(libp->para[0]), (void*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__G__Cont_17_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TVirtualCollectionProxy*) G__getstructoffset())->GetValueClass());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Cont_17_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((TVirtualCollectionProxy*) G__getstructoffset())->At((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Cont_17_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((TVirtualCollectionProxy*) G__getstructoffset())->Allocate((UInt_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Cont_17_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TVirtualCollectionProxy*) G__getstructoffset())->operator[]((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Cont_17_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TVirtualCollectionProxy*) G__getstructoffset())->GetWriteMemberWiseActions());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_17_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 89, (long) ((TVirtualCollectionProxy*) G__getstructoffset())->GetFunctionCreateIterators((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 89, (long) ((TVirtualCollectionProxy*) G__getstructoffset())->GetFunctionCreateIterators());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_17_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 89, (long) ((TVirtualCollectionProxy*) G__getstructoffset())->GetFunctionCopyIterator((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 89, (long) ((TVirtualCollectionProxy*) G__getstructoffset())->GetFunctionCopyIterator());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_17_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 89, (long) ((TVirtualCollectionProxy*) G__getstructoffset())->GetFunctionNext((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 89, (long) ((TVirtualCollectionProxy*) G__getstructoffset())->GetFunctionNext());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_17_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 89, (long) ((TVirtualCollectionProxy*) G__getstructoffset())->GetFunctionDeleteIterator((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 89, (long) ((TVirtualCollectionProxy*) G__getstructoffset())->GetFunctionDeleteIterator());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_17_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 89, (long) ((TVirtualCollectionProxy*) G__getstructoffset())->GetFunctionDeleteTwoIterators((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 89, (long) ((TVirtualCollectionProxy*) G__getstructoffset())->GetFunctionDeleteTwoIterators());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

static int G__G__Cont_76_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TList*) G__getstructoffset())->Add((TObject*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_76_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TList*) G__getstructoffset())->AddFirst((TObject*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_76_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TList*) G__getstructoffset())->AddLast((TObject*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_76_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TList*) G__getstructoffset())->AddAfter((TObjLink*) G__int(libp->para[0]), (TObject*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_76_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TList*) G__getstructoffset())->AddBefore((TObjLink*) G__int(libp->para[0]), (TObject*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_76_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TList*) G__getstructoffset())->Remove((TObjLink*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

static int G__G__Cont_78_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TObjArray*) G__getstructoffset())->AddAtAndExpand((TObject*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Cont_78_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TObject*& obj = ((TObjArray*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__Cont_78_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TObjArray*) G__getstructoffset())->BinarySearch((TObject*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TObjArray*) G__getstructoffset())->BinarySearch((TObject*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

static int G__G__Cont_87_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TClonesArray* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TClonesArray(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TClonesArray(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TClonesArray((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TClonesArray((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TClonesArray((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TClonesArray((const char*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TClonesArray));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_87_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TClonesArray* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TClonesArray(
(TClass*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TClonesArray(
(TClass*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TClonesArray((TClass*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TClonesArray((TClass*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TClonesArray((TClass*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TClonesArray((TClass*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TClonesArray));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

static int G__G__Cont_87_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TClonesArray*) G__getstructoffset())->SetClass((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TClonesArray*) G__getstructoffset())->SetClass((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_87_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TClonesArray*) G__getstructoffset())->SetClass((TClass*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TClonesArray*) G__getstructoffset())->SetClass((TClass*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__Cont_88_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRefTable* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TRefTable((TObject*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TRefTable((TObject*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TRefTable));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_88_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TRefTable*) G__getstructoffset())->Add((Int_t) G__int(libp->para[0]), (TProcessID*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TRefTable*) G__getstructoffset())->Add((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

static int G__G__Cont_88_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((const TRefTable*) G__getstructoffset())->GetParent((Int_t) G__int(libp->para[0]), (TProcessID*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const TRefTable*) G__getstructoffset())->GetParent((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__G__Cont_88_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TRefTable::SetRefTable((TRefTable*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

static int G__G__Cont_99_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TArray*) G__getstructoffset())->SetAt((Double_t) G__double(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_99_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TArray::ReadArray(*(TBuffer*) libp->para[0].ref, (TClass*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_99_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TArray::WriteArray(*(TBuffer*) libp->para[0].ref, (TArray*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

static int G__G__Cont_100_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TArrayC* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TArrayC((Int_t) G__int(libp->para[0]), (const Char_t*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TArrayC((Int_t) G__int(libp->para[0]), (const Char_t*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TArrayC));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Cont_100_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TArrayC*) G__getstructoffset())->Adopt((Int_t) G__int(libp->para[0]), (Char_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_100_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TArrayC*) G__getstructoffset())->AddAt((Char_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Cont_100_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TArrayC*) G__getstructoffset())->Copy(*(TArrayC*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_100_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TArrayC*) G__getstructoffset())->GetArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_100_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TArrayC*) G__getstructoffset())->GetArray());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Cont_100_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Char_t& obj = ((TArrayC*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'c', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

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

static int G__G__Cont_101_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TArrayD* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TArrayD((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TArrayD((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TArrayD));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Cont_101_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TArrayD*) G__getstructoffset())->Adopt((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_101_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TArrayD*) G__getstructoffset())->AddAt((Double_t) G__double(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Cont_101_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TArrayD*) G__getstructoffset())->Copy(*(TArrayD*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_101_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TArrayD*) G__getstructoffset())->GetArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_101_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TArrayD*) G__getstructoffset())->GetArray());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Cont_101_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TArrayD*) G__getstructoffset())->Reset((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Cont_101_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TArrayD*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

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

static int G__G__Cont_102_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TArrayF* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TArrayF((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TArrayF((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TArrayF));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Cont_102_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TArrayF*) G__getstructoffset())->Adopt((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_102_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TArrayF*) G__getstructoffset())->AddAt((Float_t) G__double(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Cont_102_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TArrayF*) G__getstructoffset())->Copy(*(TArrayF*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_102_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TArrayF*) G__getstructoffset())->GetArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_102_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((TArrayF*) G__getstructoffset())->GetArray());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Cont_102_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TArrayF*) G__getstructoffset())->Reset((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Cont_102_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Float_t& obj = ((TArrayF*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

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

static int G__G__Cont_103_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TArrayI* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TArrayI((Int_t) G__int(libp->para[0]), (const Int_t*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TArrayI((Int_t) G__int(libp->para[0]), (const Int_t*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TArrayI));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__Cont_103_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TArrayI*) G__getstructoffset())->Copy(*(TArrayI*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_103_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TArrayI*) G__getstructoffset())->GetArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_103_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((TArrayI*) G__getstructoffset())->GetArray());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

static int G__G__Cont_104_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TArrayL64* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TArrayL64((Int_t) G__int(libp->para[0]), (const Long64_t*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TArrayL64((Int_t) G__int(libp->para[0]), (const Long64_t*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TArrayL64));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Cont_104_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TArrayL64*) G__getstructoffset())->Adopt((Int_t) G__int(libp->para[0]), (Long64_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_104_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TArrayL64*) G__getstructoffset())->AddAt((Long64_t) G__Longlong(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_104_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TArrayL64*) G__getstructoffset())->At((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_104_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TArrayL64*) G__getstructoffset())->Copy(*(TArrayL64*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_104_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 78, (long) ((const TArrayL64*) G__getstructoffset())->GetArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_104_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 78, (long) ((TArrayL64*) G__getstructoffset())->GetArray());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Cont_104_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TArrayL64*) G__getstructoffset())->Reset((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Cont_104_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Long64_t& obj = ((TArrayL64*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'n', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_104_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TArrayL64*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

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

static int G__G__Cont_105_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TArrayL* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TArrayL((Int_t) G__int(libp->para[0]), (const Long_t*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TArrayL((Int_t) G__int(libp->para[0]), (const Long_t*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TArrayL));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Cont_105_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TArrayL*) G__getstructoffset())->Adopt((Int_t) G__int(libp->para[0]), (Long_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_105_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TArrayL*) G__getstructoffset())->AddAt((Long_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Cont_105_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TArrayL*) G__getstructoffset())->Copy(*(TArrayL*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_105_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 76, (long) ((const TArrayL*) G__getstructoffset())->GetArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_105_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 76, (long) ((TArrayL*) G__getstructoffset())->GetArray());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Cont_105_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Long_t& obj = ((TArrayL*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'l', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

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

static int G__G__Cont_106_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TArrayS* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TArrayS((Int_t) G__int(libp->para[0]), (const Short_t*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TArrayS((Int_t) G__int(libp->para[0]), (const Short_t*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TArrayS));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Cont_106_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TArrayS*) G__getstructoffset())->Adopt((Int_t) G__int(libp->para[0]), (Short_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_106_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TArrayS*) G__getstructoffset())->AddAt((Short_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Cont_106_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TArrayS*) G__getstructoffset())->Copy(*(TArrayS*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_106_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 83, (long) ((const TArrayS*) G__getstructoffset())->GetArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_106_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 83, (long) ((TArrayS*) G__getstructoffset())->GetArray());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Cont_106_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Short_t& obj = ((TArrayS*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 's', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

static int G__G__Cont_107_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TBits*) G__getstructoffset())->TestBitNumber((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Cont_107_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TBits*) G__getstructoffset())->operator[]((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Cont_107_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 104, (long) ((const TBits*) G__getstructoffset())->CountBits((UInt_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 104, (long) ((const TBits*) G__getstructoffset())->CountBits());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_107_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 104, (long) ((const TBits*) G__getstructoffset())->FirstNullBit((UInt_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 104, (long) ((const TBits*) G__getstructoffset())->FirstNullBit());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_107_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 104, (long) ((const TBits*) G__getstructoffset())->FirstSetBit((UInt_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 104, (long) ((const TBits*) G__getstructoffset())->FirstSetBit());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Cont_107_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TBits*) G__getstructoffset())->Output(*(ostream*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


/* TBits::TReference */
static int G__G__Cont_108_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBits::TReference* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TBits::TReference(*(TBits*) libp->para[0].ref, (UInt_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TBits::TReference(*(TBits*) libp->para[0].ref, (UInt_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TBitscLcLTReference));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Cont_108_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TBits::TReference*) G__getstructoffset())->operator Bool_t());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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


/* TCollection */
static int G__G__Cont_109_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TCollection*) G__getstructoffset())->Add((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_109_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   G__va_arg_buf G__va_arg_bufobj;
   G__va_arg_put(&G__va_arg_bufobj, libp, 1);
      ((TCollection*) G__getstructoffset())->AddVector((TObject*) G__int(libp->para[0]), G__va_arg_bufobj);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Cont_109_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TCollection*) G__getstructoffset())->AssertClass((TClass*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Cont_109_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TCollection*) G__getstructoffset())->Contains((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_109_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TCollection*) G__getstructoffset())->Contains((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__Cont_109_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TCollection*) G__getstructoffset())->IsArgNull((const char*) G__int(libp->para[0]), (TObject*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Cont_109_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TCollection*) G__getstructoffset())->MakeIterator((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TCollection*) G__getstructoffset())->MakeIterator());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Cont_109_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TCollection*) G__getstructoffset())->Print((Option_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_109_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((const TCollection*) G__getstructoffset())->Print((Option_t*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((const TCollection*) G__getstructoffset())->Print((Option_t*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_109_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((const TCollection*) G__getstructoffset())->Print((Option_t*) G__int(libp->para[0]), *(TPRegexp*) libp->para[1].ref
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((const TCollection*) G__getstructoffset())->Print((Option_t*) G__int(libp->para[0]), *(TPRegexp*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_109_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TCollection*) G__getstructoffset())->Remove((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__G__Cont_109_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TCollection::StartGarbageCollection();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_109_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TCollection::GarbageCollect((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_109_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TCollection::EmptyGarbageCollection();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

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

static int G__G__Cont_110_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TIterator*) G__getstructoffset())->GetOption());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_110_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TIterator*) G__getstructoffset())->Next());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Cont_110_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TIterator*) G__getstructoffset())->operator()());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

static int G__G__Cont_122_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((TObjectTable*) G__getstructoffset())->CheckPtrAndWarn((const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Cont_122_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TObjectTable*) G__getstructoffset())->InstanceStatistics();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_122_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TObjectTable*) G__getstructoffset())->PtrIsValid((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Cont_122_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TObjectTable*) G__getstructoffset())->UpdateInstCount();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_122_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TObjectTable::AddObj((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


/* TIter */
static int G__G__Cont_124_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TIter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TIter((TCollection*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TIter((TCollection*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TIter((TCollection*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TIter((TCollection*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TIter));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Cont_124_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TIter*) G__getstructoffset())->operator()());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_124_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TIter*) G__getstructoffset())->Next());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Cont_124_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TIter*) G__getstructoffset())->GetOption());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Cont_124_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TIter& obj = ((TIter*) G__getstructoffset())->operator++();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Cont_124_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TIter& obj = ((TIter*) G__getstructoffset())->Begin();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_124_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TIter* pobj;
         TIter xobj = TIter::End();
         pobj = new TIter(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


/* TSeqCollection */
static int G__G__Cont_125_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSeqCollection*) G__getstructoffset())->AddFirst((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Cont_125_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSeqCollection*) G__getstructoffset())->AddAt((TObject*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Cont_125_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((TSeqCollection*) G__getstructoffset())->Merge((TCollection*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_125_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSeqCollection::ObjCompare((TObject*) G__int(libp->para[0]), (TObject*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_125_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSeqCollection::QSort((TObject**) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_125_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSeqCollection::QSort((TObject**) G__int(libp->para[0]), (TObject**) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_125_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSeqCollection::QSort((TObject**) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TObject***) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


/* TBtreeIter */
static int G__G__Cont_129_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBtreeIter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBtreeIter((TBtree*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TBtreeIter((TBtree*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBtreeIter((TBtree*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TBtreeIter((TBtree*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TBtreeIter));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


/* TClassTable */
static int G__G__Cont_135_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TClassTable::Add((const char*) G__int(libp->para[0]), (Version_t) G__int(libp->para[1])
, *(type_info*) libp->para[2].ref, (VoidFuncPtr_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_135_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TClassTable::At((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Cont_135_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TClassTable::GetID((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_135_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TClassTable::GetPragmaBits((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_135_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) TClassTable::GetDict((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_135_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) TClassTable::GetDict(*(type_info*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_135_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TClassTable::Init();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Cont_135_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TClassTable::PrintTable();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_135_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TClassTable::Remove((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_135_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TClassTable::Terminate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


/* TObjArrayIter */
static int G__G__Cont_137_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TObjArrayIter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TObjArrayIter((TObjArray*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TObjArrayIter((TObjArray*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TObjArrayIter((TObjArray*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TObjArrayIter((TObjArray*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TObjArrayIter));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

static int G__G__Cont_148_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TExMapIter*) G__getstructoffset())->Next(*(ULong64_t*) G__ULonglongref(&libp->para[0]), *(Long64_t*) G__Longlongref(&libp->para[1])
, *(Long64_t*) G__Longlongref(&libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_148_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TExMapIter*) G__getstructoffset())->Next(*(Long64_t*) G__Longlongref(&libp->para[0]), *(Long64_t*) G__Longlongref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

static int G__G__Cont_149_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExMap*) G__getstructoffset())->Add((ULong64_t) G__ULonglong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_149_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExMap*) G__getstructoffset())->Add((Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_149_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExMap*) G__getstructoffset())->AddAt((UInt_t) G__int(libp->para[0]), (ULong64_t) G__ULonglong(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Cont_149_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((TExMap*) G__getstructoffset())->GetValue((ULong64_t) G__ULonglong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_149_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((TExMap*) G__getstructoffset())->GetValue((Long64_t) G__Longlong(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_149_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((TExMap*) G__getstructoffset())->GetValue((ULong64_t) G__ULonglong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, *(UInt_t*) G__UIntref(&libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_149_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExMap*) G__getstructoffset())->Remove((ULong64_t) G__ULonglong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_149_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TExMap*) G__getstructoffset())->Remove((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_149_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Long64_t& obj = ((TExMap*) G__getstructoffset())->operator()((ULong64_t) G__ULonglong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'n', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_149_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Long64_t& obj = ((TExMap*) G__getstructoffset())->operator()((Long64_t) G__Longlong(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'n', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


/* TListIter */
static int G__G__Cont_152_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TListIter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TListIter((TList*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TListIter((TList*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TListIter((TList*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TListIter((TList*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TListIter));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__Cont_152_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TListIter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TListIter G__TTListIter;
static int G__G__Cont_152_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TListIter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TListIter*) (soff+(sizeof(TListIter)*i)))->~G__TTListIter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TListIter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TListIter*) (soff))->~G__TTListIter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THashTable */
static int G__G__Cont_154_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THashTable* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THashTable((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) THashTable((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THashTable((Int_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) THashTable((Int_t) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new THashTable[n];
       } else {
         p = new((void*) gvp) THashTable[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new THashTable;
       } else {
         p = new((void*) gvp) THashTable;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_THashTable));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_154_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const THashTable*) G__getstructoffset())->AverageCollisions());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_154_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const THashTable*) G__getstructoffset())->Collisions((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_154_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const THashTable*) G__getstructoffset())->Collisions((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_154_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const THashTable*) G__getstructoffset())->GetListForObject((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_154_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const THashTable*) G__getstructoffset())->GetListForObject((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_154_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const THashTable*) G__getstructoffset())->GetRehashLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_154_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((THashTable*) G__getstructoffset())->Rehash((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((THashTable*) G__getstructoffset())->Rehash((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_154_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((THashTable*) G__getstructoffset())->RemoveSlow((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_154_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THashTable*) G__getstructoffset())->SetRehashLevel((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_154_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THashTable::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_154_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THashTable::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_154_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THashTable::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_154_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THashTable::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_154_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THashTable*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_154_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THashTable::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_154_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THashTable::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_154_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THashTable::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_154_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THashTable::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THashTable G__TTHashTable;
static int G__G__Cont_154_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (THashTable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THashTable*) (soff+(sizeof(THashTable)*i)))->~G__TTHashTable();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THashTable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THashTable*) (soff))->~G__TTHashTable();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THashList */
static int G__G__Cont_155_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THashList* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THashList((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) THashList((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THashList((Int_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) THashList((Int_t) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new THashList[n];
       } else {
         p = new((void*) gvp) THashList[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new THashList;
       } else {
         p = new((void*) gvp) THashList;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_THashList));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_155_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THashList* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THashList(
(TObject*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) THashList(
(TObject*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THashList((TObject*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) THashList((TObject*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THashList((TObject*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) THashList((TObject*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_THashList));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_155_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const THashList*) G__getstructoffset())->AverageCollisions());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_155_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const THashList*) G__getstructoffset())->GetListForObject((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_155_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const THashList*) G__getstructoffset())->GetListForObject((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_155_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THashList*) G__getstructoffset())->Rehash((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_155_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THashList::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_155_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THashList::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_155_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THashList::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_155_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THashList::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_155_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THashList*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_155_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THashList::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_155_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THashList::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_155_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THashList::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_155_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THashList::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THashList G__TTHashList;
static int G__G__Cont_155_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (THashList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THashList*) (soff+(sizeof(THashList)*i)))->~G__TTHashList();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THashList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THashList*) (soff))->~G__TTHashList();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THashTableIter */
static int G__G__Cont_156_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THashTableIter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THashTableIter((THashTable*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) THashTableIter((THashTable*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THashTableIter((THashTable*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) THashTableIter((THashTable*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_THashTableIter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_156_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THashTableIter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new THashTableIter(*(THashTableIter*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) THashTableIter(*(THashTableIter*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_THashTableIter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_156_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const THashTableIter& obj = ((THashTableIter*) G__getstructoffset())->operator=(*(THashTableIter*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_156_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const THashTableIter*) G__getstructoffset())->operator!=(*(THashTableIter*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_156_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THashTableIter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_156_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THashTableIter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_156_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THashTableIter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_156_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THashTableIter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_156_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THashTableIter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_156_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THashTableIter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_156_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THashTableIter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_156_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THashTableIter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_156_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THashTableIter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THashTableIter G__TTHashTableIter;
static int G__G__Cont_156_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (THashTableIter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THashTableIter*) (soff+(sizeof(THashTableIter)*i)))->~G__TTHashTableIter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THashTableIter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THashTableIter*) (soff))->~G__TTHashTableIter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMapIter */
static int G__G__Cont_157_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMapIter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMapIter((TMap*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TMapIter((TMap*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMapIter((TMap*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TMapIter((TMap*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TMapIter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_157_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMapIter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMapIter(*(TMapIter*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMapIter(*(TMapIter*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TMapIter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_157_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMapIter& obj = ((TMapIter*) G__getstructoffset())->operator=(*(TMapIter*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_157_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMapIter*) G__getstructoffset())->operator!=(*(TMapIter*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_157_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMapIter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_157_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMapIter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_157_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMapIter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_157_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMapIter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_157_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMapIter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_157_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMapIter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_157_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMapIter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_157_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMapIter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_157_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMapIter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMapIter G__TTMapIter;
static int G__G__Cont_157_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMapIter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMapIter*) (soff+(sizeof(TMapIter)*i)))->~G__TTMapIter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMapIter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMapIter*) (soff))->~G__TTMapIter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TPair */
static int G__G__Cont_158_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPair* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TPair((TObject*) G__int(libp->para[0]), (TObject*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TPair((TObject*) G__int(libp->para[0]), (TObject*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TPair));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_158_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TPair* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TPair(*(TPair*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TPair(*(TPair*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TPair));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_158_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TPair*) G__getstructoffset())->Key());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_158_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TPair*) G__getstructoffset())->Value());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_158_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPair*) G__getstructoffset())->SetValue((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_158_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TPair::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_158_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPair::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_158_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TPair::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_158_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TPair::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_158_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TPair*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_158_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPair::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_158_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPair::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_158_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TPair::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_158_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TPair::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TPair G__TTPair;
static int G__G__Cont_158_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TPair*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TPair*) (soff+(sizeof(TPair)*i)))->~G__TTPair();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TPair*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TPair*) (soff))->~G__TTPair();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMap */
static int G__G__Cont_159_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMap* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMap((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TMap((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMap((Int_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TMap((Int_t) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TMap[n];
       } else {
         p = new((void*) gvp) TMap[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TMap;
       } else {
         p = new((void*) gvp) TMap;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TMap));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMap*) G__getstructoffset())->Add((TObject*) G__int(libp->para[0]), (TObject*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMap*) G__getstructoffset())->AverageCollisions());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMap*) G__getstructoffset())->Capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMap*) G__getstructoffset())->Collisions((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMap*) G__getstructoffset())->Collisions((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMap*) G__getstructoffset())->DeleteKeys();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMap*) G__getstructoffset())->DeleteValues();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMap*) G__getstructoffset())->DeleteAll();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TMap*) G__getstructoffset())->DeleteEntry((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMap*) G__getstructoffset())->GetTable());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMap*) G__getstructoffset())->GetValue((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMap*) G__getstructoffset())->GetValue((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMap*) G__getstructoffset())->IsOwnerValue());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMap*) G__getstructoffset())->operator()((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMap*) G__getstructoffset())->operator()((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMap*) G__getstructoffset())->Rehash((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMap*) G__getstructoffset())->Rehash((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TMap*) G__getstructoffset())->RemoveEntry((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TMap*) G__getstructoffset())->SetOwnerValue((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TMap*) G__getstructoffset())->SetOwnerValue();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMap*) G__getstructoffset())->SetOwnerKeyValue((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMap*) G__getstructoffset())->SetOwnerKeyValue((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TMap*) G__getstructoffset())->SetOwnerKeyValue();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMap::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMap::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMap::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMap::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMap*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMap::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMap::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMap::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_159_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMap::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMap G__TTMap;
static int G__G__Cont_159_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMap*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMap*) (soff+(sizeof(TMap)*i)))->~G__TTMap();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMap*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMap*) (soff))->~G__TTMap();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TOrdCollectionIter */
static int G__G__Cont_161_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TOrdCollectionIter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TOrdCollectionIter((TOrdCollection*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TOrdCollectionIter((TOrdCollection*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TOrdCollectionIter((TOrdCollection*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TOrdCollectionIter((TOrdCollection*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TOrdCollectionIter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_161_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TOrdCollectionIter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TOrdCollectionIter(*(TOrdCollectionIter*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TOrdCollectionIter(*(TOrdCollectionIter*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TOrdCollectionIter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_161_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TOrdCollectionIter& obj = ((TOrdCollectionIter*) G__getstructoffset())->operator=(*(TOrdCollectionIter*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_161_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TOrdCollectionIter*) G__getstructoffset())->operator!=(*(TOrdCollectionIter*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_161_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TOrdCollectionIter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_161_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TOrdCollectionIter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_161_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TOrdCollectionIter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_161_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TOrdCollectionIter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_161_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TOrdCollectionIter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_161_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TOrdCollectionIter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_161_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TOrdCollectionIter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_161_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TOrdCollectionIter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_161_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TOrdCollectionIter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TOrdCollectionIter G__TTOrdCollectionIter;
static int G__G__Cont_161_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TOrdCollectionIter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TOrdCollectionIter*) (soff+(sizeof(TOrdCollectionIter)*i)))->~G__TTOrdCollectionIter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TOrdCollectionIter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TOrdCollectionIter*) (soff))->~G__TTOrdCollectionIter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TOrdCollection */
static int G__G__Cont_162_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TOrdCollection* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TOrdCollection((Int_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TOrdCollection((Int_t) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TOrdCollection[n];
       } else {
         p = new((void*) gvp) TOrdCollection[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TOrdCollection;
       } else {
         p = new((void*) gvp) TOrdCollection;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TOrdCollection));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_162_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TOrdCollection*) G__getstructoffset())->PutAt((TObject*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_162_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TOrdCollection*) G__getstructoffset())->Sort();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_162_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TOrdCollection*) G__getstructoffset())->BinarySearch((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_162_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TOrdCollection::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_162_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TOrdCollection::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_162_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TOrdCollection::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_162_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TOrdCollection::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_162_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TOrdCollection*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_162_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TOrdCollection::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_162_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TOrdCollection::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_162_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TOrdCollection::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_162_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TOrdCollection::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TOrdCollection G__TTOrdCollection;
static int G__G__Cont_162_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TOrdCollection*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TOrdCollection*) (soff+(sizeof(TOrdCollection)*i)))->~G__TTOrdCollection();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TOrdCollection*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TOrdCollection*) (soff))->~G__TTOrdCollection();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TRefArrayIter */
static int G__G__Cont_165_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRefArrayIter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TRefArrayIter((TRefArray*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TRefArrayIter((TRefArray*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TRefArrayIter((TRefArray*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TRefArrayIter((TRefArray*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TRefArrayIter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_165_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRefArrayIter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TRefArrayIter(*(TRefArrayIter*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TRefArrayIter(*(TRefArrayIter*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TRefArrayIter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_165_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TRefArrayIter& obj = ((TRefArrayIter*) G__getstructoffset())->operator=(*(TRefArrayIter*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_165_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TRefArrayIter*) G__getstructoffset())->operator!=(*(TRefArrayIter*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_165_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TRefArrayIter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_165_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRefArrayIter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_165_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TRefArrayIter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_165_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TRefArrayIter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_165_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRefArrayIter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_165_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRefArrayIter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_165_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TRefArrayIter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_165_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRefArrayIter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_165_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TRefArrayIter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TRefArrayIter G__TTRefArrayIter;
static int G__G__Cont_165_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TRefArrayIter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TRefArrayIter*) (soff+(sizeof(TRefArrayIter)*i)))->~G__TTRefArrayIter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TRefArrayIter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TRefArrayIter*) (soff))->~G__TTRefArrayIter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TRefArray */
static int G__G__Cont_166_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRefArray* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TRefArray((TProcessID*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TRefArray((TProcessID*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TRefArray[n];
       } else {
         p = new((void*) gvp) TRefArray[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TRefArray;
       } else {
         p = new((void*) gvp) TRefArray;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TRefArray));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRefArray* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TRefArray((Int_t) G__int(libp->para[0]), (TProcessID*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TRefArray((Int_t) G__int(libp->para[0]), (TProcessID*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TRefArray));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRefArray* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TRefArray(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TProcessID*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TRefArray(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TProcessID*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TRefArray((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TRefArray((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TRefArray((Int_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TRefArray((Int_t) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TRefArray));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TRefArray* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TRefArray(*(TRefArray*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TRefArray(*(TRefArray*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TRefArray));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TRefArray& obj = ((TRefArray*) G__getstructoffset())->operator=(*(TRefArray*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRefArray*) G__getstructoffset())->Compress();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRefArray*) G__getstructoffset())->Expand((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TRefArray*) G__getstructoffset())->GetEntriesFast());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TRefArray*) G__getstructoffset())->GetLast());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRefArray*) G__getstructoffset())->GetPID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TRefArray*) G__getstructoffset())->GetUID((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRefArray*) G__getstructoffset())->AddAtAndExpand((TObject*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TRefArray*) G__getstructoffset())->AddAtFree((TObject*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TRefArray*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TRefArray*) G__getstructoffset())->LowerBound());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRefArray*) G__getstructoffset())->SetLast((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TRefArray*) G__getstructoffset())->Sort((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TRefArray*) G__getstructoffset())->Sort();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TRefArray*) G__getstructoffset())->BinarySearch((TObject*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TRefArray*) G__getstructoffset())->BinarySearch((TObject*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TRefArray::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRefArray::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TRefArray::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TRefArray::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TRefArray*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRefArray::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TRefArray::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TRefArray::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_166_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TRefArray::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TRefArray G__TTRefArray;
static int G__G__Cont_166_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TRefArray*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TRefArray*) (soff+(sizeof(TRefArray)*i)))->~G__TTRefArray();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TRefArray*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TRefArray*) (soff))->~G__TTRefArray();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<int,allocator<int> > */
static int G__G__Cont_172_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const int& obj = ((vector<int,allocator<int> >*) G__getstructoffset())->at((vector<int,allocator<int> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'i', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<int,allocator<int> >::iterator* pobj;
         vector<int,allocator<int> >::iterator xobj = ((vector<int,allocator<int> >*) G__getstructoffset())->begin();
         pobj = new vector<int,allocator<int> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<int,allocator<int> >::iterator* pobj;
         vector<int,allocator<int> >::iterator xobj = ((vector<int,allocator<int> >*) G__getstructoffset())->end();
         pobj = new vector<int,allocator<int> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<int,allocator<int> >::reverse_iterator* pobj;
         vector<int,allocator<int> >::reverse_iterator xobj = ((vector<int,allocator<int> >*) G__getstructoffset())->rbegin();
         pobj = new vector<int,allocator<int> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<int,allocator<int> >::reverse_iterator* pobj;
         vector<int,allocator<int> >::reverse_iterator xobj = ((vector<int,allocator<int> >*) G__getstructoffset())->rend();
         pobj = new vector<int,allocator<int> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const vector<int,allocator<int> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const vector<int,allocator<int> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<int,allocator<int> >*) G__getstructoffset())->resize((vector<int,allocator<int> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<int,allocator<int> >*) G__getstructoffset())->resize((vector<int,allocator<int> >::size_type) G__int(libp->para[0]), (int) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const vector<int,allocator<int> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<int,allocator<int> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const int& obj = ((vector<int,allocator<int> >*) G__getstructoffset())->operator[]((vector<int,allocator<int> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'i', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<int,allocator<int> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<int,allocator<int> >[n];
     } else {
       p = new((void*) gvp) vector<int,allocator<int> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<int,allocator<int> >;
     } else {
       p = new((void*) gvp) vector<int,allocator<int> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<int,allocator<int> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<int,allocator<int> >((vector<int,allocator<int> >::size_type) G__int(libp->para[0]), *(int*) G__Intref(&libp->para[1]));
     } else {
       p = new((void*) gvp) vector<int,allocator<int> >((vector<int,allocator<int> >::size_type) G__int(libp->para[0]), *(int*) G__Intref(&libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<int,allocator<int> >((vector<int,allocator<int> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<int,allocator<int> >((vector<int,allocator<int> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<int,allocator<int> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<int,allocator<int> >(*(vector<int,allocator<int> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<int,allocator<int> >(*(vector<int,allocator<int> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<int,allocator<int> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<int,allocator<int> >(*((vector<int,allocator<int> >::const_iterator*) G__int(libp->para[0])), *((vector<int,allocator<int> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<int,allocator<int> >(*((vector<int,allocator<int> >::const_iterator*) G__int(libp->para[0])), *((vector<int,allocator<int> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<int,allocator<int> >& obj = ((vector<int,allocator<int> >*) G__getstructoffset())->operator=(*(vector<int,allocator<int> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<int,allocator<int> >*) G__getstructoffset())->reserve((vector<int,allocator<int> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const int& obj = ((vector<int,allocator<int> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         G__letint(result7, 'i', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const int& obj = ((vector<int,allocator<int> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         G__letint(result7, 'i', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<int,allocator<int> >*) G__getstructoffset())->push_back(*(int*) G__Intref(&libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<int,allocator<int> >*) G__getstructoffset())->swap(*(vector<int,allocator<int> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<int,allocator<int> >::iterator* pobj;
         vector<int,allocator<int> >::iterator xobj = ((vector<int,allocator<int> >*) G__getstructoffset())->insert(*((vector<int,allocator<int> >::iterator*) G__int(libp->para[0])), *(int*) G__Intref(&libp->para[1]));
         pobj = new vector<int,allocator<int> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<int,allocator<int> >*) G__getstructoffset())->insert(*((vector<int,allocator<int> >::iterator*) G__int(libp->para[0])), *((vector<int,allocator<int> >::const_iterator*) G__int(libp->para[1]))
, *((vector<int,allocator<int> >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<int,allocator<int> >*) G__getstructoffset())->insert(*((vector<int,allocator<int> >::iterator*) G__int(libp->para[0])), (vector<int,allocator<int> >::size_type) G__int(libp->para[1])
, *(int*) G__Intref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<int,allocator<int> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<int,allocator<int> >*) G__getstructoffset())->erase(*((vector<int,allocator<int> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<int,allocator<int> >*) G__getstructoffset())->erase(*((vector<int,allocator<int> >::iterator*) G__int(libp->para[0])), *((vector<int,allocator<int> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_172_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<int,allocator<int> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<int,allocator<int> > G__TvectorlEintcOallocatorlEintgRsPgR;
static int G__G__Cont_172_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<int,allocator<int> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<int,allocator<int> >*) (soff+(sizeof(vector<int,allocator<int> >)*i)))->~G__TvectorlEintcOallocatorlEintgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<int,allocator<int> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<int,allocator<int> >*) (soff))->~G__TvectorlEintcOallocatorlEintgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<int,allocator<int> >::iterator */
static int G__G__Cont_173_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<int,allocator<int> >::iterator* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<int,allocator<int> >::iterator[n];
     } else {
       p = new((void*) gvp) vector<int,allocator<int> >::iterator[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<int,allocator<int> >::iterator;
     } else {
       p = new((void*) gvp) vector<int,allocator<int> >::iterator;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_173_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<int,allocator<int> >::iterator* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<int,allocator<int> >::iterator(libp->para[0].ref ? *(const vector<int,allocator<int> >::iterator::pointer*) libp->para[0].ref : *(const vector<int,allocator<int> >::iterator::pointer*) (void*) (&G__Mlong(libp->para[0])));
   } else {
     p = new((void*) gvp) vector<int,allocator<int> >::iterator(libp->para[0].ref ? *(const vector<int,allocator<int> >::iterator::pointer*) libp->para[0].ref : *(const vector<int,allocator<int> >::iterator::pointer*) (void*) (&G__Mlong(libp->para[0])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_173_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<int,allocator<int> >::iterator::reference obj = ((const vector<int,allocator<int> >::iterator*) G__getstructoffset())->operator*();
         result7->ref = (long) (&obj);
         G__letint(result7, 'i', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_173_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const vector<int,allocator<int> >::iterator*) G__getstructoffset())->operator->());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_173_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<int,allocator<int> >::iterator& obj = ((vector<int,allocator<int> >::iterator*) G__getstructoffset())->operator++();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_173_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<int,allocator<int> >::iterator* pobj;
         vector<int,allocator<int> >::iterator xobj = ((vector<int,allocator<int> >::iterator*) G__getstructoffset())->operator++((int) G__int(libp->para[0]));
         pobj = new vector<int,allocator<int> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_173_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<int,allocator<int> >::iterator& obj = ((vector<int,allocator<int> >::iterator*) G__getstructoffset())->operator--();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_173_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<int,allocator<int> >::iterator* pobj;
         vector<int,allocator<int> >::iterator xobj = ((vector<int,allocator<int> >::iterator*) G__getstructoffset())->operator--((int) G__int(libp->para[0]));
         pobj = new vector<int,allocator<int> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_173_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<int,allocator<int> >::iterator::reference obj = ((const vector<int,allocator<int> >::iterator*) G__getstructoffset())->operator[](*(vector<int,allocator<int> >::iterator::difference_type*) G__Longref(&libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'i', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_173_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<int,allocator<int> >::iterator& obj = ((vector<int,allocator<int> >::iterator*) G__getstructoffset())->operator+=(*(vector<int,allocator<int> >::iterator::difference_type*) G__Longref(&libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_173_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<int,allocator<int> >::iterator* pobj;
         const vector<int,allocator<int> >::iterator xobj = ((const vector<int,allocator<int> >::iterator*) G__getstructoffset())->operator+(*(vector<int,allocator<int> >::iterator::difference_type*) G__Longref(&libp->para[0]));
         pobj = new vector<int,allocator<int> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_173_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<int,allocator<int> >::iterator& obj = ((vector<int,allocator<int> >::iterator*) G__getstructoffset())->operator-=(*(vector<int,allocator<int> >::iterator::difference_type*) G__Longref(&libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_173_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<int,allocator<int> >::iterator* pobj;
         const vector<int,allocator<int> >::iterator xobj = ((const vector<int,allocator<int> >::iterator*) G__getstructoffset())->operator-(*(vector<int,allocator<int> >::iterator::difference_type*) G__Longref(&libp->para[0]));
         pobj = new vector<int,allocator<int> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_173_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<int,allocator<int> >::iterator::pointer& obj = ((const vector<int,allocator<int> >::iterator*) G__getstructoffset())->base();
         result7->ref = (long) (&obj);
         G__letint(result7, 'I', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_173_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<int,allocator<int> >::iterator* pobj;
         vector<int,allocator<int> >::iterator xobj = ((vector<int,allocator<int> >::iterator*) G__getstructoffset())->operator=(*(vector<int,allocator<int> >::iterator*) libp->para[0].ref);
         pobj = new vector<int,allocator<int> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Cont_173_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   vector<int,allocator<int> >::iterator* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new vector<int,allocator<int> >::iterator(*(vector<int,allocator<int> >::iterator*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<int,allocator<int> >::iterator G__TvectorlEintcOallocatorlEintgRsPgRcLcLiterator;
static int G__G__Cont_173_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<int,allocator<int> >::iterator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<int,allocator<int> >::iterator*) (soff+(sizeof(vector<int,allocator<int> >::iterator)*i)))->~G__TvectorlEintcOallocatorlEintgRsPgRcLcLiterator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<int,allocator<int> >::iterator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<int,allocator<int> >::iterator*) (soff))->~G__TvectorlEintcOallocatorlEintgRsPgRcLcLiterator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* reverse_iterator<vector<int,allocator<int> >::iterator> */
static int G__G__Cont_174_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   reverse_iterator<vector<int,allocator<int> >::iterator>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new reverse_iterator<vector<int,allocator<int> >::iterator>[n];
     } else {
       p = new((void*) gvp) reverse_iterator<vector<int,allocator<int> >::iterator>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new reverse_iterator<vector<int,allocator<int> >::iterator>;
     } else {
       p = new((void*) gvp) reverse_iterator<vector<int,allocator<int> >::iterator>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_174_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<int,allocator<int> >::iterator* pobj;
         const vector<int,allocator<int> >::iterator xobj = ((const reverse_iterator<vector<int,allocator<int> >::iterator>*) G__getstructoffset())->base();
         pobj = new vector<int,allocator<int> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_174_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<int,allocator<int> >::iterator>::reference obj = ((const reverse_iterator<vector<int,allocator<int> >::iterator>*) G__getstructoffset())->operator*();
         result7->ref = (long) (&obj);
         G__letint(result7, 'i', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_174_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const reverse_iterator<vector<int,allocator<int> >::iterator>*) G__getstructoffset())->operator->());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_174_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<int,allocator<int> >::iterator>& obj = ((reverse_iterator<vector<int,allocator<int> >::iterator>*) G__getstructoffset())->operator++();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_174_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         reverse_iterator<vector<int,allocator<int> >::iterator>* pobj;
         reverse_iterator<vector<int,allocator<int> >::iterator> xobj = ((reverse_iterator<vector<int,allocator<int> >::iterator>*) G__getstructoffset())->operator++((int) G__int(libp->para[0]));
         pobj = new reverse_iterator<vector<int,allocator<int> >::iterator>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_174_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<int,allocator<int> >::iterator>& obj = ((reverse_iterator<vector<int,allocator<int> >::iterator>*) G__getstructoffset())->operator--();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_174_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         reverse_iterator<vector<int,allocator<int> >::iterator>* pobj;
         reverse_iterator<vector<int,allocator<int> >::iterator> xobj = ((reverse_iterator<vector<int,allocator<int> >::iterator>*) G__getstructoffset())->operator--((int) G__int(libp->para[0]));
         pobj = new reverse_iterator<vector<int,allocator<int> >::iterator>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_174_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<int,allocator<int> >::iterator>* pobj;
         const reverse_iterator<vector<int,allocator<int> >::iterator> xobj = ((const reverse_iterator<vector<int,allocator<int> >::iterator>*) G__getstructoffset())->operator+((reverse_iterator<vector<int,allocator<int> >::iterator>::difference_type) G__int(libp->para[0]));
         pobj = new reverse_iterator<vector<int,allocator<int> >::iterator>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_174_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<int,allocator<int> >::iterator>& obj = ((reverse_iterator<vector<int,allocator<int> >::iterator>*) G__getstructoffset())->operator+=((reverse_iterator<vector<int,allocator<int> >::iterator>::difference_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_174_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<int,allocator<int> >::iterator>* pobj;
         const reverse_iterator<vector<int,allocator<int> >::iterator> xobj = ((const reverse_iterator<vector<int,allocator<int> >::iterator>*) G__getstructoffset())->operator-((reverse_iterator<vector<int,allocator<int> >::iterator>::difference_type) G__int(libp->para[0]));
         pobj = new reverse_iterator<vector<int,allocator<int> >::iterator>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_174_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<int,allocator<int> >::iterator>& obj = ((reverse_iterator<vector<int,allocator<int> >::iterator>*) G__getstructoffset())->operator-=((reverse_iterator<vector<int,allocator<int> >::iterator>::difference_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_174_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const reverse_iterator<vector<int,allocator<int> >::iterator>::reference obj = ((const reverse_iterator<vector<int,allocator<int> >::iterator>*) G__getstructoffset())->operator[]((reverse_iterator<vector<int,allocator<int> >::iterator>::difference_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'i', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Cont_174_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   reverse_iterator<vector<int,allocator<int> >::iterator>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new reverse_iterator<vector<int,allocator<int> >::iterator>(*(reverse_iterator<vector<int,allocator<int> >::iterator>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef reverse_iterator<vector<int,allocator<int> >::iterator> G__Treverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR;
static int G__G__Cont_174_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (reverse_iterator<vector<int,allocator<int> >::iterator>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((reverse_iterator<vector<int,allocator<int> >::iterator>*) (soff+(sizeof(reverse_iterator<vector<int,allocator<int> >::iterator>)*i)))->~G__Treverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (reverse_iterator<vector<int,allocator<int> >::iterator>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((reverse_iterator<vector<int,allocator<int> >::iterator>*) (soff))->~G__Treverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Cont_174_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   reverse_iterator<vector<int,allocator<int> >::iterator>* dest = (reverse_iterator<vector<int,allocator<int> >::iterator>*) G__getstructoffset();
   const reverse_iterator<vector<int,allocator<int> >::iterator>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TSortedList */
static int G__G__Cont_176_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSortedList* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSortedList((Bool_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TSortedList((Bool_t) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TSortedList[n];
       } else {
         p = new((void*) gvp) TSortedList[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TSortedList;
       } else {
         p = new((void*) gvp) TSortedList;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ContLN_TSortedList));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_176_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSortedList::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_176_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSortedList::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_176_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TSortedList::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_176_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSortedList::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_176_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSortedList*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_176_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSortedList::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_176_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSortedList::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_176_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSortedList::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont_176_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSortedList::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSortedList G__TTSortedList;
static int G__G__Cont_176_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TSortedList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSortedList*) (soff+(sizeof(TSortedList)*i)))->~G__TTSortedList();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSortedList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSortedList*) (soff))->~G__TTSortedList();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */
static int G__G__Cont__0_298(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator&(*(TBits::TReference*) libp->para[0].ref, *(TBits::TReference*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont__0_299(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator|(*(TBits::TReference*) libp->para[0].ref, *(TBits::TReference*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont__0_300(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator^(*(TBits::TReference*) libp->para[0].ref, *(TBits::TReference*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont__0_301(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TBits* pobj;
         TBits xobj = operator&(*(TBits*) libp->para[0].ref, *(TBits*) libp->para[1].ref);
         pobj = new TBits(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont__0_302(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TBits* pobj;
         TBits xobj = operator|(*(TBits*) libp->para[0].ref, *(TBits*) libp->para[1].ref);
         pobj = new TBits(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont__0_303(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TBits* pobj;
         TBits xobj = operator^(*(TBits*) libp->para[0].ref, *(TBits*) libp->para[1].ref);
         pobj = new TBits(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont__0_304(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ostream& obj = operator<<(*(ostream*) libp->para[0].ref, *(TBits*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont__0_509(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(vector<int,allocator<int> >::iterator*) libp->para[0].ref, *(vector<int,allocator<int> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont__0_510(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator!=(*(vector<int,allocator<int> >::iterator*) libp->para[0].ref, *(vector<int,allocator<int> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont__0_511(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<(*(vector<int,allocator<int> >::iterator*) libp->para[0].ref, *(vector<int,allocator<int> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont__0_512(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>(*(vector<int,allocator<int> >::iterator*) libp->para[0].ref, *(vector<int,allocator<int> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont__0_513(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<=(*(vector<int,allocator<int> >::iterator*) libp->para[0].ref, *(vector<int,allocator<int> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont__0_514(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>=(*(vector<int,allocator<int> >::iterator*) libp->para[0].ref, *(vector<int,allocator<int> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont__0_515(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) operator-(*(vector<int,allocator<int> >::iterator*) libp->para[0].ref, *(vector<int,allocator<int> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont__0_516(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<int,allocator<int> >::iterator* pobj;
         const vector<int,allocator<int> >::iterator xobj = operator+((const vector<int,allocator<int> >::iterator::difference_type) G__int(libp->para[0]), *(vector<int,allocator<int> >::iterator*) libp->para[1].ref);
         pobj = new vector<int,allocator<int> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont__0_517(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(vector<int,allocator<int> >::reverse_iterator*) libp->para[0].ref, *(vector<int,allocator<int> >::reverse_iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont__0_518(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator!=(*(vector<int,allocator<int> >::reverse_iterator*) libp->para[0].ref, *(vector<int,allocator<int> >::reverse_iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont__0_519(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(vector<int,allocator<int> >*) libp->para[0].ref, *(vector<int,allocator<int> >*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont__0_520(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<(*(vector<int,allocator<int> >*) libp->para[0].ref, *(vector<int,allocator<int> >*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont__0_521(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator!=(*(vector<int,allocator<int> >*) libp->para[0].ref, *(vector<int,allocator<int> >*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont__0_522(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>(*(vector<int,allocator<int> >*) libp->para[0].ref, *(vector<int,allocator<int> >*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont__0_523(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>=(*(vector<int,allocator<int> >*) libp->para[0].ref, *(vector<int,allocator<int> >*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Cont__0_524(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<=(*(vector<int,allocator<int> >*) libp->para[0].ref, *(vector<int,allocator<int> >*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}


/*********************************************************
* Member function Stub
*********************************************************/

/* TVirtualCollectionProxy */

/* TList */

/* TObjArray */

/* TClonesArray */

/* TRefTable */

/* TArray */

/* TArrayC */

/* TArrayD */

/* TArrayF */

/* TArrayI */

/* TArrayL64 */

/* TArrayL */

/* TArrayS */

/* TBits */

/* TBits::TReference */

/* TCollection */

/* TIterator */

/* TObjectTable */

/* TIter */

/* TSeqCollection */

/* TBtreeIter */

/* TBtree */

/* TClassTable */

/* TObjArrayIter */

/* TExMapIter */

/* TExMap */

/* TListIter */

/* THashTable */

/* THashList */

/* THashTableIter */

/* TMapIter */

/* TPair */

/* TMap */

/* TOrdCollectionIter */

/* TOrdCollection */

/* TRefArrayIter */

/* TRefArray */

/* vector<int,allocator<int> > */

/* vector<int,allocator<int> >::iterator */

/* reverse_iterator<vector<int,allocator<int> >::iterator> */

/* TSortedList */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__Cont {
 public:
  G__Sizep2memfuncG__Cont(): p(&G__Sizep2memfuncG__Cont::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__Cont::*p)();
};

size_t G__get_sizep2memfuncG__Cont()
{
  G__Sizep2memfuncG__Cont 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_inheritanceG__Cont() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TList))) {
     TList *G__Lderived;
     G__Lderived=(TList*)0x1000;
     {
       TSeqCollection *G__Lpbase=(TSeqCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TList),G__get_linked_tagnum(&G__G__ContLN_TSeqCollection),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TCollection *G__Lpbase=(TCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TList),G__get_linked_tagnum(&G__G__ContLN_TCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TList),G__get_linked_tagnum(&G__G__ContLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TObjArray))) {
     TObjArray *G__Lderived;
     G__Lderived=(TObjArray*)0x1000;
     {
       TSeqCollection *G__Lpbase=(TSeqCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TObjArray),G__get_linked_tagnum(&G__G__ContLN_TSeqCollection),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TCollection *G__Lpbase=(TCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TObjArray),G__get_linked_tagnum(&G__G__ContLN_TCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TObjArray),G__get_linked_tagnum(&G__G__ContLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TClonesArray))) {
     TClonesArray *G__Lderived;
     G__Lderived=(TClonesArray*)0x1000;
     {
       TObjArray *G__Lpbase=(TObjArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TClonesArray),G__get_linked_tagnum(&G__G__ContLN_TObjArray),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TSeqCollection *G__Lpbase=(TSeqCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TClonesArray),G__get_linked_tagnum(&G__G__ContLN_TSeqCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TCollection *G__Lpbase=(TCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TClonesArray),G__get_linked_tagnum(&G__G__ContLN_TCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TClonesArray),G__get_linked_tagnum(&G__G__ContLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TRefTable))) {
     TRefTable *G__Lderived;
     G__Lderived=(TRefTable*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TRefTable),G__get_linked_tagnum(&G__G__ContLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TArrayC))) {
     TArrayC *G__Lderived;
     G__Lderived=(TArrayC*)0x1000;
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TArrayC),G__get_linked_tagnum(&G__G__ContLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TArrayD))) {
     TArrayD *G__Lderived;
     G__Lderived=(TArrayD*)0x1000;
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TArrayD),G__get_linked_tagnum(&G__G__ContLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TArrayF))) {
     TArrayF *G__Lderived;
     G__Lderived=(TArrayF*)0x1000;
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TArrayF),G__get_linked_tagnum(&G__G__ContLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TArrayI))) {
     TArrayI *G__Lderived;
     G__Lderived=(TArrayI*)0x1000;
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TArrayI),G__get_linked_tagnum(&G__G__ContLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TArrayL64))) {
     TArrayL64 *G__Lderived;
     G__Lderived=(TArrayL64*)0x1000;
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TArrayL64),G__get_linked_tagnum(&G__G__ContLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TArrayL))) {
     TArrayL *G__Lderived;
     G__Lderived=(TArrayL*)0x1000;
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TArrayL),G__get_linked_tagnum(&G__G__ContLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TArrayS))) {
     TArrayS *G__Lderived;
     G__Lderived=(TArrayS*)0x1000;
     {
       TArray *G__Lpbase=(TArray*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TArrayS),G__get_linked_tagnum(&G__G__ContLN_TArray),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TBits))) {
     TBits *G__Lderived;
     G__Lderived=(TBits*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TBits),G__get_linked_tagnum(&G__G__ContLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TCollection))) {
     TCollection *G__Lderived;
     G__Lderived=(TCollection*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TCollection),G__get_linked_tagnum(&G__G__ContLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TObjectTable))) {
     TObjectTable *G__Lderived;
     G__Lderived=(TObjectTable*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TObjectTable),G__get_linked_tagnum(&G__G__ContLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TSeqCollection))) {
     TSeqCollection *G__Lderived;
     G__Lderived=(TSeqCollection*)0x1000;
     {
       TCollection *G__Lpbase=(TCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TSeqCollection),G__get_linked_tagnum(&G__G__ContLN_TCollection),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TSeqCollection),G__get_linked_tagnum(&G__G__ContLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TBtreeIter))) {
     TBtreeIter *G__Lderived;
     G__Lderived=(TBtreeIter*)0x1000;
     {
       TIterator *G__Lpbase=(TIterator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TBtreeIter),G__get_linked_tagnum(&G__G__ContLN_TIterator),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&> *G__Lpbase=(iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TBtreeIter),G__get_linked_tagnum(&G__G__ContLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TBtree))) {
     TBtree *G__Lderived;
     G__Lderived=(TBtree*)0x1000;
     {
       TSeqCollection *G__Lpbase=(TSeqCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TBtree),G__get_linked_tagnum(&G__G__ContLN_TSeqCollection),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TCollection *G__Lpbase=(TCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TBtree),G__get_linked_tagnum(&G__G__ContLN_TCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TBtree),G__get_linked_tagnum(&G__G__ContLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TClassTable))) {
     TClassTable *G__Lderived;
     G__Lderived=(TClassTable*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TClassTable),G__get_linked_tagnum(&G__G__ContLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TObjArrayIter))) {
     TObjArrayIter *G__Lderived;
     G__Lderived=(TObjArrayIter*)0x1000;
     {
       TIterator *G__Lpbase=(TIterator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TObjArrayIter),G__get_linked_tagnum(&G__G__ContLN_TIterator),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&> *G__Lpbase=(iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TObjArrayIter),G__get_linked_tagnum(&G__G__ContLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TExMap))) {
     TExMap *G__Lderived;
     G__Lderived=(TExMap*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TExMap),G__get_linked_tagnum(&G__G__ContLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TListIter))) {
     TListIter *G__Lderived;
     G__Lderived=(TListIter*)0x1000;
     {
       TIterator *G__Lpbase=(TIterator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TListIter),G__get_linked_tagnum(&G__G__ContLN_TIterator),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&> *G__Lpbase=(iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TListIter),G__get_linked_tagnum(&G__G__ContLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_THashTable))) {
     THashTable *G__Lderived;
     G__Lderived=(THashTable*)0x1000;
     {
       TCollection *G__Lpbase=(TCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_THashTable),G__get_linked_tagnum(&G__G__ContLN_TCollection),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_THashTable),G__get_linked_tagnum(&G__G__ContLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_THashList))) {
     THashList *G__Lderived;
     G__Lderived=(THashList*)0x1000;
     {
       TList *G__Lpbase=(TList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_THashList),G__get_linked_tagnum(&G__G__ContLN_TList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TSeqCollection *G__Lpbase=(TSeqCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_THashList),G__get_linked_tagnum(&G__G__ContLN_TSeqCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TCollection *G__Lpbase=(TCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_THashList),G__get_linked_tagnum(&G__G__ContLN_TCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_THashList),G__get_linked_tagnum(&G__G__ContLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_THashTableIter))) {
     THashTableIter *G__Lderived;
     G__Lderived=(THashTableIter*)0x1000;
     {
       TIterator *G__Lpbase=(TIterator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_THashTableIter),G__get_linked_tagnum(&G__G__ContLN_TIterator),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TMapIter))) {
     TMapIter *G__Lderived;
     G__Lderived=(TMapIter*)0x1000;
     {
       TIterator *G__Lpbase=(TIterator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TMapIter),G__get_linked_tagnum(&G__G__ContLN_TIterator),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&> *G__Lpbase=(iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TMapIter),G__get_linked_tagnum(&G__G__ContLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TPair))) {
     TPair *G__Lderived;
     G__Lderived=(TPair*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TPair),G__get_linked_tagnum(&G__G__ContLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TMap))) {
     TMap *G__Lderived;
     G__Lderived=(TMap*)0x1000;
     {
       TCollection *G__Lpbase=(TCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TMap),G__get_linked_tagnum(&G__G__ContLN_TCollection),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TMap),G__get_linked_tagnum(&G__G__ContLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TOrdCollectionIter))) {
     TOrdCollectionIter *G__Lderived;
     G__Lderived=(TOrdCollectionIter*)0x1000;
     {
       TIterator *G__Lpbase=(TIterator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TOrdCollectionIter),G__get_linked_tagnum(&G__G__ContLN_TIterator),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&> *G__Lpbase=(iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TOrdCollectionIter),G__get_linked_tagnum(&G__G__ContLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TOrdCollection))) {
     TOrdCollection *G__Lderived;
     G__Lderived=(TOrdCollection*)0x1000;
     {
       TSeqCollection *G__Lpbase=(TSeqCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TOrdCollection),G__get_linked_tagnum(&G__G__ContLN_TSeqCollection),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TCollection *G__Lpbase=(TCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TOrdCollection),G__get_linked_tagnum(&G__G__ContLN_TCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TOrdCollection),G__get_linked_tagnum(&G__G__ContLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TRefArrayIter))) {
     TRefArrayIter *G__Lderived;
     G__Lderived=(TRefArrayIter*)0x1000;
     {
       TIterator *G__Lpbase=(TIterator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TRefArrayIter),G__get_linked_tagnum(&G__G__ContLN_TIterator),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&> *G__Lpbase=(iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TRefArrayIter),G__get_linked_tagnum(&G__G__ContLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TRefArray))) {
     TRefArray *G__Lderived;
     G__Lderived=(TRefArray*)0x1000;
     {
       TSeqCollection *G__Lpbase=(TSeqCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TRefArray),G__get_linked_tagnum(&G__G__ContLN_TSeqCollection),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TCollection *G__Lpbase=(TCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TRefArray),G__get_linked_tagnum(&G__G__ContLN_TCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TRefArray),G__get_linked_tagnum(&G__G__ContLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ContLN_TSortedList))) {
     TSortedList *G__Lderived;
     G__Lderived=(TSortedList*)0x1000;
     {
       TList *G__Lpbase=(TList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TSortedList),G__get_linked_tagnum(&G__G__ContLN_TList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TSeqCollection *G__Lpbase=(TSeqCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TSortedList),G__get_linked_tagnum(&G__G__ContLN_TSeqCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TCollection *G__Lpbase=(TCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TSortedList),G__get_linked_tagnum(&G__G__ContLN_TCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__ContLN_TSortedList),G__get_linked_tagnum(&G__G__ContLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__Cont() {

   /* Setting up typedef entry */
   G__search_typename2("Char_t",99,-1,0,-1);
   G__setnewtype(-1,"Signed Character 1 byte (char)",0);
   G__search_typename2("UChar_t",98,-1,0,-1);
   G__setnewtype(-1,"Unsigned Character 1 byte (unsigned char)",0);
   G__search_typename2("Short_t",115,-1,0,-1);
   G__setnewtype(-1,"Signed Short integer 2 bytes (short)",0);
   G__search_typename2("UShort_t",114,-1,0,-1);
   G__setnewtype(-1,"Unsigned Short integer 2 bytes (unsigned short)",0);
   G__search_typename2("Int_t",105,-1,0,-1);
   G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
   G__search_typename2("UInt_t",104,-1,0,-1);
   G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
   G__search_typename2("Long_t",108,-1,0,-1);
   G__setnewtype(-1,"Signed long integer 4 bytes (long)",0);
   G__search_typename2("ULong_t",107,-1,0,-1);
   G__setnewtype(-1,"Unsigned long integer 4 bytes (unsigned long)",0);
   G__search_typename2("Float_t",102,-1,0,-1);
   G__setnewtype(-1,"Float 4 bytes (float)",0);
   G__search_typename2("Double_t",100,-1,0,-1);
   G__setnewtype(-1,"Double 8 bytes",0);
   G__search_typename2("Bool_t",103,-1,0,-1);
   G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
   G__search_typename2("Version_t",115,-1,0,-1);
   G__setnewtype(-1,"Class version identifier (short)",0);
   G__search_typename2("Option_t",99,-1,256,-1);
   G__setnewtype(-1,"Option string (const char)",0);
   G__search_typename2("Long64_t",110,-1,0,-1);
   G__setnewtype(-1,"Portable signed long integer 8 bytes",0);
   G__search_typename2("ULong64_t",109,-1,0,-1);
   G__setnewtype(-1,"Portable unsigned long integer 8 bytes",0);
   G__search_typename2("Stat_t",100,-1,0,-1);
   G__setnewtype(-1,"Statistics type (double)",0);
   G__search_typename2("VoidFuncPtr_t",89,-1,0,-1);
   G__setnewtype(-1,"pointer to void function",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__ContLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ContLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ContLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__ContLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ContLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ContLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Iterator_t",117,G__get_linked_tagnum(&G__G__ContLN_TBtreeIter),0,G__get_linked_tagnum(&G__G__ContLN_TBtree));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__ContLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__G__ContLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__G__ContLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__G__ContLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("IdMap_t",117,G__get_linked_tagnum(&G__G__ContLN_ROOTcLcLTMapTypeToClassRec),0,G__get_linked_tagnum(&G__G__ContLN_TClassTable));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Iterator_t",117,G__get_linked_tagnum(&G__G__ContLN_TObjArrayIter),0,G__get_linked_tagnum(&G__G__ContLN_TObjArray));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<bool>",117,G__get_linked_tagnum(&G__G__ContLN_vectorlEboolcOallocatorlEboolgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ContLN_vectorlEboolcOallocatorlEboolgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ContLN_vectorlEboolcOallocatorlEboolgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Iterator_t",117,G__get_linked_tagnum(&G__G__ContLN_TListIter),0,G__get_linked_tagnum(&G__G__ContLN_TList));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Iterator_t",117,G__get_linked_tagnum(&G__G__ContLN_TMapIter),0,G__get_linked_tagnum(&G__G__ContLN_TMap));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TAssoc",117,G__get_linked_tagnum(&G__G__ContLN_TPair),0,-1);
   G__setnewtype(-1,"for backward compatibility",0);
   G__search_typename2("Iterator_t",117,G__get_linked_tagnum(&G__G__ContLN_TOrdCollectionIter),0,G__get_linked_tagnum(&G__G__ContLN_TOrdCollection));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Iterator_t",117,G__get_linked_tagnum(&G__G__ContLN_TRefArrayIter),0,G__get_linked_tagnum(&G__G__ContLN_TRefArray));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::string>",117,G__get_linked_tagnum(&G__G__ContLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ContLN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ContLN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<string>",117,G__get_linked_tagnum(&G__G__ContLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Int_t>",117,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",105,-1,0,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",73,-1,0,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",73,-1,256,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",105,-1,1,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",105,-1,257,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",104,-1,0,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",73,-1,0,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",73,-1,0,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",105,-1,1,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",105,-1,1,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",104,-1,0,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",73,-1,0,G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",105,-1,1,G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<int>",117,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,TObjArray*>",117,G__get_linked_tagnum(&G__G__ContLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__G__ContLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*,less<string> >",117,G__get_linked_tagnum(&G__G__ContLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("CreateIterators_t",89,-1,0,G__get_linked_tagnum(&G__G__ContLN_TVirtualCollectionProxy));
   G__setnewtype(-1,"void (*CreateIterators_t)(void *collection, void **begin_arena, void **end_arena);",0);
   G__search_typename2("CopyIterator_t",89,-1,0,G__get_linked_tagnum(&G__G__ContLN_TVirtualCollectionProxy));
   G__setnewtype(-1,"void* (*CopyIterator_t)(void *dest, const void *source);",0);
   G__search_typename2("Next_t",89,-1,0,G__get_linked_tagnum(&G__G__ContLN_TVirtualCollectionProxy));
   G__setnewtype(-1,"void* (*Next_t)(void *iter, const void *end);",0);
   G__search_typename2("DeleteIterator_t",89,-1,0,G__get_linked_tagnum(&G__G__ContLN_TVirtualCollectionProxy));
   G__setnewtype(-1,"void (*DeleteIterator_t)(void *iter);",0);
   G__search_typename2("DeleteTwoIterators_t",89,-1,0,G__get_linked_tagnum(&G__G__ContLN_TVirtualCollectionProxy));
   G__setnewtype(-1,"void (*DeleteTwoIterators_t)(void *begin, void *end);",0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* TVirtualCollectionProxy */
static void G__setup_memvarTVirtualCollectionProxy(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TVirtualCollectionProxy));
   { TVirtualCollectionProxy *p; p=(TVirtualCollectionProxy*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ContLN_TClassRef),-1,-1,2,"fClass=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fProperties=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ContLN_TVirtualCollectionProxycLcLEProperty),-1,-2,1,G__FastAllocString(2048).Format("kIsInitialized=%lldLL",(long long)TVirtualCollectionProxy::kIsInitialized).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ContLN_TVirtualCollectionProxycLcLEProperty),-1,-2,1,G__FastAllocString(2048).Format("kIsAssociative=%lldLL",(long long)TVirtualCollectionProxy::kIsAssociative).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ContLN_TVirtualCollectionProxycLcLEProperty),-1,-2,1,G__FastAllocString(2048).Format("kIsEmulated=%lldLL",(long long)TVirtualCollectionProxy::kIsEmulated).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,1,G__FastAllocString(2048).Format("fgIteratorArenaSize=%lldLL",(long long)TVirtualCollectionProxy::fgIteratorArenaSize).data(),0,"greater than sizeof(void*) + sizeof(UInt_t)");
   }
   G__tag_memvar_reset();
}


   /* TList */
static void G__setup_memvarTList(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TList));
   { TList *p; p=(TList*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TObjLink),-1,-1,2,"fFirst=",0,"! pointer to first entry in linked list");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TObjLink),-1,-1,2,"fLast=",0,"! pointer to last entry in linked list");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TObjLink),-1,-1,2,"fCache=",0,"! cache to speedup sequential calling of Before() and After() functions");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAscending=",0,"! sorting order (when calling Sort() or for TSortedList)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TObjArray */
static void G__setup_memvarTObjArray(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TObjArray));
   { TObjArray *p; p=(TObjArray*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__ContLN_TObject),-1,-1,2,"fCont=",0,"!Array contents");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLowerBound=",0,"Lower bound of the array");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLast=",0,"Last element in array containing an object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TClonesArray */
static void G__setup_memvarTClonesArray(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TClonesArray));
   { TClonesArray *p; p=(TClonesArray*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-1,2,"fClass=",0,"!Pointer to the class");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TObjArray),-1,-1,2,"fKeep=",0,"!Saved copies of pointers to objects");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ContLN_TClonesArraycLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kForgetBits=%lldLL",(long long)TClonesArray::kForgetBits).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ContLN_TClonesArraycLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kNoSplit=%lldLL",(long long)TClonesArray::kNoSplit).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ContLN_TClonesArraycLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kBypassStreamer=%lldLL",(long long)TClonesArray::kBypassStreamer).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRefTable */
static void G__setup_memvarTRefTable(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TRefTable));
   { TRefTable *p; p=(TRefTable*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumPIDs=",0,"!number of known ProcessIDs");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fAllocSize=",0,"![fNumPIDs] allocated size of array fParentIDs for each ProcessID");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fN=",0,"![fNumPIDs] current maximum number of IDs in array fParentIDs for each ProcessID");
   G__memvar_setup((void*)0,73,2,0,-1,G__defined_typename("Int_t"),-1,2,"fParentIDs=",0,"![fNumPIDs][fAllocSize] array of Parent IDs");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fParentID=",0,"!current parent ID in fParents (latest call to SetParent)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDefaultSize=",0,"!default size for a new PID array");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fUID=",0,"!Current uid (set by TRef::GetObject)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TProcessID),-1,-1,2,"fUIDContext=",0,"!TProcessID the current uid is referring to");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSize=",0,"dummy for backward compatibility");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TObjArray),-1,-1,2,"fParents=",0,"array of Parent objects  (eg TTree branch) holding the referenced objects");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TObject),-1,-1,2,"fOwner=",0,"Object owning this TRefTable");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ContLN_vectorlEstringcOallocatorlEstringgRsPgR),G__defined_typename("vector<std::string>"),-1,2,"fProcessGUIDs=",0,"UUIDs of TProcessIDs used in fParentIDs");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,2,"fMapPIDtoInternal=",0,"! cache of pid to index in fProcessGUIDs");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TRefTable),-1,-2,2,"fgRefTable=",0,"Pointer to current TRefTable");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ContLN_TRefTablecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kHaveWarnedReadingOld=%lldLL",(long long)TRefTable::kHaveWarnedReadingOld).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TArray */
static void G__setup_memvarTArray(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TArray));
   { TArray *p; p=(TArray*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fN)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fN=",0,"Number of array elements");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TArrayC */
static void G__setup_memvarTArrayC(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TArrayC));
   { TArrayC *p; p=(TArrayC*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fArray)-(long)(p)),67,0,0,-1,G__defined_typename("Char_t"),-1,1,"fArray=",0,"[fN] Array of fN chars");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TArrayD */
static void G__setup_memvarTArrayD(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TArrayD));
   { TArrayD *p; p=(TArrayD*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fArray)-(long)(p)),68,0,0,-1,G__defined_typename("Double_t"),-1,1,"fArray=",0,"[fN] Array of fN doubles");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TArrayF */
static void G__setup_memvarTArrayF(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TArrayF));
   { TArrayF *p; p=(TArrayF*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fArray)-(long)(p)),70,0,0,-1,G__defined_typename("Float_t"),-1,1,"fArray=",0,"[fN] Array of fN floats");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TArrayI */
static void G__setup_memvarTArrayI(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TArrayI));
   { TArrayI *p; p=(TArrayI*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fArray)-(long)(p)),73,0,0,-1,G__defined_typename("Int_t"),-1,1,"fArray=",0,"[fN] Array of fN 32 bit integers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TArrayL64 */
static void G__setup_memvarTArrayL64(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TArrayL64));
   { TArrayL64 *p; p=(TArrayL64*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fArray)-(long)(p)),78,0,0,-1,G__defined_typename("Long64_t"),-1,1,"fArray=",0,"[fN] Array of fN long64s");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TArrayL */
static void G__setup_memvarTArrayL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TArrayL));
   { TArrayL *p; p=(TArrayL*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fArray)-(long)(p)),76,0,0,-1,G__defined_typename("Long_t"),-1,1,"fArray=",0,"[fN] Array of fN longs");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TArrayS */
static void G__setup_memvarTArrayS(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TArrayS));
   { TArrayS *p; p=(TArrayS*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fArray)-(long)(p)),83,0,0,-1,G__defined_typename("Short_t"),-1,1,"fArray=",0,"[fN] Array of fN shorts");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TBits */
static void G__setup_memvarTBits(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TBits));
   { TBits *p; p=(TBits*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fNbits=",0,"Highest bit set + 1");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fNbytes=",0,"Number of UChars in fAllBits");
   G__memvar_setup((void*)0,66,0,0,-1,G__defined_typename("UChar_t"),-1,2,"fAllBits=",0,"[fNbytes] array of UChars");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TBits::TReference */
static void G__setup_memvarTBitscLcLTReference(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TBitscLcLTReference));
   { TBits::TReference *p; p=(TBits::TReference*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,1,0,G__get_linked_tagnum(&G__G__ContLN_TBits),-1,-1,4,"fBits=",0,"!");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fPos=",0,"!");
   }
   G__tag_memvar_reset();
}


   /* TCollection */
static void G__setup_memvarTCollection(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TCollection));
   { TCollection *p; p=(TCollection*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TCollection),-1,-2,4,"fgCurrentCollection=",0,"used by macro R__FOR_EACH");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TObjectTable),-1,-2,4,"fgGarbageCollection=",0,"used by garbage collector");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgEmptyingGarbage=",0,"used by garbage collector");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fgGarbageStack=",0,"used by garbage collector");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ContLN_TCollectioncLcLdA),-1,-2,2,"kIsOwner=16384LL",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ContLN_TString),-1,-1,2,"fName=",0,"name of the collection");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSize=",0,"number of elements in collection");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ContLN_TCollectioncLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kInitCapacity=%lldLL",(long long)TCollection::kInitCapacity).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ContLN_TCollectioncLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kInitHashTableCapacity=%lldLL",(long long)TCollection::kInitHashTableCapacity).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TIterator */
static void G__setup_memvarTIterator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TIterator));
   { TIterator *p; p=(TIterator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TObjectTable */
static void G__setup_memvarTObjectTable(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TObjectTable));
   { TObjectTable *p; p=(TObjectTable*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__ContLN_TObject),-1,-1,4,"fTable=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fTally=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TIter */
static void G__setup_memvarTIter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TIter));
   { TIter *p; p=(TIter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TIterator),-1,-1,4,"fIterator=",0,"collection iterator");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSeqCollection */
static void G__setup_memvarTSeqCollection(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TSeqCollection));
   { TSeqCollection *p; p=(TSeqCollection*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSorted=",0,"true if collection has been sorted");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TBtreeIter */
static void G__setup_memvarTBtreeIter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TBtreeIter));
   { TBtreeIter *p; p=(TBtreeIter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__ContLN_TBtree),-1,-1,4,"fTree=",0,"btree being iterated");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCurCursor=",0,"current position in btree");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCursor=",0,"next position in btree");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDirection=",0,"iteration direction");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TBtree */
static void G__setup_memvarTBtree(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TBtree));
   { TBtree *p; p=(TBtree*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TBtNode),-1,-1,4,"fRoot=",0,"root node of btree");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOrder=",0,"the order of the tree (should be > 2)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOrder2=",0,"order*2+1 (assumes a memory access is");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fInnerLowWaterMark=",0,"inner node low water mark");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLeafLowWaterMark=",0,"leaf low water mark");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fInnerMaxIndex=",0,"maximum inner node index");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLeafMaxIndex=",0,"maximum leaf index");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TClassTable */
static void G__setup_memvarTClassTable(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TClassTable));
   { TClassTable *p; p=(TClassTable*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__ContLN_TClassRec),-1,-2,4,"fgTable=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__ContLN_TClassRec),-1,-2,4,"fgSortedTable=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_ROOTcLcLTMapTypeToClassRec),G__defined_typename("IdMap_t"),-2,4,"fgIdMap=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-2,4,"fgSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-2,4,"fgTally=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgSorted=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-2,4,"fgCursor=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ContLN_TClassTablecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kNoStreamer=%lldLL",(long long)TClassTable::kNoStreamer).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ContLN_TClassTablecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kNoInputOperator=%lldLL",(long long)TClassTable::kNoInputOperator).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ContLN_TClassTablecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kAutoStreamer=%lldLL",(long long)TClassTable::kAutoStreamer).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TObjArrayIter */
static void G__setup_memvarTObjArrayIter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TObjArrayIter));
   { TObjArrayIter *p; p=(TObjArrayIter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__ContLN_TObjArray),-1,-1,4,"fArray=",0,"array being iterated");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCurCursor=",0,"current position in array");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCursor=",0,"next position in array");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDirection=",0,"iteration direction");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TExMapIter */
static void G__setup_memvarTExMapIter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TExMapIter));
   { TExMapIter *p; p=(TExMapIter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__ContLN_TExMap),-1,-1,4,"fMap=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCursor=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TExMap */
static void G__setup_memvarTExMap(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TExMap));
   { TExMap *p; p=(TExMap*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TExMapcLcLAssoc_t),-1,-1,4,"fTable=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fTally=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TListIter */
static void G__setup_memvarTListIter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TListIter));
   { TListIter *p; p=(TListIter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__ContLN_TList),-1,-1,2,"fList=",0,"list being iterated");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TObjLink),-1,-1,2,"fCurCursor=",0,"current position in list");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TObjLink),-1,-1,2,"fCursor=",0,"next position in list");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDirection=",0,"iteration direction");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fStarted=",0,"iteration started");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THashTable */
static void G__setup_memvarTHashTable(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_THashTable));
   { THashTable *p; p=(THashTable*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__ContLN_TList),-1,-1,4,"fCont=",0,"Hash table (table of lists)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fEntries=",0,"Number of objects in table");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fUsedSlots=",0,"Number of used slots");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fRehashLevel=",0,"Average collision rate which triggers rehash");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THashList */
static void G__setup_memvarTHashList(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_THashList));
   { THashList *p; p=(THashList*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_THashTable),-1,-1,2,"fTable=",0,"Hashtable used for quick lookup of objects");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THashTableIter */
static void G__setup_memvarTHashTableIter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_THashTableIter));
   { THashTableIter *p; p=(THashTableIter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__ContLN_THashTable),-1,-1,4,"fTable=",0,"hash table being iterated");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCursor=",0,"current position in table");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TListIter),-1,-1,4,"fListCursor=",0,"current position in collision list");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDirection=",0,"iteration direction");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMapIter */
static void G__setup_memvarTMapIter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TMapIter));
   { TMapIter *p; p=(TMapIter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__ContLN_TMap),-1,-1,4,"fMap=",0,"map being iterated");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_THashTableIter),-1,-1,4,"fCursor=",0,"current position in map");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDirection=",0,"iteration direction");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TPair */
static void G__setup_memvarTPair(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TPair));
   { TPair *p; p=(TPair*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TObject),-1,-1,4,"fKey=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TObject),-1,-1,4,"fValue=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMap */
static void G__setup_memvarTMap(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TMap));
   { TMap *p; p=(TMap*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_THashTable),-1,-1,4,"fTable=",0,"Hash table used to store TPair's");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ContLN_TMapcLcLdA),-1,-2,2,"kIsOwnerValue=32768LL",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TOrdCollectionIter */
static void G__setup_memvarTOrdCollectionIter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TOrdCollectionIter));
   { TOrdCollectionIter *p; p=(TOrdCollectionIter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__ContLN_TOrdCollection),-1,-1,4,"fCol=",0,"collection being iterated");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCurCursor=",0,"current position in collection");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCursor=",0,"next position in collection");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDirection=",0,"iteration direction");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TOrdCollection */
static void G__setup_memvarTOrdCollection(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TOrdCollection));
   { TOrdCollection *p; p=(TOrdCollection*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__ContLN_TObject),-1,-1,4,"fCont=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCapacity=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fGapStart=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fGapSize=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ContLN_TOrdCollectioncLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kDefaultCapacity=%lldLL",(long long)TOrdCollection::kDefaultCapacity).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ContLN_TOrdCollectioncLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kMinExpand=%lldLL",(long long)TOrdCollection::kMinExpand).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ContLN_TOrdCollectioncLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kShrinkFactor=%lldLL",(long long)TOrdCollection::kShrinkFactor).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRefArrayIter */
static void G__setup_memvarTRefArrayIter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TRefArrayIter));
   { TRefArrayIter *p; p=(TRefArrayIter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__ContLN_TRefArray),-1,-1,4,"fArray=",0,"array being iterated");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCurCursor=",0,"current position in array");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCursor=",0,"next position in array");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDirection=",0,"iteration direction");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TRefArray */
static void G__setup_memvarTRefArray(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TRefArray));
   { TRefArray *p; p=(TRefArray*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TProcessID),-1,-1,2,"fPID=",0,"Pointer to Process Unique Identifier");
   G__memvar_setup((void*)0,72,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fUIDs=",0,"[fSize] To store uids of referenced objects");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLowerBound=",0,"Lower bound of the array");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLast=",0,"Last element in array containing an object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* vector<int,allocator<int> > */
static void G__setup_memvarvectorlEintcOallocatorlEintgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR));
   { vector<int,allocator<int> > *p; p=(vector<int,allocator<int> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* vector<int,allocator<int> >::iterator */
static void G__setup_memvarvectorlEintcOallocatorlEintgRsPgRcLcLiterator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator));
   { vector<int,allocator<int> >::iterator *p; p=(vector<int,allocator<int> >::iterator*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* reverse_iterator<vector<int,allocator<int> >::iterator> */
static void G__setup_memvarreverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR));
   { reverse_iterator<vector<int,allocator<int> >::iterator> *p; p=(reverse_iterator<vector<int,allocator<int> >::iterator>*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* TSortedList */
static void G__setup_memvarTSortedList(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ContLN_TSortedList));
   { TSortedList *p; p=(TSortedList*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__Cont() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTVirtualCollectionProxy(void) {
   /* TVirtualCollectionProxy */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TVirtualCollectionProxy));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__ContLN_TVirtualCollectionProxy), -1, 1, 1, 1, 4, 0, "u 'TVirtualCollectionProxy' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("SetValueClass",1311,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TClass' - 0 - newcl", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Generate",811,G__G__Cont_17_0_6, 85, G__get_linked_tagnum(&G__G__ContLN_TVirtualCollectionProxy), -1, 0, 0, 1, 1, 8, "", "Returns an object of the actual CollectionProxy class", (void*) NULL, 3);
   G__memfunc_setup("GetCollectionClass",1826,G__G__Cont_17_0_7, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCollectionType",1742,G__G__Cont_17_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetIncrement",1221,G__G__Cont_17_0_9, 107, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetProperties",1357,G__G__Cont_17_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("New",298,G__G__Cont_17_0_11, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("New",298,G__G__Cont_17_0_12, 89, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - arena", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NewArray",809,G__G__Cont_17_0_13, 89, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - nElements", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NewArray",809,G__G__Cont_17_0_14, 89, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - nElements Y - - 0 - arena", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Destructor",1071,G__G__Cont_17_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 - p g - 'Bool_t' 0 'kFALSE' dtorOnly", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteArray",1106,G__G__Cont_17_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 - p g - 'Bool_t' 0 'kFALSE' dtorOnly", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof",624,G__G__Cont_17_0_17, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PushProxy",962,G__G__Cont_17_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - objectstart", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PopProxy",849,G__G__Cont_17_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("HasPointers",1136,G__G__Cont_17_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetValueClass",1299,G__G__Cont_17_0_21, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetType",706,G__G__Cont_17_0_22, 105, G__get_linked_tagnum(&G__G__ContLN_EDataType), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("At",181,G__G__Cont_17_0_23, 89, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - idx", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Clear",487,G__G__Cont_17_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' opt", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Size",411,G__G__Cont_17_0_25, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Allocate",805,G__G__Cont_17_0_26, 89, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - n g - 'Bool_t' 0 - forceDelete", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Commit",617,G__G__Cont_17_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("operator[]",1060,G__G__Cont_17_0_28, 67, -1, -1, 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetConversionReadMemberWiseActions",3459,G__G__Cont_17_0_29, 85, G__get_linked_tagnum(&G__G__ContLN_TStreamerInfoActionscLcLTActionSequence), -1, 0, 2, 1, 1, 0, 
"U 'TClass' - 0 - oldClass i - 'Int_t' 0 - version", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetReadMemberWiseActions",2397,G__G__Cont_17_0_30, 85, G__get_linked_tagnum(&G__G__ContLN_TStreamerInfoActionscLcLTActionSequence), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - version", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetWriteMemberWiseActions",2540,G__G__Cont_17_0_31, 85, G__get_linked_tagnum(&G__G__ContLN_TStreamerInfoActionscLcLTActionSequence), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetFunctionCreateIterators",2679,G__G__Cont_17_0_32, 89, -1, G__defined_typename("TVirtualCollectionProxy::CreateIterators_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' read", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetFunctionCopyIterator",2379,G__G__Cont_17_0_33, 89, -1, G__defined_typename("TVirtualCollectionProxy::CopyIterator_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' read", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetFunctionNext",1541,G__G__Cont_17_0_34, 89, -1, G__defined_typename("TVirtualCollectionProxy::Next_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' read", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetFunctionDeleteIterator",2563,G__G__Cont_17_0_35, 89, -1, G__defined_typename("TVirtualCollectionProxy::DeleteIterator_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' read", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetFunctionDeleteTwoIterators",2992,G__G__Cont_17_0_36, 89, -1, G__defined_typename("TVirtualCollectionProxy::DeleteTwoIterators_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' read", (char*)NULL, (void*) NULL, 3);
   // automatic destructor
   G__memfunc_setup("~TVirtualCollectionProxy", 2535, G__G__Cont_17_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTList(void) {
   /* TList */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TList));
   G__memfunc_setup("LinkAt",579,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ContLN_TObjLink), -1, 0, 1, 1, 2, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindLink",783,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ContLN_TObjLink), -1, 0, 2, 1, 2, 8, 
"U 'TObject' - 10 - obj i - 'Int_t' 1 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSort",603,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ContLN_TObjLink), -1, 2, 2, 1, 2, 0, 
"U 'TObjLink' - 2 - head i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LnkCompare",1004,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 0, 
"U 'TObjLink' - 0 - l1 U 'TObjLink' - 0 - l2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NewLink",696,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ContLN_TObjLink), -1, 0, 2, 1, 2, 0, 
"U 'TObject' - 0 - obj U 'TObjLink' - 0 'NULL' prev", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NewOptLink",1003,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ContLN_TObjLink), -1, 0, 3, 1, 2, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 - opt "
"U 'TObjLink' - 0 'NULL' prev", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteLink",993,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TObjLink' - 0 - lnk", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TList",496,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ContLN_TList), -1, 0, 1, 1, 4, 0, "u 'TList' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__ContLN_TList), -1, 1, 1, 1, 4, 0, "u 'TList' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TList",496,G__G__Cont_76_0_10, 105, G__get_linked_tagnum(&G__G__ContLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TList",496,G__G__Cont_76_0_11, 105, G__get_linked_tagnum(&G__G__ContLN_TList), -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - -", "for backward compatibility, don't use", (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeIterator",1224,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TIterator), -1, 0, 1, 1, 1, 8, "g - 'Bool_t' 0 'kIterForward' dir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,G__G__Cont_76_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFirst",785,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFirst",785,G__G__Cont_76_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLast",669,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLast",669,G__G__Cont_76_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAt",446,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAfter",763,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - after U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAfter",763,G__G__Cont_76_0_25, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObjLink' - 0 - after U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBefore",860,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - before U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBefore",860,G__G__Cont_76_0_27, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObjLink' - 0 - before U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,G__G__Cont_76_0_29, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 0, "U 'TObjLink' - 0 - lnk", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveLast",1026,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("At",181,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("After",498,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Before",595,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("First",520,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FirstLink",918,G__G__Cont_76_0_36, 85, G__get_linked_tagnum(&G__G__ContLN_TObjLink), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjectRef",1172,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 2, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Last",404,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LastLink",802,G__G__Cont_76_0_39, 85, G__get_linked_tagnum(&G__G__ContLN_TObjLink), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sort",424,G__G__Cont_76_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kSortAscending' order", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsAscending",1096,G__G__Cont_76_0_41, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Cont_76_0_42, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TList::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_76_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TList::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_76_0_44, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TList::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_76_0_45, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TList::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_76_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_76_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TList::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_76_0_51, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TList::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_76_0_52, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TList::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_76_0_53, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TList::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TList", 622, G__G__Cont_76_0_54, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTObjArray(void) {
   /* TObjArray */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TObjArray));
   G__memfunc_setup("BoundsOk",805,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 8, 
"C - - 10 - where i - 'Int_t' 0 - at", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - s i - 'Int_t' 0 - lowerBound", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OutOfBoundsError",1634,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 8, 
"C - - 10 - where i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAbsLast",970,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TObjArray",878,G__G__Cont_78_0_5, 105, G__get_linked_tagnum(&G__G__ContLN_TObjArray), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 'TCollection::kInitCapacity' s i - 'Int_t' 0 '0' lowerBound", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TObjArray",878,G__G__Cont_78_0_6, 105, G__get_linked_tagnum(&G__G__ContLN_TObjArray), -1, 0, 1, 1, 1, 0, "u 'TObjArray' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Cont_78_0_7, 117, G__get_linked_tagnum(&G__G__ContLN_TObjArray), -1, 1, 1, 1, 1, 0, "u 'TObjArray' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Compress",844,G__G__Cont_78_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Expand",608,G__G__Cont_78_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - newSize", "expand or shrink an array", (void*) NULL, 1);
   G__memfunc_setup("GetEntries",1018,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntriesFast",1416,G__G__Cont_78_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLast",692,G__G__Cont_78_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObjectRef",1172,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 2, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsEmpty",715,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeIterator",1224,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TIterator), -1, 0, 1, 1, 1, 8, "g - 'Bool_t' 0 'kIterForward' dir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFirst",785,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLast",669,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAt",446,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAtAndExpand",1329,G__G__Cont_78_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAtFree",832,G__G__Cont_78_0_23, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAfter",763,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - after U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBefore",860,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - before U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveAt",803,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveRange",1115,G__G__Cont_78_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - idx1 i - 'Int_t' 0 - idx2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("At",181,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UncheckedAt",1087,G__G__Cont_78_0_33, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Before",595,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("After",498,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("First",520,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Last",404,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__G__Cont_78_0_38, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__G__Cont_78_0_39, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LowerBound",1025,G__G__Cont_78_0_40, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IndexOf",685,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLast",704,G__G__Cont_78_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Randomize",937,G__G__Cont_78_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' ntimes", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sort",424,G__G__Cont_78_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 'kMaxInt' upto", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BinarySearch",1211,G__G__Cont_78_0_45, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj i - 'Int_t' 0 'kMaxInt' upto", "the TObjArray has to be sorted, -1 == not found !!", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Cont_78_0_46, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TObjArray::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_78_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TObjArray::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_78_0_48, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TObjArray::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_78_0_49, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TObjArray::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_78_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_78_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TObjArray::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_78_0_55, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TObjArray::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_78_0_56, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TObjArray::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_78_0_57, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TObjArray::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TObjArray", 1004, G__G__Cont_78_0_58, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTClonesArray(void) {
   /* TClonesArray */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TClonesArray));
   G__memfunc_setup("TClonesArray",1207,G__G__Cont_87_0_1, 105, G__get_linked_tagnum(&G__G__ContLN_TClonesArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TClonesArray",1207,G__G__Cont_87_0_2, 105, G__get_linked_tagnum(&G__G__ContLN_TClonesArray), -1, 0, 3, 1, 1, 0, 
"C - - 10 - classname i - 'Int_t' 0 '1000' size "
"g - 'Bool_t' 0 'kFALSE' call_dtor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TClonesArray",1207,G__G__Cont_87_0_3, 105, G__get_linked_tagnum(&G__G__ContLN_TClonesArray), -1, 0, 3, 1, 1, 0, 
"U 'TClass' - 10 - cl i - 'Int_t' 0 '1000' size "
"g - 'Bool_t' 0 'kFALSE' call_dtor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TClonesArray",1207,G__G__Cont_87_0_4, 105, G__get_linked_tagnum(&G__G__ContLN_TClonesArray), -1, 0, 1, 1, 1, 0, "u 'TClonesArray' - 11 - tc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Cont_87_0_5, 117, G__get_linked_tagnum(&G__G__ContLN_TClonesArray), -1, 1, 1, 1, 1, 0, "u 'TClonesArray' - 11 - tc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Compress",844,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Expand",608,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - newSize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExpandCreate",1204,G__G__Cont_87_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExpandCreateFast",1602,G__G__Cont_87_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetClass",790,G__G__Cont_87_0_12, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOwner",823,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' enable", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFirst",785,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLast",669,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAt",446,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAtAndExpand",1329,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAtFree",832,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TObject' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAfter",763,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - - U 'TObject' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBefore",860,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - - U 'TObject' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BypassStreamer",1461,G__G__Cont_87_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' bypass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CanBypassStreamer",1735,G__G__Cont_87_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClass",802,G__G__Cont_87_0_23, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - classname i - 'Int_t' 0 '1000' size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClass",802,G__G__Cont_87_0_24, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClass' - 10 - cl i - 'Int_t' 0 '1000' size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AbsorbObjects",1315,G__G__Cont_87_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClonesArray' - 0 - tc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MultiSort",947,G__G__Cont_87_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nTCs U 'TClonesArray' - 2 - tcs "
"i - 'Int_t' 0 'kMaxInt' upto", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveAt",803,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveRange",1115,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - idx1 i - 'Int_t' 0 - idx2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sort",424,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 'kMaxInt' upto", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("New",298,G__G__Cont_87_0_31, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddrAt",560,G__G__Cont_87_0_32, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Cont_87_0_35, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TClonesArray::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_87_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TClonesArray::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_87_0_37, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TClonesArray::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_87_0_38, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TClonesArray::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_87_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_87_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TClonesArray::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_87_0_44, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TClonesArray::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_87_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TClonesArray::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_87_0_46, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TClonesArray::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TClonesArray", 1333, G__G__Cont_87_0_47, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRefTable(void) {
   /* TRefTable */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TRefTable));
   G__memfunc_setup("AddInternalIdxForPID",1903,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "U 'TProcessID' - 0 - procid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExpandForIID",1117,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - iid i - 'Int_t' 0 - newsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExpandPIDs",944,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - numpids", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindPIDGUID",903,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "C - - 10 - guid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInternalIdxForPID",1926,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "U 'TProcessID' - 0 - procid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInternalIdxForPID",1926,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TRefTable",857,G__G__Cont_88_0_7, 105, G__get_linked_tagnum(&G__G__ContLN_TRefTable), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TRefTable",857,G__G__Cont_88_0_8, 105, G__get_linked_tagnum(&G__G__ContLN_TRefTable), -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - owner i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Cont_88_0_9, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - uid U 'TProcessID' - 0 '0' context", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Expand",608,G__G__Cont_88_0_11, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - pid i - 'Int_t' 0 - newsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillBuffer",993,G__G__Cont_88_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRefTable",1061,G__G__Cont_88_0_13, 85, G__get_linked_tagnum(&G__G__ContLN_TRefTable), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TRefTable* (*)())(&TRefTable::GetRefTable) ), 0);
   G__memfunc_setup("GetNumPIDs",928,G__G__Cont_88_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSize",699,G__G__Cont_88_0_15, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetN",366,G__G__Cont_88_0_16, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOwner",811,G__G__Cont_88_0_17, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParent",906,G__G__Cont_88_0_18, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - uid U 'TProcessID' - 0 '0' context", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParents",1021,G__G__Cont_88_0_19, 85, G__get_linked_tagnum(&G__G__ContLN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUID",514,G__G__Cont_88_0_20, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUIDContext",1255,G__G__Cont_88_0_21, 85, G__get_linked_tagnum(&G__G__ContLN_TProcessID), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Notify",633,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffer",982,G__G__Cont_88_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,G__G__Cont_88_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParent",918,G__G__Cont_88_0_25, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - parent i - 'Int_t' 0 - branchID", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRefTable",1073,G__G__Cont_88_0_26, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TRefTable' - 0 - table", (char*)NULL, (void*) G__func2void( (void (*)(TRefTable*))(&TRefTable::SetRefTable) ), 0);
   G__memfunc_setup("SetUID",526,G__G__Cont_88_0_27, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - uid U 'TProcessID' - 0 '0' context", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Cont_88_0_28, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRefTable::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_88_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRefTable::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_88_0_30, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRefTable::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_88_0_31, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRefTable::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_88_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_88_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRefTable::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_88_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRefTable::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_88_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRefTable::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_88_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRefTable::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TRefTable", 857, G__G__Cont_88_0_40, (int) ('i'), G__get_linked_tagnum(&G__G__ContLN_TRefTable), -1, 0, 1, 1, 1, 0, "u 'TRefTable' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TRefTable", 983, G__G__Cont_88_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Cont_88_0_42, (int) ('u'), G__get_linked_tagnum(&G__G__ContLN_TRefTable), -1, 1, 1, 1, 1, 0, "u 'TRefTable' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTArray(void) {
   /* TArray */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TArray));
   G__memfunc_setup("BoundsOk",805,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 8, 
"C - - 10 - where i - 'Int_t' 0 - at", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OutOfBoundsError",1634,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 8, 
"C - - 10 - where i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Cont_99_0_6, 117, G__get_linked_tagnum(&G__G__ContLN_TArray), -1, 1, 1, 1, 1, 0, "u 'TArray' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSize",699,G__G__Cont_99_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Cont_99_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetAt",469,G__G__Cont_99_0_9, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetAt",481,G__G__Cont_99_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - v i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadArray",891,G__G__Cont_99_0_11, 85, G__get_linked_tagnum(&G__G__ContLN_TArray), -1, 0, 2, 3, 1, 0, 
"u 'TBuffer' - 1 - b U 'TClass' - 10 - clReq", (char*)NULL, (void*) G__func2void( (TArray* (*)(TBuffer&, const TClass*))(&TArray::ReadArray) ), 0);
   G__memfunc_setup("WriteArray",1034,G__G__Cont_99_0_12, 121, -1, -1, 0, 2, 3, 1, 0, 
"u 'TBuffer' - 1 - b U 'TArray' - 10 - a", (char*)NULL, (void*) G__func2void( (void (*)(TBuffer&, const TArray*))(&TArray::WriteArray) ), 0);
   G__memfunc_setup("Class",502,G__G__Cont_99_0_13, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TArray::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_99_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArray::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_99_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TArray::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_99_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TArray::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Cont_99_0_17, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Cont_99_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Cont_99_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_99_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_99_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArray::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_99_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArray::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_99_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArray::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_99_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArray::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TArray", 721, G__G__Cont_99_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTArrayC(void) {
   /* TArrayC */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TArrayC));
   G__memfunc_setup("TArrayC",662,G__G__Cont_100_0_1, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayC), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrayC",662,G__G__Cont_100_0_2, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayC), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrayC",662,G__G__Cont_100_0_3, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayC), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n C - 'Char_t' 10 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrayC",662,G__G__Cont_100_0_4, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayC), -1, 0, 1, 1, 1, 0, "u 'TArrayC' - 11 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Cont_100_0_5, 117, G__get_linked_tagnum(&G__G__ContLN_TArrayC), -1, 1, 1, 1, 1, 0, "u 'TArrayC' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Adopt",504,G__G__Cont_100_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n C - 'Char_t' 0 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAt",446,G__G__Cont_100_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"c - 'Char_t' 0 - c i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("At",181,G__G__Cont_100_0_8, 99, -1, G__defined_typename("Char_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,G__G__Cont_100_0_9, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TArrayC' - 1 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetArray",799,G__G__Cont_100_0_10, 67, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetArray",799,G__G__Cont_100_0_11, 67, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAt",469,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSum",597,G__G__Cont_100_0_13, 100, -1, G__defined_typename("Stat_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Cont_100_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 0 '0' val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Set",300,G__G__Cont_100_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n C - 'Char_t' 10 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAt",481,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - v i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__G__Cont_100_0_18, 99, -1, G__defined_typename("Char_t"), 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Cont_100_0_19, 99, -1, G__defined_typename("Char_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Cont_100_0_20, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TArrayC::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_100_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrayC::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_100_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TArrayC::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_100_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TArrayC::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_100_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_100_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrayC::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_100_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArrayC::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_100_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrayC::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_100_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArrayC::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TArrayC", 788, G__G__Cont_100_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTArrayD(void) {
   /* TArrayD */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TArrayD));
   G__memfunc_setup("TArrayD",663,G__G__Cont_101_0_1, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayD), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrayD",663,G__G__Cont_101_0_2, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayD), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrayD",663,G__G__Cont_101_0_3, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayD), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 10 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrayD",663,G__G__Cont_101_0_4, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayD), -1, 0, 1, 1, 1, 0, "u 'TArrayD' - 11 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Cont_101_0_5, 117, G__get_linked_tagnum(&G__G__ContLN_TArrayD), -1, 1, 1, 1, 1, 0, "u 'TArrayD' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Adopt",504,G__G__Cont_101_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 0 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAt",446,G__G__Cont_101_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - c i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("At",181,G__G__Cont_101_0_8, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,G__G__Cont_101_0_9, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TArrayD' - 1 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetArray",799,G__G__Cont_101_0_10, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetArray",799,G__G__Cont_101_0_11, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAt",469,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSum",597,G__G__Cont_101_0_13, 100, -1, G__defined_typename("Stat_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Cont_101_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Cont_101_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Set",300,G__G__Cont_101_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n D - 'Double_t' 10 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAt",481,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - v i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__G__Cont_101_0_19, 100, -1, G__defined_typename("Double_t"), 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Cont_101_0_20, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Cont_101_0_21, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TArrayD::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_101_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrayD::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_101_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TArrayD::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_101_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TArrayD::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_101_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_101_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrayD::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_101_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArrayD::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_101_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrayD::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_101_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArrayD::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TArrayD", 789, G__G__Cont_101_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTArrayF(void) {
   /* TArrayF */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TArrayF));
   G__memfunc_setup("TArrayF",665,G__G__Cont_102_0_1, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayF), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrayF",665,G__G__Cont_102_0_2, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayF), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrayF",665,G__G__Cont_102_0_3, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayF), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 10 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrayF",665,G__G__Cont_102_0_4, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayF), -1, 0, 1, 1, 1, 0, "u 'TArrayF' - 11 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Cont_102_0_5, 117, G__get_linked_tagnum(&G__G__ContLN_TArrayF), -1, 1, 1, 1, 1, 0, "u 'TArrayF' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Adopt",504,G__G__Cont_102_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 0 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAt",446,G__G__Cont_102_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - c i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("At",181,G__G__Cont_102_0_8, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,G__G__Cont_102_0_9, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TArrayF' - 1 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetArray",799,G__G__Cont_102_0_10, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetArray",799,G__G__Cont_102_0_11, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAt",469,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSum",597,G__G__Cont_102_0_13, 100, -1, G__defined_typename("Stat_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Cont_102_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Cont_102_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Set",300,G__G__Cont_102_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n F - 'Float_t' 10 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAt",481,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - v i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__G__Cont_102_0_19, 102, -1, G__defined_typename("Float_t"), 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Cont_102_0_20, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Cont_102_0_21, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TArrayF::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_102_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrayF::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_102_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TArrayF::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_102_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TArrayF::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_102_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_102_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrayF::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_102_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArrayF::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_102_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrayF::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_102_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArrayF::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TArrayF", 791, G__G__Cont_102_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTArrayI(void) {
   /* TArrayI */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TArrayI));
   G__memfunc_setup("TArrayI",668,G__G__Cont_103_0_1, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayI), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrayI",668,G__G__Cont_103_0_2, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayI), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrayI",668,G__G__Cont_103_0_3, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayI), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n I - 'Int_t' 10 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrayI",668,G__G__Cont_103_0_4, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayI), -1, 0, 1, 1, 1, 0, "u 'TArrayI' - 11 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Cont_103_0_5, 117, G__get_linked_tagnum(&G__G__ContLN_TArrayI), -1, 1, 1, 1, 1, 0, "u 'TArrayI' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Adopt",504,G__G__Cont_103_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n I - 'Int_t' 0 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAt",446,G__G__Cont_103_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - c i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("At",181,G__G__Cont_103_0_8, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,G__G__Cont_103_0_9, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TArrayI' - 1 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetArray",799,G__G__Cont_103_0_10, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetArray",799,G__G__Cont_103_0_11, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAt",469,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSum",597,G__G__Cont_103_0_13, 100, -1, G__defined_typename("Stat_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Cont_103_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Cont_103_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Set",300,G__G__Cont_103_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n I - 'Int_t' 10 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAt",481,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - v i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__G__Cont_103_0_19, 105, -1, G__defined_typename("Int_t"), 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Cont_103_0_20, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Cont_103_0_21, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TArrayI::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_103_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrayI::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_103_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TArrayI::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_103_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TArrayI::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_103_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_103_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrayI::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_103_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArrayI::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_103_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrayI::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_103_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArrayI::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TArrayI", 794, G__G__Cont_103_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTArrayL64(void) {
   /* TArrayL64 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TArrayL64));
   G__memfunc_setup("TArrayL64",777,G__G__Cont_104_0_1, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayL64), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrayL64",777,G__G__Cont_104_0_2, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayL64), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrayL64",777,G__G__Cont_104_0_3, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayL64), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n N - 'Long64_t' 10 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrayL64",777,G__G__Cont_104_0_4, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayL64), -1, 0, 1, 1, 1, 0, "u 'TArrayL64' - 11 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Cont_104_0_5, 117, G__get_linked_tagnum(&G__G__ContLN_TArrayL64), -1, 1, 1, 1, 1, 0, "u 'TArrayL64' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Adopt",504,G__G__Cont_104_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n N - 'Long64_t' 0 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAt",446,G__G__Cont_104_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - c i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("At",181,G__G__Cont_104_0_8, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,G__G__Cont_104_0_9, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TArrayL64' - 1 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetArray",799,G__G__Cont_104_0_10, 78, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetArray",799,G__G__Cont_104_0_11, 78, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAt",469,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSum",597,G__G__Cont_104_0_13, 100, -1, G__defined_typename("Stat_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Cont_104_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Cont_104_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Set",300,G__G__Cont_104_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n N - 'Long64_t' 10 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAt",481,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - v i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__G__Cont_104_0_19, 110, -1, G__defined_typename("Long64_t"), 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Cont_104_0_20, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Cont_104_0_21, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TArrayL64::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_104_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrayL64::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_104_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TArrayL64::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_104_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TArrayL64::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_104_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_104_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrayL64::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_104_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArrayL64::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_104_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrayL64::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_104_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArrayL64::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TArrayL64", 903, G__G__Cont_104_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTArrayL(void) {
   /* TArrayL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TArrayL));
   G__memfunc_setup("TArrayL",671,G__G__Cont_105_0_1, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayL), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrayL",671,G__G__Cont_105_0_2, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayL), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrayL",671,G__G__Cont_105_0_3, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayL), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n L - 'Long_t' 10 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrayL",671,G__G__Cont_105_0_4, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayL), -1, 0, 1, 1, 1, 0, "u 'TArrayL' - 11 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Cont_105_0_5, 117, G__get_linked_tagnum(&G__G__ContLN_TArrayL), -1, 1, 1, 1, 1, 0, "u 'TArrayL' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Adopt",504,G__G__Cont_105_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n L - 'Long_t' 0 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAt",446,G__G__Cont_105_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"l - 'Long_t' 0 - c i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("At",181,G__G__Cont_105_0_8, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,G__G__Cont_105_0_9, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TArrayL' - 1 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetArray",799,G__G__Cont_105_0_10, 76, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetArray",799,G__G__Cont_105_0_11, 76, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAt",469,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSum",597,G__G__Cont_105_0_13, 100, -1, G__defined_typename("Stat_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Cont_105_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Cont_105_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Set",300,G__G__Cont_105_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n L - 'Long_t' 10 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAt",481,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - v i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__G__Cont_105_0_19, 108, -1, G__defined_typename("Long_t"), 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Cont_105_0_20, 108, -1, G__defined_typename("Long_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Cont_105_0_21, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TArrayL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_105_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrayL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_105_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TArrayL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_105_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TArrayL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_105_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_105_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrayL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_105_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArrayL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_105_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrayL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_105_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArrayL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TArrayL", 797, G__G__Cont_105_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTArrayS(void) {
   /* TArrayS */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TArrayS));
   G__memfunc_setup("TArrayS",678,G__G__Cont_106_0_1, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayS), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrayS",678,G__G__Cont_106_0_2, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayS), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrayS",678,G__G__Cont_106_0_3, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayS), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n S - 'Short_t' 10 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TArrayS",678,G__G__Cont_106_0_4, 105, G__get_linked_tagnum(&G__G__ContLN_TArrayS), -1, 0, 1, 1, 1, 0, "u 'TArrayS' - 11 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Cont_106_0_5, 117, G__get_linked_tagnum(&G__G__ContLN_TArrayS), -1, 1, 1, 1, 1, 0, "u 'TArrayS' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Adopt",504,G__G__Cont_106_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n S - 'Short_t' 0 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAt",446,G__G__Cont_106_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Short_t' 0 - c i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("At",181,G__G__Cont_106_0_8, 115, -1, G__defined_typename("Short_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,G__G__Cont_106_0_9, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TArrayS' - 1 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetArray",799,G__G__Cont_106_0_10, 83, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetArray",799,G__G__Cont_106_0_11, 83, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAt",469,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSum",597,G__G__Cont_106_0_13, 100, -1, G__defined_typename("Stat_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Cont_106_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Cont_106_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Set",300,G__G__Cont_106_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n S - 'Short_t' 10 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAt",481,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - v i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__G__Cont_106_0_19, 115, -1, G__defined_typename("Short_t"), 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Cont_106_0_20, 115, -1, G__defined_typename("Short_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Cont_106_0_21, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TArrayS::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_106_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrayS::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_106_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TArrayS::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_106_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TArrayS::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_106_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_106_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrayS::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_106_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArrayS::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_106_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrayS::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_106_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArrayS::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TArrayS", 804, G__G__Cont_106_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBits(void) {
   /* TBits */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TBits));
   G__memfunc_setup("ReserveBytes",1251,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "h - 'UInt_t' 0 - nbytes", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoAndEqual",958,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TBits' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoOrEqual",876,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TBits' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoXorEqual",996,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TBits' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoLeftShift",1084,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "h - 'UInt_t' 0 - shift", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRightShift",1199,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "h - 'UInt_t' 0 - shift", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoFlip",574,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBits",486,G__G__Cont_107_0_8, 105, G__get_linked_tagnum(&G__G__ContLN_TBits), -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 '8' nbits", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBits",486,G__G__Cont_107_0_9, 105, G__get_linked_tagnum(&G__G__ContLN_TBits), -1, 0, 1, 1, 1, 0, "u 'TBits' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Cont_107_0_10, 117, G__get_linked_tagnum(&G__G__ContLN_TBits), -1, 1, 1, 1, 1, 0, "u 'TBits' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetAllBits",1198,G__G__Cont_107_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' value", "if value=1 set all bits to 1", (void*) NULL, 0);
   G__memfunc_setup("ResetBitNumber",1419,G__G__Cont_107_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - bitnumber", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBitNumber",1204,G__G__Cont_107_0_13, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - bitnumber g - 'Bool_t' 0 'kTRUE' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TestBitNumber",1320,G__G__Cont_107_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - bitnumber", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Cont_107_0_15, 117, G__get_linked_tagnum(&G__G__ContLN_TBitscLcLTReference), -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - bitnumber", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Cont_107_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - bitnumber", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator&=",975,G__G__Cont_107_0_17, 117, G__get_linked_tagnum(&G__G__ContLN_TBits), -1, 1, 1, 1, 1, 0, "u 'TBits' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator|=",1061,G__G__Cont_107_0_18, 117, G__get_linked_tagnum(&G__G__ContLN_TBits), -1, 1, 1, 1, 1, 0, "u 'TBits' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator^=",1031,G__G__Cont_107_0_19, 117, G__get_linked_tagnum(&G__G__ContLN_TBits), -1, 1, 1, 1, 1, 0, "u 'TBits' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator<<=",1057,G__G__Cont_107_0_20, 117, G__get_linked_tagnum(&G__G__ContLN_TBits), -1, 1, 1, 1, 1, 0, "h - 'UInt_t' 0 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator>>=",1061,G__G__Cont_107_0_21, 117, G__get_linked_tagnum(&G__G__ContLN_TBits), -1, 1, 1, 1, 1, 0, "h - 'UInt_t' 0 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator<<",996,G__G__Cont_107_0_22, 117, G__get_linked_tagnum(&G__G__ContLN_TBits), -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator>>",1000,G__G__Cont_107_0_23, 117, G__get_linked_tagnum(&G__G__ContLN_TBits), -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator~",1002,G__G__Cont_107_0_24, 117, G__get_linked_tagnum(&G__G__ContLN_TBits), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Cont_107_0_25, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - nbits C - 'Char_t' 10 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Cont_107_0_26, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - nbits B - 'UChar_t' 10 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Cont_107_0_27, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - nbits S - 'Short_t' 10 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Cont_107_0_28, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - nbits R - 'UShort_t' 10 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Cont_107_0_29, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - nbits I - 'Int_t' 10 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Cont_107_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - nbits H - 'UInt_t' 10 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Cont_107_0_31, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - nbits N - 'Long64_t' 10 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Cont_107_0_32, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - nbits M - 'ULong64_t' 10 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get",288,G__G__Cont_107_0_33, 121, -1, -1, 0, 1, 1, 1, 8, "C - 'Char_t' 0 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get",288,G__G__Cont_107_0_34, 121, -1, -1, 0, 1, 1, 1, 8, "B - 'UChar_t' 0 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get",288,G__G__Cont_107_0_35, 121, -1, -1, 0, 1, 1, 1, 8, "S - 'Short_t' 0 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get",288,G__G__Cont_107_0_36, 121, -1, -1, 0, 1, 1, 1, 8, "R - 'UShort_t' 0 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get",288,G__G__Cont_107_0_37, 121, -1, -1, 0, 1, 1, 1, 8, "I - 'Int_t' 0 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get",288,G__G__Cont_107_0_38, 121, -1, -1, 0, 1, 1, 1, 8, "H - 'UInt_t' 0 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get",288,G__G__Cont_107_0_39, 121, -1, -1, 0, 1, 1, 1, 8, "N - 'Long64_t' 0 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get",288,G__G__Cont_107_0_40, 121, -1, -1, 0, 1, 1, 1, 8, "M - 'ULong64_t' 0 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Compact",711,G__G__Cont_107_0_42, 121, -1, -1, 0, 0, 1, 1, 0, "", "Reduce the space used.", (void*) NULL, 0);
   G__memfunc_setup("CountBits",923,G__G__Cont_107_0_43, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 '0' startBit", "return number of bits set to 1", (void*) NULL, 0);
   G__memfunc_setup("FirstNullBit",1218,G__G__Cont_107_0_44, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 '0' startBit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FirstSetBit",1107,G__G__Cont_107_0_45, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 '0' startBit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNbits",800,G__G__Cont_107_0_46, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNbytes",917,G__G__Cont_107_0_47, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__G__Cont_107_0_48, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TBits' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__G__Cont_107_0_49, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TBits' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "to visualize the bits array as an histogram, etc", (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", "to show the list of active bits", (void*) NULL, 1);
   G__memfunc_setup("Output",657,G__G__Cont_107_0_52, 121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Cont_107_0_53, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBits::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_107_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBits::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_107_0_55, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBits::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_107_0_56, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBits::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_107_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_107_0_61, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBits::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_107_0_62, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBits::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_107_0_63, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBits::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_107_0_64, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBits::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TBits", 612, G__G__Cont_107_0_65, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBitscLcLTReference(void) {
   /* TBits::TReference */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TBitscLcLTReference));
   G__memfunc_setup("TReference",995,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ContLN_TBitscLcLTReference), -1, 0, 0, 1, 4, 0, "", "left undefined", (void*) NULL, 0);
   G__memfunc_setup("TReference",995,G__G__Cont_108_0_2, 105, G__get_linked_tagnum(&G__G__ContLN_TBitscLcLTReference), -1, 0, 2, 1, 1, 0, 
"u 'TBits' - 1 - bit h - 'UInt_t' 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Cont_108_0_3, 117, G__get_linked_tagnum(&G__G__ContLN_TBitscLcLTReference), -1, 1, 1, 1, 1, 0, "g - 'Bool_t' 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Cont_108_0_4, 117, G__get_linked_tagnum(&G__G__ContLN_TBitscLcLTReference), -1, 1, 1, 1, 1, 0, "u 'TBits::TReference' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator Bool_t",1515,G__G__Cont_108_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TReference", 995, G__G__Cont_108_0_6, (int) ('i'), G__get_linked_tagnum(&G__G__ContLN_TBitscLcLTReference), -1, 0, 1, 1, 1, 0, "u 'TBits::TReference' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TReference", 1121, G__G__Cont_108_0_7, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTCollection(void) {
   /* TCollection */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TCollection));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TCollection' - 11 - -", "are too complex to be automatically copied", (void*) NULL, 0);
   G__memfunc_setup("PrintCollectionHeader",2146,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCollectionEntryName",2239,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 1, 1, 2, 9, "U 'TObject' - 0 - entry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintCollectionEntry",2091,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 8, 
"U 'TObject' - 0 - entry C - 'Option_t' 10 - option "
"i - 'Int_t' 0 - recurse", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,G__G__Cont_109_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddVector",892,G__G__Cont_109_0_8, 121, -1, -1, 0, 1, 8, 1, 0, "U 'TObject' - 0 - obj1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAll",546,G__G__Cont_109_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TCollection' - 10 - col", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AssertClass",1128,G__G__Cont_109_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Capacity",814,G__G__Cont_109_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 '\"\"' newname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Compare",711,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,G__G__Cont_109_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Contains",831,G__G__Cont_109_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Dump",406,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator()",957,G__G__Cont_109_0_22, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntries",1018,G__G__Cont_109_0_24, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjectRef",1172,G__G__Cont_109_0_26, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 2, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetSize",699,G__G__Cont_109_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GrowBy",602,G__G__Cont_109_0_28, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - delta", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Hash",388,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsArgNull",881,G__G__Cont_109_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"C - - 10 - where U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsEmpty",715,G__G__Cont_109_0_31, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsOwner",711,G__G__Cont_109_0_33, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSortable",1016,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeIterator",1224,G__G__Cont_109_0_36, 85, G__get_linked_tagnum(&G__G__ContLN_TIterator), -1, 0, 1, 1, 1, 8, "g - 'Bool_t' 0 'kIterForward' dir", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("MakeReverseIterator",1956,G__G__Cont_109_0_37, 85, G__get_linked_tagnum(&G__G__ContLN_TIterator), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,G__G__Cont_109_0_40, 121, -1, -1, 0, 2, 1, 1, 8, 
"C - 'Option_t' 10 - option i - 'Int_t' 0 - recurse", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,G__G__Cont_109_0_41, 121, -1, -1, 0, 3, 1, 1, 8, 
"C - 'Option_t' 10 - option C - - 10 - wildcard "
"i - 'Int_t' 0 '1' recurse", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,G__G__Cont_109_0_42, 121, -1, -1, 0, 3, 1, 1, 8, 
"C - 'Option_t' 10 - option u 'TPRegexp' - 1 - regexp "
"i - 'Int_t' 0 '1' recurse", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,G__G__Cont_109_0_44, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("RemoveAll",903,G__G__Cont_109_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TCollection' - 0 - col", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveAll",903,G__G__Cont_109_0_46, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrentCollection",2075,G__G__Cont_109_0_47, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetName",685,G__G__Cont_109_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOwner",823,G__G__Cont_109_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' enable", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Write",523,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 '0' name i - 'Int_t' 0 '0' option "
"i - 'Int_t' 0 '0' bufsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Write",523,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 8, 
"C - - 10 '0' name i - 'Int_t' 0 '0' option "
"i - 'Int_t' 0 '0' bufsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrentCollection",2063,G__G__Cont_109_0_52, 85, G__get_linked_tagnum(&G__G__ContLN_TCollection), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TCollection* (*)())(&TCollection::GetCurrentCollection) ), 0);
   G__memfunc_setup("StartGarbageCollection",2243,G__G__Cont_109_0_53, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCollection::StartGarbageCollection) ), 0);
   G__memfunc_setup("GarbageCollect",1391,G__G__Cont_109_0_54, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) G__func2void( (void (*)(TObject*))(&TCollection::GarbageCollect) ), 0);
   G__memfunc_setup("EmptyGarbageCollection",2244,G__G__Cont_109_0_55, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCollection::EmptyGarbageCollection) ), 0);
   G__memfunc_setup("Class",502,G__G__Cont_109_0_56, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TCollection::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_109_0_57, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCollection::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_109_0_58, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TCollection::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_109_0_59, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCollection::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_109_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_109_0_64, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCollection::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_109_0_65, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCollection::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_109_0_66, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCollection::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_109_0_67, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCollection::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TCollection", 1246, G__G__Cont_109_0_68, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTIterator(void) {
   /* TIterator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TIterator));
   G__memfunc_setup("operator=",937,G__G__Cont_110_0_3, 117, G__get_linked_tagnum(&G__G__ContLN_TIterator), -1, 1, 1, 1, 1, 0, "u 'TIterator' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCollection",1324,G__G__Cont_110_0_4, 85, G__get_linked_tagnum(&G__G__ContLN_TCollection), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetOption",921,G__G__Cont_110_0_5, 67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Next",415,G__G__Cont_110_0_6, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Reset",515,G__G__Cont_110_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("operator()",957,G__G__Cont_110_0_8, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__G__Cont_110_0_9, 103, -1, -1, 0, 1, 1, 1, 8, "u 'TIterator' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator*",918,G__G__Cont_110_0_10, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Cont_110_0_11, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TIterator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_110_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TIterator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_110_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TIterator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_110_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TIterator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Cont_110_0_15, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Cont_110_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Cont_110_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_110_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_110_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TIterator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_110_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TIterator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_110_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TIterator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_110_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TIterator::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TIterator", 1052, G__G__Cont_110_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTObjectTable(void) {
   /* TObjectTable */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TObjectTable));
   G__memfunc_setup("HighWaterMark",1294,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Expand",608,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - newsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindElement",1099,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FixCollisions",1350,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TObjectTable",1171,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ContLN_TObjectTable), -1, 0, 1, 1, 4, 0, "u 'TObjectTable' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__ContLN_TObjectTable), -1, 1, 1, 1, 4, 0, "u 'TObjectTable' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TObjectTable",1171,G__G__Cont_122_0_7, 105, G__get_linked_tagnum(&G__G__ContLN_TObjectTable), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '100' tableSize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Cont_122_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckPtrAndWarn",1471,G__G__Cont_122_0_9, 89, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - msg Y - - 0 - vp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSize",699,G__G__Cont_122_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Instances",936,G__G__Cont_122_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InstanceStatistics",1888,G__G__Cont_122_0_13, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PtrIsValid",994,G__G__Cont_122_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TObject' - 0 - op", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Remove",622,G__G__Cont_122_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveQuietly",1371,G__G__Cont_122_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Statistics",1067,G__G__Cont_122_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Terminate",937,G__G__Cont_122_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateInstCount",1546,G__G__Cont_122_0_20, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddObj",548,G__G__Cont_122_0_21, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) G__func2void( (void (*)(TObject*))(&TObjectTable::AddObj) ), 0);
   G__memfunc_setup("Class",502,G__G__Cont_122_0_22, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TObjectTable::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_122_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TObjectTable::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_122_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TObjectTable::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_122_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TObjectTable::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_122_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_122_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TObjectTable::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_122_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TObjectTable::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_122_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TObjectTable::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_122_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TObjectTable::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TObjectTable", 1297, G__G__Cont_122_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTIter(void) {
   /* TIter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TIter));
   G__memfunc_setup("TIter",488,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ContLN_TIter), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TIter",488,G__G__Cont_124_0_2, 105, G__get_linked_tagnum(&G__G__ContLN_TIter), -1, 0, 2, 1, 1, 0, 
"U 'TCollection' - 10 - col g - 'Bool_t' 0 'kIterForward' dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TIter",488,G__G__Cont_124_0_3, 105, G__get_linked_tagnum(&G__G__ContLN_TIter), -1, 0, 1, 1, 1, 0, "U 'TIterator' - 0 - it", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TIter",488,G__G__Cont_124_0_4, 105, G__get_linked_tagnum(&G__G__ContLN_TIter), -1, 0, 1, 1, 1, 0, "u 'TIter' - 11 - iter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Cont_124_0_5, 117, G__get_linked_tagnum(&G__G__ContLN_TIter), -1, 1, 1, 1, 1, 0, "u 'TIter' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Cont_124_0_6, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Next",415,G__G__Cont_124_0_7, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCollection",1324,G__G__Cont_124_0_8, 85, G__get_linked_tagnum(&G__G__ContLN_TCollection), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOption",921,G__G__Cont_124_0_9, 67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Cont_124_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Cont_124_0_11, 117, G__get_linked_tagnum(&G__G__ContLN_TIter), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__G__Cont_124_0_12, 103, -1, -1, 0, 1, 1, 1, 8, "u 'TIter' - 11 - aIter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__G__Cont_124_0_13, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Begin",485,G__G__Cont_124_0_14, 117, G__get_linked_tagnum(&G__G__ContLN_TIter), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("End",279,G__G__Cont_124_0_15, 117, G__get_linked_tagnum(&G__G__ContLN_TIter), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TIter (*)())(&TIter::End) ), 0);
   G__memfunc_setup("Class",502,G__G__Cont_124_0_16, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TIter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_124_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TIter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_124_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TIter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_124_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TIter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Cont_124_0_20, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Cont_124_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Cont_124_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_124_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_124_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TIter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_124_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TIter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_124_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TIter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_124_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TIter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TIter", 614, G__G__Cont_124_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSeqCollection(void) {
   /* TSeqCollection */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TSeqCollection));
   G__memfunc_setup("Changed",682,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFirst",785,G__G__Cont_125_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddLast",669,G__G__Cont_125_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddAt",446,G__G__Cont_125_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddAfter",763,G__G__Cont_125_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - after U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddBefore",860,G__G__Cont_125_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - before U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("RemoveFirst",1142,G__G__Cont_125_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveLast",1026,G__G__Cont_125_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveAt",803,G__G__Cont_125_0_11, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveAfter",1120,G__G__Cont_125_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - after", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveBefore",1217,G__G__Cont_125_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - before", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("At",181,G__G__Cont_125_0_14, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Before",595,G__G__Cont_125_0_15, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("After",498,G__G__Cont_125_0_16, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("First",520,G__G__Cont_125_0_17, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Last",404,G__G__Cont_125_0_18, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("LastIndex",908,G__G__Cont_125_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IndexOf",685,G__G__Cont_125_0_20, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsSorted",813,G__G__Cont_125_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnSort",619,G__G__Cont_125_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Merge",496,G__G__Cont_125_0_23, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "U 'TCollection' - 0 - list", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ObjCompare",994,G__G__Cont_125_0_24, 105, -1, G__defined_typename("Int_t"), 0, 2, 3, 1, 0, 
"U 'TObject' - 0 - a U 'TObject' - 0 - b", (char*)NULL, (void*) G__func2void( (Int_t (*)(TObject*, TObject*))(&TSeqCollection::ObjCompare) ), 0);
   G__memfunc_setup("QSort",505,G__G__Cont_125_0_25, 121, -1, -1, 0, 3, 3, 1, 0, 
"U 'TObject' - 2 - a i - 'Int_t' 0 - first "
"i - 'Int_t' 0 - last", (char*)NULL, (void*) G__func2void( (void (*)(TObject**, Int_t, Int_t))(&TSeqCollection::QSort) ), 0);
   G__memfunc_setup("QSort",505,G__G__Cont_125_0_26, 121, -1, -1, 0, 4, 3, 1, 0, 
"U 'TObject' - 2 - a U 'TObject' - 2 - b "
"i - 'Int_t' 0 - first i - 'Int_t' 0 - last", (char*)NULL, (void*) G__func2void( (void (*)(TObject**, TObject**, Int_t, Int_t))(&TSeqCollection::QSort) ), 0);
   G__memfunc_setup("QSort",505,G__G__Cont_125_0_27, 121, -1, -1, 0, 5, 3, 1, 0, 
"U 'TObject' - 2 - a i - 'Int_t' 0 - nBs "
"U 'TObject' - 3 - b i - 'Int_t' 0 - first "
"i - 'Int_t' 0 - last", (char*)NULL, (void*) G__func2void( (void (*)(TObject**, Int_t, TObject***, Int_t, Int_t))(&TSeqCollection::QSort) ), 0);
   G__memfunc_setup("Class",502,G__G__Cont_125_0_28, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSeqCollection::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_125_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSeqCollection::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_125_0_30, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSeqCollection::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_125_0_31, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSeqCollection::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_125_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_125_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSeqCollection::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_125_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSeqCollection::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_125_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSeqCollection::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_125_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSeqCollection::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSeqCollection", 1543, G__G__Cont_125_0_40, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBtreeIter(void) {
   /* TBtreeIter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TBtreeIter));
   G__memfunc_setup("TBtreeIter",986,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ContLN_TBtreeIter), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBtreeIter",986,G__G__Cont_129_0_2, 105, G__get_linked_tagnum(&G__G__ContLN_TBtreeIter), -1, 0, 2, 1, 1, 0, 
"U 'TBtree' - 10 - t g - 'Bool_t' 0 'kIterForward' dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBtreeIter",986,G__G__Cont_129_0_3, 105, G__get_linked_tagnum(&G__G__ContLN_TBtreeIter), -1, 0, 1, 1, 1, 0, "u 'TBtreeIter' - 11 - iter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__ContLN_TIterator), -1, 1, 1, 1, 1, 0, "u 'TIterator' - 11 - rhs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Cont_129_0_5, 117, G__get_linked_tagnum(&G__G__ContLN_TBtreeIter), -1, 1, 1, 1, 1, 0, "u 'TBtreeIter' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCollection",1324,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TCollection), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Next",415,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator!=",970,(G__InterfaceMethod) NULL,103, -1, -1, 0, 1, 1, 1, 8, "u 'TIterator' - 11 - aIter", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator!=",970,G__G__Cont_129_0_10, 103, -1, -1, 0, 1, 1, 1, 8, "u 'TBtreeIter' - 11 - aIter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Cont_129_0_12, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBtreeIter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_129_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBtreeIter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_129_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBtreeIter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_129_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBtreeIter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_129_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_129_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBtreeIter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_129_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBtreeIter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_129_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBtreeIter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_129_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBtreeIter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TBtreeIter", 1112, G__G__Cont_129_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBtree(void) {
   /* TBtree */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TBtree));
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - i", "initialize btree", (void*) NULL, 0);
   G__memfunc_setup("RootIsFull",1011,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", "called when the root node is full", (void*) NULL, 0);
   G__memfunc_setup("RootIsEmpty",1135,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", "called when root is empty", (void*) NULL, 0);
   G__memfunc_setup("IncrNofKeys",1099,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DecrNofKeys",1085,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IdxAdd",558,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "u 'TObject' - 11 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBtree",582,G__G__Cont_130_0_7, 105, G__get_linked_tagnum(&G__G__ContLN_TBtree), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '3' ordern", "create a TBtree of order n", (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjectRef",1172,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 2, 1, 1, 1, 8, "U 'TObject' - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeIterator",1224,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TIterator), -1, 0, 1, 1, 1, 8, "g - 'Bool_t' 0 'kIterForward' dir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFirst",785,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLast",669,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAt",446,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAfter",763,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - - U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBefore",860,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - - U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("At",181,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Before",595,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("After",498,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("First",520,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Last",404,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Order",508,G__G__Cont_130_0_26, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Cont_130_0_27, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rank",396,G__G__Cont_130_0_28, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Cont_130_0_29, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBtree::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_130_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBtree::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_130_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBtree::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_130_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBtree::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_130_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_130_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBtree::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_130_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBtree::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_130_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBtree::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_130_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBtree::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TBtree", 708, G__G__Cont_130_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTClassTable(void) {
   /* TClassTable */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TClassTable));
   G__memfunc_setup("TClassTable",1074,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ContLN_TClassTable), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindElementImpl",1501,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ContLN_TClassRec), -1, 0, 2, 3, 4, 0, 
"C - - 10 - cname g - 'Bool_t' 0 - insert", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindElement",1099,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ContLN_TClassRec), -1, 0, 2, 3, 4, 0, 
"C - - 10 - cname g - 'Bool_t' 0 'kFALSE' insert", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SortTable",912,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 3, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Cont_135_0_5, 121, -1, -1, 0, 5, 3, 1, 0, 
"C - - 10 - cname s - 'Version_t' 0 - id "
"u 'type_info' - 11 - info Y - 'VoidFuncPtr_t' 0 - dict "
"i - 'Int_t' 0 - pragmabits", (char*)NULL, (void*) G__func2void( (void (*)(const char*, Version_t, const type_info&, VoidFuncPtr_t, Int_t))(&TClassTable::Add) ), 0);
   G__memfunc_setup("At",181,G__G__Cont_135_0_6, 67, -1, -1, 0, 1, 3, 1, 0, "i - - 0 - index", (char*)NULL, (void*) G__func2void( (char* (*)(int))(&TClassTable::At) ), 0);
   G__memfunc_setup("Classes",718,G__G__Cont_135_0_7, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetID",429,G__G__Cont_135_0_8, 115, -1, G__defined_typename("Version_t"), 0, 1, 3, 1, 0, "C - - 10 - cname", (char*)NULL, (void*) G__func2void( (Version_t (*)(const char*))(&TClassTable::GetID) ), 0);
   G__memfunc_setup("GetPragmaBits",1290,G__G__Cont_135_0_9, 105, -1, G__defined_typename("Int_t"), 0, 1, 3, 1, 0, "C - - 10 - name", (char*)NULL, (void*) G__func2void( (Int_t (*)(const char*))(&TClassTable::GetPragmaBits) ), 0);
   G__memfunc_setup("GetDict",676,G__G__Cont_135_0_10, 89, -1, G__defined_typename("VoidFuncPtr_t"), 0, 1, 3, 1, 0, "C - - 10 - cname", (char*)NULL, (void*) G__func2void( (VoidFuncPtr_t (*)(const char*))(&TClassTable::GetDict) ), 0);
   G__memfunc_setup("GetDict",676,G__G__Cont_135_0_11, 89, -1, G__defined_typename("VoidFuncPtr_t"), 0, 1, 3, 1, 0, "u 'type_info' - 11 - info", (char*)NULL, (void*) G__func2void( (VoidFuncPtr_t (*)(const type_info&))(&TClassTable::GetDict) ), 0);
   G__memfunc_setup("Init",404,G__G__Cont_135_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TClassTable::Init) ), 0);
   G__memfunc_setup("Next",415,G__G__Cont_135_0_13, 67, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (char* (*)())(&TClassTable::Next) ), 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintTable",1013,G__G__Cont_135_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TClassTable::PrintTable) ), 0);
   G__memfunc_setup("Remove",622,G__G__Cont_135_0_16, 121, -1, -1, 0, 1, 3, 1, 0, "C - - 10 - cname", (char*)NULL, (void*) G__func2void( (void (*)(const char*))(&TClassTable::Remove) ), 0);
   G__memfunc_setup("Terminate",937,G__G__Cont_135_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TClassTable::Terminate) ), 0);
   G__memfunc_setup("Class",502,G__G__Cont_135_0_18, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TClassTable::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_135_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TClassTable::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_135_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TClassTable::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_135_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TClassTable::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_135_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_135_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TClassTable::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_135_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TClassTable::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_135_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TClassTable::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_135_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TClassTable::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TClassTable", 1074, G__G__Cont_135_0_30, (int) ('i'), G__get_linked_tagnum(&G__G__ContLN_TClassTable), -1, 0, 1, 1, 1, 0, "u 'TClassTable' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TClassTable", 1200, G__G__Cont_135_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Cont_135_0_32, (int) ('u'), G__get_linked_tagnum(&G__G__ContLN_TClassTable), -1, 1, 1, 1, 1, 0, "u 'TClassTable' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTObjArrayIter(void) {
   /* TObjArrayIter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TObjArrayIter));
   G__memfunc_setup("TObjArrayIter",1282,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ContLN_TObjArrayIter), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TObjArrayIter",1282,G__G__Cont_137_0_2, 105, G__get_linked_tagnum(&G__G__ContLN_TObjArrayIter), -1, 0, 2, 1, 1, 0, 
"U 'TObjArray' - 10 - arr g - 'Bool_t' 0 'kIterForward' dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TObjArrayIter",1282,G__G__Cont_137_0_3, 105, G__get_linked_tagnum(&G__G__ContLN_TObjArrayIter), -1, 0, 1, 1, 1, 0, "u 'TObjArrayIter' - 11 - iter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__ContLN_TIterator), -1, 1, 1, 1, 1, 0, "u 'TIterator' - 11 - rhs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Cont_137_0_5, 117, G__get_linked_tagnum(&G__G__ContLN_TObjArrayIter), -1, 1, 1, 1, 1, 0, "u 'TObjArrayIter' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCollection",1324,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TCollection), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Next",415,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator!=",970,(G__InterfaceMethod) NULL,103, -1, -1, 0, 1, 1, 1, 8, "u 'TIterator' - 11 - aIter", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator!=",970,G__G__Cont_137_0_10, 103, -1, -1, 0, 1, 1, 1, 8, "u 'TObjArrayIter' - 11 - aIter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Cont_137_0_12, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TObjArrayIter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_137_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TObjArrayIter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_137_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TObjArrayIter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_137_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TObjArrayIter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_137_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_137_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TObjArrayIter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_137_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TObjArrayIter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_137_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TObjArrayIter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_137_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TObjArrayIter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TObjArrayIter", 1408, G__G__Cont_137_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTExMapIter(void) {
   /* TExMapIter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TExMapIter));
   G__memfunc_setup("TExMapIter",963,G__G__Cont_148_0_1, 105, G__get_linked_tagnum(&G__G__ContLN_TExMapIter), -1, 0, 1, 1, 1, 0, "U 'TExMap' - 10 - map", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TExMapIter",963,G__G__Cont_148_0_2, 105, G__get_linked_tagnum(&G__G__ContLN_TExMapIter), -1, 0, 1, 1, 1, 0, "u 'TExMapIter' - 11 - tei", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Cont_148_0_3, 117, G__get_linked_tagnum(&G__G__ContLN_TExMapIter), -1, 1, 1, 1, 1, 0, "u 'TExMapIter' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCollection",1324,G__G__Cont_148_0_4, 85, G__get_linked_tagnum(&G__G__ContLN_TExMap), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Next",415,G__G__Cont_148_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"m - 'ULong64_t' 1 - hash n - 'Long64_t' 1 - key "
"n - 'Long64_t' 1 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Next",415,G__G__Cont_148_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"n - 'Long64_t' 1 - key n - 'Long64_t' 1 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Cont_148_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Cont_148_0_8, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TExMapIter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_148_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TExMapIter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_148_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TExMapIter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_148_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TExMapIter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Cont_148_0_12, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Cont_148_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Cont_148_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_148_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_148_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TExMapIter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_148_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TExMapIter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_148_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TExMapIter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_148_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TExMapIter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TExMapIter", 1089, G__G__Cont_148_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTExMap(void) {
   /* TExMap */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TExMap));
   G__memfunc_setup("HighWaterMark",1294,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindElement",1099,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
"m - 'ULong64_t' 0 - hash n - 'Long64_t' 0 - key", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FixCollisions",1350,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TExMap",559,G__G__Cont_149_0_4, 105, G__get_linked_tagnum(&G__G__ContLN_TExMap), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '100' mapSize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TExMap",559,G__G__Cont_149_0_5, 105, G__get_linked_tagnum(&G__G__ContLN_TExMap), -1, 0, 1, 1, 1, 0, "u 'TExMap' - 11 - map", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Cont_149_0_6, 117, G__get_linked_tagnum(&G__G__ContLN_TExMap), -1, 1, 1, 1, 1, 0, "u 'TExMap' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Cont_149_0_7, 121, -1, -1, 0, 3, 1, 1, 0, 
"m - 'ULong64_t' 0 - hash n - 'Long64_t' 0 - key "
"n - 'Long64_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Cont_149_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - key n - 'Long64_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAt",446,G__G__Cont_149_0_9, 121, -1, -1, 0, 4, 1, 1, 0, 
"h - 'UInt_t' 0 - slot m - 'ULong64_t' 0 - hash "
"n - 'Long64_t' 0 - key n - 'Long64_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Capacity",814,G__G__Cont_149_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Expand",608,G__G__Cont_149_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - newsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSize",699,G__G__Cont_149_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValue",797,G__G__Cont_149_0_14, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
"m - 'ULong64_t' 0 - hash n - 'Long64_t' 0 - key", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValue",797,G__G__Cont_149_0_15, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - key", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValue",797,G__G__Cont_149_0_16, 110, -1, G__defined_typename("Long64_t"), 0, 3, 1, 1, 0, 
"m - 'ULong64_t' 0 - hash n - 'Long64_t' 0 - key "
"h - 'UInt_t' 1 - slot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Remove",622,G__G__Cont_149_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"m - 'ULong64_t' 0 - hash n - 'Long64_t' 0 - key", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Remove",622,G__G__Cont_149_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - key", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Cont_149_0_19, 110, -1, G__defined_typename("Long64_t"), 1, 2, 1, 1, 0, 
"m - 'ULong64_t' 0 - hash n - 'Long64_t' 0 - key", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Cont_149_0_20, 110, -1, G__defined_typename("Long64_t"), 1, 1, 1, 1, 0, "n - 'Long64_t' 0 - key", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Cont_149_0_21, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TExMap::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_149_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TExMap::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_149_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TExMap::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_149_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TExMap::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_149_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_149_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TExMap::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_149_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TExMap::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_149_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TExMap::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_149_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TExMap::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TExMap", 685, G__G__Cont_149_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTListIter(void) {
   /* TListIter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TListIter));
   G__memfunc_setup("TListIter",900,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ContLN_TListIter), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TListIter",900,G__G__Cont_152_0_2, 105, G__get_linked_tagnum(&G__G__ContLN_TListIter), -1, 0, 2, 1, 1, 0, 
"U 'TList' - 10 - l g - 'Bool_t' 0 'kIterForward' dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TListIter",900,G__G__Cont_152_0_3, 105, G__get_linked_tagnum(&G__G__ContLN_TListIter), -1, 0, 1, 1, 1, 0, "u 'TListIter' - 11 - iter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__ContLN_TIterator), -1, 1, 1, 1, 1, 0, "u 'TIterator' - 11 - rhs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Cont_152_0_5, 117, G__get_linked_tagnum(&G__G__ContLN_TListIter), -1, 1, 1, 1, 1, 0, "u 'TListIter' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCollection",1324,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TCollection), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOption",921,(G__InterfaceMethod) NULL,67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOption",933,G__G__Cont_152_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Next",415,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator!=",970,(G__InterfaceMethod) NULL,103, -1, -1, 0, 1, 1, 1, 8, "u 'TIterator' - 11 - aIter", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator!=",970,G__G__Cont_152_0_12, 103, -1, -1, 0, 1, 1, 1, 8, "u 'TListIter' - 11 - aIter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Cont_152_0_14, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TListIter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_152_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TListIter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_152_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TListIter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_152_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TListIter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_152_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_152_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TListIter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_152_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TListIter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_152_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TListIter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_152_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TListIter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TListIter", 1026, G__G__Cont_152_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHashTable(void) {
   /* THashTable */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_THashTable));
   G__memfunc_setup("GetHashValue",1185,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHashValue",1185,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 8, "u 'TString' - 1 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHashValue",1185,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 8, "C - - 10 - str", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THashTable",960,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ContLN_THashTable), -1, 0, 1, 1, 4, 0, "u 'THashTable' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__ContLN_THashTable), -1, 1, 1, 1, 4, 0, "u 'THashTable' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("THashTable",960,G__G__Cont_154_0_6, 105, G__get_linked_tagnum(&G__G__ContLN_THashTable), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 'TCollection::kInitHashTableCapacity' capacity i - 'Int_t' 0 '0' rehash", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAll",546,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TCollection' - 10 - col", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AverageCollisions",1754,G__G__Cont_154_0_9, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Collisions",1055,G__G__Cont_154_0_11, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Collisions",1055,G__G__Cont_154_0_12, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListForObject",1594,G__G__Cont_154_0_16, 85, G__get_linked_tagnum(&G__G__ContLN_TList), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListForObject",1594,G__G__Cont_154_0_17, 85, G__get_linked_tagnum(&G__G__ContLN_TList), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObjectRef",1172,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 2, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRehashLevel",1395,G__G__Cont_154_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSize",699,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeIterator",1224,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TIterator), -1, 0, 1, 1, 1, 8, "g - 'Bool_t' 0 'kIterForward' dir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rehash",603,G__G__Cont_154_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - newCapacity g - 'Bool_t' 0 'kTRUE' checkObjValidity", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Remove",622,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveSlow",1043,G__G__Cont_154_0_24, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRehashLevel",1407,G__G__Cont_154_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - rehash", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Cont_154_0_26, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THashTable::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_154_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THashTable::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_154_0_28, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THashTable::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_154_0_29, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THashTable::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_154_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_154_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THashTable::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_154_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THashTable::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_154_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THashTable::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_154_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THashTable::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~THashTable", 1086, G__G__Cont_154_0_38, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHashList(void) {
   /* THashList */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_THashList));
   G__memfunc_setup("THashList",884,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ContLN_THashList), -1, 0, 1, 1, 4, 0, "u 'THashList' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__ContLN_THashList), -1, 1, 1, 1, 4, 0, "u 'THashList' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("THashList",884,G__G__Cont_155_0_3, 105, G__get_linked_tagnum(&G__G__ContLN_THashList), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 'TCollection::kInitHashTableCapacity' capacity i - 'Int_t' 0 '0' rehash", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THashList",884,G__G__Cont_155_0_4, 105, G__get_linked_tagnum(&G__G__ContLN_THashList), -1, 0, 3, 1, 1, 0, 
"U 'TObject' - 0 - parent i - 'Int_t' 0 'TCollection::kInitHashTableCapacity' capacity "
"i - 'Int_t' 0 '0' rehash", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AverageCollisions",1754,G__G__Cont_155_0_5, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListForObject",1594,G__G__Cont_155_0_10, 85, G__get_linked_tagnum(&G__G__ContLN_TList), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListForObject",1594,G__G__Cont_155_0_11, 85, G__get_linked_tagnum(&G__G__ContLN_TList), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddFirst",785,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFirst",785,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLast",669,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLast",669,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAt",446,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAfter",763,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - after U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAfter",763,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObjLink' - 0 - after U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBefore",860,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - before U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBefore",860,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObjLink' - 0 - before U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rehash",603,G__G__Cont_155_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - newCapacity", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Remove",622,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 0, "U 'TObjLink' - 0 - lnk", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Cont_155_0_25, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THashList::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_155_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THashList::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_155_0_27, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THashList::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_155_0_28, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THashList::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_155_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_155_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THashList::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_155_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THashList::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_155_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THashList::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_155_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THashList::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~THashList", 1010, G__G__Cont_155_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHashTableIter(void) {
   /* THashTableIter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_THashTableIter));
   G__memfunc_setup("THashTableIter",1364,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ContLN_THashTableIter), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NextSlot",833,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THashTableIter",1364,G__G__Cont_156_0_3, 105, G__get_linked_tagnum(&G__G__ContLN_THashTableIter), -1, 0, 2, 1, 1, 0, 
"U 'THashTable' - 10 - ht g - 'Bool_t' 0 'kIterForward' dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THashTableIter",1364,G__G__Cont_156_0_4, 105, G__get_linked_tagnum(&G__G__ContLN_THashTableIter), -1, 0, 1, 1, 1, 0, "u 'THashTableIter' - 11 - iter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__ContLN_TIterator), -1, 1, 1, 1, 1, 0, "u 'TIterator' - 11 - rhs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Cont_156_0_6, 117, G__get_linked_tagnum(&G__G__ContLN_THashTableIter), -1, 1, 1, 1, 1, 0, "u 'THashTableIter' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCollection",1324,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TCollection), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Next",415,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator!=",970,(G__InterfaceMethod) NULL,103, -1, -1, 0, 1, 1, 1, 8, "u 'TIterator' - 11 - aIter", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator!=",970,G__G__Cont_156_0_11, 103, -1, -1, 0, 1, 1, 1, 8, "u 'THashTableIter' - 11 - aIter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Cont_156_0_13, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THashTableIter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_156_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THashTableIter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_156_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THashTableIter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_156_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THashTableIter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_156_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_156_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THashTableIter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_156_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THashTableIter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_156_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THashTableIter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_156_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THashTableIter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~THashTableIter", 1490, G__G__Cont_156_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMapIter(void) {
   /* TMapIter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TMapIter));
   G__memfunc_setup("TMapIter",774,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ContLN_TMapIter), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMapIter",774,G__G__Cont_157_0_2, 105, G__get_linked_tagnum(&G__G__ContLN_TMapIter), -1, 0, 2, 1, 1, 0, 
"U 'TMap' - 10 - map g - 'Bool_t' 0 'kIterForward' dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMapIter",774,G__G__Cont_157_0_3, 105, G__get_linked_tagnum(&G__G__ContLN_TMapIter), -1, 0, 1, 1, 1, 0, "u 'TMapIter' - 11 - iter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__ContLN_TIterator), -1, 1, 1, 1, 1, 0, "u 'TIterator' - 11 - rhs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Cont_157_0_5, 117, G__get_linked_tagnum(&G__G__ContLN_TMapIter), -1, 1, 1, 1, 1, 0, "u 'TMapIter' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCollection",1324,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TCollection), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Next",415,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator!=",970,(G__InterfaceMethod) NULL,103, -1, -1, 0, 1, 1, 1, 8, "u 'TIterator' - 11 - aIter", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator!=",970,G__G__Cont_157_0_10, 103, -1, -1, 0, 1, 1, 1, 8, "u 'TMapIter' - 11 - aIter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Cont_157_0_12, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMapIter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_157_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMapIter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_157_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMapIter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_157_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMapIter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_157_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_157_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMapIter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_157_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMapIter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_157_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMapIter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_157_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMapIter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMapIter", 900, G__G__Cont_157_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTPair(void) {
   /* TPair */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TPair));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__ContLN_TPair), -1, 1, 1, 1, 4, 0, "u 'TPair' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TPair",480,G__G__Cont_158_0_2, 105, G__get_linked_tagnum(&G__G__ContLN_TPair), -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - key U 'TObject' - 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TPair",480,G__G__Cont_158_0_3, 105, G__get_linked_tagnum(&G__G__ContLN_TPair), -1, 0, 1, 1, 1, 0, "u 'TPair' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTitle",802,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Hash",388,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("ULong_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsEqual",692,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Key",297,G__G__Cont_158_0_10, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Value",509,G__G__Cont_158_0_11, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetValue",809,G__G__Cont_158_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Cont_158_0_13, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPair::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_158_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPair::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_158_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPair::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_158_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPair::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_158_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_158_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPair::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_158_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPair::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_158_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPair::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_158_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPair::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TPair", 606, G__G__Cont_158_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMap(void) {
   /* TMap */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TMap));
   G__memfunc_setup("TMap",370,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ContLN_TMap), -1, 0, 1, 1, 4, 0, "u 'TMap' - 11 - map", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__ContLN_TMap), -1, 1, 1, 1, 4, 0, "u 'TMap' - 11 - map", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("PrintCollectionEntry",2091,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 8, 
"U 'TObject' - 0 - entry C - 'Option_t' 10 - option "
"i - 'Int_t' 0 - recurse", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TMap",370,G__G__Cont_159_0_4, 105, G__get_linked_tagnum(&G__G__ContLN_TMap), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 'TCollection::kInitHashTableCapacity' capacity i - 'Int_t' 0 '0' rehash", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,G__G__Cont_159_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - key U 'TObject' - 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AverageCollisions",1754,G__G__Cont_159_0_7, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,G__G__Cont_159_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Collisions",1055,G__G__Cont_159_0_10, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - - 10 - keyname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Collisions",1055,G__G__Cont_159_0_11, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "U 'TObject' - 0 - key", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteKeys",1007,G__G__Cont_159_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteValues",1219,G__G__Cont_159_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteAll",876,G__G__Cont_159_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteEntry",1125,G__G__Cont_159_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TObject' - 0 - key", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - keyname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindObject",984,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - key", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjectRef",1172,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 2, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTable",776,G__G__Cont_159_0_20, 85, G__get_linked_tagnum(&G__G__ContLN_THashTable), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValue",797,G__G__Cont_159_0_21, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - keyname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValue",797,G__G__Cont_159_0_22, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - key", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsOwnerValue",1220,G__G__Cont_159_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Cont_159_0_24, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - keyname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Cont_159_0_25, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - key", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeIterator",1224,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TIterator), -1, 0, 1, 1, 1, 8, "g - 'Bool_t' 0 'kIterForward' dir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rehash",603,G__G__Cont_159_0_27, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - newCapacity g - 'Bool_t' 0 'kTRUE' checkObjValidity", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Remove",622,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - key", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveEntry",1152,G__G__Cont_159_0_29, 85, G__get_linked_tagnum(&G__G__ContLN_TPair), -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - key", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOwnerValue",1332,G__G__Cont_159_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' enable", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOwnerKeyValue",1629,G__G__Cont_159_0_31, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kTRUE' ownkeys g - 'Bool_t' 0 'kTRUE' ownvals", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Cont_159_0_32, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMap::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_159_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMap::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_159_0_34, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMap::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_159_0_35, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMap::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_159_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_159_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMap::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_159_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMap::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_159_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMap::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_159_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMap::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMap", 496, G__G__Cont_159_0_44, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTOrdCollectionIter(void) {
   /* TOrdCollectionIter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TOrdCollectionIter));
   G__memfunc_setup("TOrdCollectionIter",1817,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ContLN_TOrdCollectionIter), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TOrdCollectionIter",1817,G__G__Cont_161_0_2, 105, G__get_linked_tagnum(&G__G__ContLN_TOrdCollectionIter), -1, 0, 2, 1, 1, 0, 
"U 'TOrdCollection' - 10 - col g - 'Bool_t' 0 'kIterForward' dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TOrdCollectionIter",1817,G__G__Cont_161_0_3, 105, G__get_linked_tagnum(&G__G__ContLN_TOrdCollectionIter), -1, 0, 1, 1, 1, 0, "u 'TOrdCollectionIter' - 11 - iter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__ContLN_TIterator), -1, 1, 1, 1, 1, 0, "u 'TIterator' - 11 - rhs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Cont_161_0_5, 117, G__get_linked_tagnum(&G__G__ContLN_TOrdCollectionIter), -1, 1, 1, 1, 1, 0, "u 'TOrdCollectionIter' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCollection",1324,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TCollection), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Next",415,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator!=",970,(G__InterfaceMethod) NULL,103, -1, -1, 0, 1, 1, 1, 8, "u 'TIterator' - 11 - aIter", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator!=",970,G__G__Cont_161_0_10, 103, -1, -1, 0, 1, 1, 1, 8, "u 'TOrdCollectionIter' - 11 - aIter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Cont_161_0_12, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TOrdCollectionIter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_161_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TOrdCollectionIter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_161_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TOrdCollectionIter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_161_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TOrdCollectionIter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_161_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_161_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TOrdCollectionIter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_161_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TOrdCollectionIter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_161_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TOrdCollectionIter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_161_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TOrdCollectionIter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TOrdCollectionIter", 1943, G__G__Cont_161_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTOrdCollection(void) {
   /* TOrdCollection */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TOrdCollection));
   G__memfunc_setup("PhysIndex",924,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LogIndex",794,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MoveGapTo",882,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - newGapStart", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IllegalIndex",1202,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 4, 8, 
"C - - 10 - method i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - capacity", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LowWaterMark",1216,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCapacity",1114,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - newCapacity", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TOrdCollection",1413,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ContLN_TOrdCollection), -1, 0, 1, 1, 4, 0, "u 'TOrdCollection' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__ContLN_TOrdCollection), -1, 1, 1, 1, 4, 0, "u 'TOrdCollection' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TOrdCollection",1413,G__G__Cont_162_0_10, 105, G__get_linked_tagnum(&G__G__ContLN_TOrdCollection), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 'kDefaultCapacity' capacity", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjectRef",1172,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 2, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IndexOf",685,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeIterator",1224,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TIterator), -1, 0, 1, 1, 1, 8, "g - 'Bool_t' 0 'kIterForward' dir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFirst",785,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLast",669,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAt",446,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAfter",763,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - after U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBefore",860,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - before U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PutAt",494,G__G__Cont_162_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveAt",803,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("At",181,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Before",595,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("After",498,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("First",520,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Last",404,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sort",424,G__G__Cont_162_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BinarySearch",1211,G__G__Cont_162_0_30, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Cont_162_0_31, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TOrdCollection::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_162_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TOrdCollection::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_162_0_33, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TOrdCollection::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_162_0_34, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TOrdCollection::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_162_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_162_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TOrdCollection::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_162_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TOrdCollection::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_162_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TOrdCollection::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_162_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TOrdCollection::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TOrdCollection", 1539, G__G__Cont_162_0_43, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRefArrayIter(void) {
   /* TRefArrayIter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TRefArrayIter));
   G__memfunc_setup("TRefArrayIter",1284,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ContLN_TRefArrayIter), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TRefArrayIter",1284,G__G__Cont_165_0_2, 105, G__get_linked_tagnum(&G__G__ContLN_TRefArrayIter), -1, 0, 2, 1, 1, 0, 
"U 'TRefArray' - 10 - arr g - 'Bool_t' 0 'kIterForward' dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TRefArrayIter",1284,G__G__Cont_165_0_3, 105, G__get_linked_tagnum(&G__G__ContLN_TRefArrayIter), -1, 0, 1, 1, 1, 0, "u 'TRefArrayIter' - 11 - iter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__ContLN_TIterator), -1, 1, 1, 1, 1, 0, "u 'TIterator' - 11 - rhs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Cont_165_0_5, 117, G__get_linked_tagnum(&G__G__ContLN_TRefArrayIter), -1, 1, 1, 1, 1, 0, "u 'TRefArrayIter' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCollection",1324,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TCollection), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Next",415,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator!=",970,(G__InterfaceMethod) NULL,103, -1, -1, 0, 1, 1, 1, 8, "u 'TIterator' - 11 - aIter", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator!=",970,G__G__Cont_165_0_10, 103, -1, -1, 0, 1, 1, 1, 8, "u 'TRefArrayIter' - 11 - aIter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Cont_165_0_12, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRefArrayIter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_165_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRefArrayIter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_165_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRefArrayIter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_165_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRefArrayIter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_165_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_165_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRefArrayIter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_165_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRefArrayIter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_165_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRefArrayIter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_165_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRefArrayIter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TRefArrayIter", 1410, G__G__Cont_165_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTRefArray(void) {
   /* TRefArray */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TRefArray));
   G__memfunc_setup("BoundsOk",805,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 8, 
"C - - 10 - where i - 'Int_t' 0 - at", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - s i - 'Int_t' 0 - lowerBound", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OutOfBoundsError",1634,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 8, 
"C - - 10 - where i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAbsLast",970,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFromTable",1180,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 2, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TRefArray",880,G__G__Cont_166_0_6, 105, G__get_linked_tagnum(&G__G__ContLN_TRefArray), -1, 0, 1, 1, 1, 0, "U 'TProcessID' - 0 '0' pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TRefArray",880,G__G__Cont_166_0_7, 105, G__get_linked_tagnum(&G__G__ContLN_TRefArray), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - s U 'TProcessID' - 0 - pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TRefArray",880,G__G__Cont_166_0_8, 105, G__get_linked_tagnum(&G__G__ContLN_TRefArray), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - s i - 'Int_t' 0 '0' lowerBound "
"U 'TProcessID' - 0 '0' pid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TRefArray",880,G__G__Cont_166_0_9, 105, G__get_linked_tagnum(&G__G__ContLN_TRefArray), -1, 0, 1, 1, 1, 0, "u 'TRefArray' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Cont_166_0_10, 117, G__get_linked_tagnum(&G__G__ContLN_TRefArray), -1, 1, 1, 1, 1, 0, "u 'TRefArray' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Compress",844,G__G__Cont_166_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Expand",608,G__G__Cont_166_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - newSize", "expand or shrink an array", (void*) NULL, 1);
   G__memfunc_setup("GetEntries",1018,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntriesFast",1416,G__G__Cont_166_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLast",692,G__G__Cont_166_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObjectRef",1172,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 2, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPID",509,G__G__Cont_166_0_19, 85, G__get_linked_tagnum(&G__G__ContLN_TProcessID), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUID",514,G__G__Cont_166_0_20, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - at", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsEmpty",715,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeIterator",1224,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TIterator), -1, 0, 1, 1, 1, 8, "g - 'Bool_t' 0 'kIterForward' dir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFirst",785,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLast",669,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAt",446,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAtAndExpand",1329,G__G__Cont_166_0_27, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAtFree",832,G__G__Cont_166_0_28, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAfter",763,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - after U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBefore",860,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - before U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveAt",803,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("At",181,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - at", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Before",595,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("After",498,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("First",520,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Last",404,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__G__Cont_166_0_38, 85, G__get_linked_tagnum(&G__G__ContLN_TObject), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - at", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LowerBound",1025,G__G__Cont_166_0_39, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IndexOf",685,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLast",704,G__G__Cont_166_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sort",424,G__G__Cont_166_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 'kMaxInt' upto", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BinarySearch",1211,G__G__Cont_166_0_43, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj i - 'Int_t' 0 'kMaxInt' upto", "the TRefArray has to be sorted, -1 == not found !!", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Cont_166_0_44, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TRefArray::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_166_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRefArray::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_166_0_46, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TRefArray::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_166_0_47, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TRefArray::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_166_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_166_0_52, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRefArray::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_166_0_53, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRefArray::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_166_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TRefArray::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_166_0_55, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TRefArray::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TRefArray", 1006, G__G__Cont_166_0_56, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlEintcOallocatorlEintgRsPgR(void) {
   /* vector<int,allocator<int> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR));
   G__memfunc_setup("at",213,G__G__Cont_172_0_1, 105, -1, -1, 1, 1, 1, 1, 0, "h - 'vector<int,allocator<int> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__G__Cont_172_0_2, 117, G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__G__Cont_172_0_3, 117, G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__G__Cont_172_0_4, 117, G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR), G__defined_typename("vector<int,allocator<int> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__G__Cont_172_0_5, 117, G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR), G__defined_typename("vector<int,allocator<int> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__G__Cont_172_0_6, 104, -1, G__defined_typename("vector<int,allocator<int> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__G__Cont_172_0_7, 104, -1, G__defined_typename("vector<int,allocator<int> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__G__Cont_172_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'vector<int,allocator<int> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__G__Cont_172_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'vector<int,allocator<int> >::size_type' 0 - sz i - - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__G__Cont_172_0_10, 104, -1, G__defined_typename("vector<int,allocator<int> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__G__Cont_172_0_11, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Cont_172_0_12, 105, -1, -1, 1, 1, 1, 1, 0, "h - 'vector<int,allocator<int> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<int,allocator<int> >",2602,G__G__Cont_172_0_13, 105, G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<int,allocator<int> >",2602,G__G__Cont_172_0_14, 105, G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR), -1, 0, 2, 1, 1, 0, 
"h - 'vector<int,allocator<int> >::size_type' 0 - n i - - 11 'int()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<int,allocator<int> >",2602,G__G__Cont_172_0_15, 105, G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<int,allocator<int> >",2602,G__G__Cont_172_0_16, 105, G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<int,allocator<int> >::iterator' 'vector<int,allocator<int> >::const_iterator' 10 - first u 'vector<int,allocator<int> >::iterator' 'vector<int,allocator<int> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Cont_172_0_17, 117, G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__G__Cont_172_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'vector<int,allocator<int> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__G__Cont_172_0_19, 105, -1, -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__G__Cont_172_0_20, 105, -1, -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__G__Cont_172_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__G__Cont_172_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Cont_172_0_23, 117, G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<int,allocator<int> >::iterator' - 0 - position i - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Cont_172_0_24, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<int,allocator<int> >::iterator' - 0 - position u 'vector<int,allocator<int> >::iterator' 'vector<int,allocator<int> >::const_iterator' 10 - first "
"u 'vector<int,allocator<int> >::iterator' 'vector<int,allocator<int> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Cont_172_0_25, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<int,allocator<int> >::iterator' - 0 - position h - 'vector<int,allocator<int> >::size_type' 0 - n "
"i - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__G__Cont_172_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__G__Cont_172_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__G__Cont_172_0_28, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<int,allocator<int> >::iterator' - 0 - first u 'vector<int,allocator<int> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__G__Cont_172_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<int,allocator<int> >", 2728, G__G__Cont_172_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlEintcOallocatorlEintgRsPgRcLcLiterator(void) {
   /* vector<int,allocator<int> >::iterator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator));
   G__memfunc_setup("iterator",874,G__G__Cont_173_0_1, 105, G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("iterator",874,G__G__Cont_173_0_2, 105, G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator), -1, 0, 1, 5, 1, 0, "I - 'vector<int,allocator<int> >::iterator::pointer' 11 - __i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__G__Cont_173_0_3, 105, -1, G__defined_typename("vector<int,allocator<int> >::iterator::reference"), 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator->",983,G__G__Cont_173_0_4, 73, -1, G__defined_typename("vector<int,allocator<int> >::iterator::pointer"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Cont_173_0_5, 117, G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Cont_173_0_6, 117, G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Cont_173_0_7, 117, G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Cont_173_0_8, 117, G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Cont_173_0_9, 105, -1, G__defined_typename("vector<int,allocator<int> >::iterator::reference"), 1, 1, 1, 1, 8, "l - 'vector<int,allocator<int> >::iterator::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Cont_173_0_10, 117, G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator), -1, 1, 1, 1, 1, 0, "l - 'vector<int,allocator<int> >::iterator::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+",919,G__G__Cont_173_0_11, 117, G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 8, "l - 'vector<int,allocator<int> >::iterator::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Cont_173_0_12, 117, G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator), -1, 1, 1, 1, 1, 0, "l - 'vector<int,allocator<int> >::iterator::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__G__Cont_173_0_13, 117, G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 8, "l - 'vector<int,allocator<int> >::iterator::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("base",411,G__G__Cont_173_0_14, 73, -1, G__defined_typename("vector<int,allocator<int> >::iterator::pointer"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Cont_173_0_15, 117, G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >::iterator' - 11 - x", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("iterator", 874, G__G__Cont_173_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >::iterator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~iterator", 1000, G__G__Cont_173_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncreverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR(void) {
   /* reverse_iterator<vector<int,allocator<int> >::iterator> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR));
   G__memfunc_setup("reverse_iterator<vector<int,allocator<int> >::iterator>",5447,G__G__Cont_174_0_1, 105, G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("base",411,G__G__Cont_174_0_2, 117, G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 8, "", "explicit", (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__G__Cont_174_0_3, 105, -1, G__defined_typename("reverse_iterator<vector<int,allocator<int> >::iterator>::reference"), 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator->",983,G__G__Cont_174_0_4, 73, -1, G__defined_typename("reverse_iterator<vector<int,allocator<int> >::iterator>::pointer"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Cont_174_0_5, 117, G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Cont_174_0_6, 117, G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR), -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Cont_174_0_7, 117, G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Cont_174_0_8, 117, G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR), -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+",919,G__G__Cont_174_0_9, 117, G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR), -1, 0, 1, 1, 1, 8, "l - 'reverse_iterator<vector<int,allocator<int> >::iterator>::difference_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Cont_174_0_10, 117, G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR), -1, 1, 1, 1, 1, 0, "l - 'reverse_iterator<vector<int,allocator<int> >::iterator>::difference_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__G__Cont_174_0_11, 117, G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR), -1, 0, 1, 1, 1, 8, "l - 'reverse_iterator<vector<int,allocator<int> >::iterator>::difference_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Cont_174_0_12, 117, G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR), -1, 1, 1, 1, 1, 0, "l - 'reverse_iterator<vector<int,allocator<int> >::iterator>::difference_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Cont_174_0_13, 105, -1, G__defined_typename("reverse_iterator<vector<int,allocator<int> >::iterator>::reference"), 1, 1, 1, 1, 8, "l - 'reverse_iterator<vector<int,allocator<int> >::iterator>::difference_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("reverse_iterator<vector<int,allocator<int> >::iterator>", 5447, G__G__Cont_174_0_14, (int) ('i'), 
G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR), -1, 0, 1, 1, 1, 0, "u 'reverse_iterator<vector<int,allocator<int> >::iterator>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~reverse_iterator<vector<int,allocator<int> >::iterator>", 5573, G__G__Cont_174_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Cont_174_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR), -1, 1, 1, 1, 1, 0, "u 'reverse_iterator<vector<int,allocator<int> >::iterator>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSortedList(void) {
   /* TSortedList */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ContLN_TSortedList));
   G__memfunc_setup("TSortedList",1121,G__G__Cont_176_0_1, 105, G__get_linked_tagnum(&G__G__ContLN_TSortedList), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kSortAscending' order", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsSorted",813,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFirst",785,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFirst",785,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLast",669,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLast",669,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAt",446,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAfter",763,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - - U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAfter",763,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObjLink' - 0 - - U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBefore",860,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - - U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBefore",860,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObjLink' - 0 - - U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sort",424,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kSortAscending' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Cont_176_0_15, 85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSortedList::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Cont_176_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSortedList::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Cont_176_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSortedList::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Cont_176_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSortedList::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ContLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Cont_176_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Cont_176_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSortedList::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Cont_176_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSortedList::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Cont_176_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSortedList::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Cont_176_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSortedList::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSortedList", 1247, G__G__Cont_176_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}


/*********************************************************
* Member function information setup
*********************************************************/
extern "C" void G__cpp_setup_memfuncG__Cont() {
}

/*********************************************************
* 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__memvar_setup((void*)(&kIterForward),103,0,1,-1,G__defined_typename("Bool_t"),-1,1,"kIterForward=",0,(char*)NULL);
   G__memvar_setup((void*)(&kIterBackward),103,0,1,-1,G__defined_typename("Bool_t"),-1,1,"kIterBackward=",0,(char*)NULL);
   G__memvar_setup((void*)(&gClassTable),85,0,0,G__get_linked_tagnum(&G__G__ContLN_TClassTable),-1,-1,1,"gClassTable=",0,(char*)NULL);
}

static void G__cpp_setup_global2() {
   G__memvar_setup((void*)(&gObjectTable),85,0,0,G__get_linked_tagnum(&G__G__ContLN_TObjectTable),-1,-1,1,"gObjectTable=",0,(char*)NULL);
}

static void G__cpp_setup_global3() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__Cont() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
  G__cpp_setup_global3();
}

/*********************************************************
* 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() {
   G__memfunc_setup("operator&", 914, G__G__Cont__0_298, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TBits::TReference' - 11 - lhs u 'TBits::TReference' - 11 - rhs", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator|", 1000, G__G__Cont__0_299, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TBits::TReference' - 11 - lhs u 'TBits::TReference' - 11 - rhs", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator^", 970, G__G__Cont__0_300, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TBits::TReference' - 11 - lhs u 'TBits::TReference' - 11 - rhs", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator&", 914, G__G__Cont__0_301, 117, G__get_linked_tagnum(&G__G__ContLN_TBits), -1, 0, 2, 1, 1, 0, 
"u 'TBits' - 11 - lhs u 'TBits' - 11 - rhs", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator|", 1000, G__G__Cont__0_302, 117, G__get_linked_tagnum(&G__G__ContLN_TBits), -1, 0, 2, 1, 1, 0, 
"u 'TBits' - 11 - lhs u 'TBits' - 11 - rhs", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator^", 970, G__G__Cont__0_303, 117, G__get_linked_tagnum(&G__G__ContLN_TBits), -1, 0, 2, 1, 1, 0, 
"u 'TBits' - 11 - lhs u 'TBits' - 11 - rhs", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<<", 996, G__G__Cont__0_304, 117, G__get_linked_tagnum(&G__G__ContLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os u 'TBits' - 11 - rhs", (char*) NULL
, (void*) NULL, 0);
}

static void G__cpp_setup_func3() {
}

static void G__cpp_setup_func4() {
}

static void G__cpp_setup_func5() {
   G__memfunc_setup("operator==", 998, G__G__Cont__0_509, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<int,allocator<int> >::iterator' - 11 - x u 'vector<int,allocator<int> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Cont__0_510, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<int,allocator<int> >::iterator' - 11 - x u 'vector<int,allocator<int> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<", 936, G__G__Cont__0_511, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<int,allocator<int> >::iterator' - 11 - x u 'vector<int,allocator<int> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>", 938, G__G__Cont__0_512, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<int,allocator<int> >::iterator' - 11 - x u 'vector<int,allocator<int> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<=", 997, G__G__Cont__0_513, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<int,allocator<int> >::iterator' - 11 - x u 'vector<int,allocator<int> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>=", 999, G__G__Cont__0_514, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<int,allocator<int> >::iterator' - 11 - x u 'vector<int,allocator<int> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Cont__0_515, 108, -1, G__defined_typename("difference_type"), 0, 2, 1, 1, 8, 
"u 'vector<int,allocator<int> >::iterator' - 11 - x u 'vector<int,allocator<int> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Cont__0_516, 117, G__get_linked_tagnum(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 8, 
"l - 'difference_type' 10 - x u 'vector<int,allocator<int> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator==", 998, G__G__Cont__0_517, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'reverse_iterator<vector<int,allocator<int> >::iterator>' 'reverse_iterator' 11 - x u 'reverse_iterator<vector<int,allocator<int> >::iterator>' 'reverse_iterator' 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Cont__0_518, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'reverse_iterator<vector<int,allocator<int> >::iterator>' 'reverse_iterator' 11 - x u 'reverse_iterator<vector<int,allocator<int> >::iterator>' 'reverse_iterator' 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator==", 998, G__G__Cont__0_519, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<int,allocator<int> >' - 11 - x u 'vector<int,allocator<int> >' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<", 936, G__G__Cont__0_520, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<int,allocator<int> >' - 11 - x u 'vector<int,allocator<int> >' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Cont__0_521, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<int,allocator<int> >' - 11 - x u 'vector<int,allocator<int> >' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>", 938, G__G__Cont__0_522, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<int,allocator<int> >' - 11 - x u 'vector<int,allocator<int> >' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>=", 999, G__G__Cont__0_523, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<int,allocator<int> >' - 11 - x u 'vector<int,allocator<int> >' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<=", 997, G__G__Cont__0_524, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<int,allocator<int> >' - 11 - x u 'vector<int,allocator<int> >' - 11 - y", (char*) NULL
, (void*) NULL, 0);

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__Cont() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
  G__cpp_setup_func5();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__ContLN_type_info = { "type_info" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TVirtualCollectionProxy = { "TVirtualCollectionProxy" , 99 , -1 };
G__linked_taginfo G__G__ContLN_ROOT = { "ROOT" , 110 , -1 };
G__linked_taginfo G__G__ContLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__ContLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__ContLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TList = { "TList" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TBrowser = { "TBrowser" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TObjArray = { "TObjArray" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TProcessID = { "TProcessID" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TClonesArray = { "TClonesArray" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TRefTable = { "TRefTable" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TStreamerInfoActions = { "TStreamerInfoActions" , 110 , -1 };
G__linked_taginfo G__G__ContLN_TStreamerInfoActionscLcLTActionSequence = { "TStreamerInfoActions::TActionSequence" , 99 , -1 };
G__linked_taginfo G__G__ContLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__ContLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TArray = { "TArray" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TArrayC = { "TArrayC" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TArrayD = { "TArrayD" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TArrayF = { "TArrayF" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TArrayI = { "TArrayI" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TArrayL64 = { "TArrayL64" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TArrayL = { "TArrayL" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TArrayS = { "TArrayS" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TBits = { "TBits" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TBitscLcLTReference = { "TBits::TReference" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TCollection = { "TCollection" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TIterator = { "TIterator" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TPRegexp = { "TPRegexp" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TObjectTable = { "TObjectTable" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TCollectioncLcLdA = { "TCollection::$" , 101 , -1 };
G__linked_taginfo G__G__ContLN_TIter = { "TIter" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TSeqCollection = { "TSeqCollection" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TBtNode = { "TBtNode" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TBtreeIter = { "TBtreeIter" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TBtree = { "TBtree" , 99 , -1 };
G__linked_taginfo G__G__ContLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__ContLN_TClassRec = { "TClassRec" , 99 , -1 };
G__linked_taginfo G__G__ContLN_ROOTcLcLTMapTypeToClassRec = { "ROOT::TMapTypeToClassRec" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TClassTable = { "TClassTable" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TClassTablecLcLdA = { "TClassTable::$" , 101 , -1 };
G__linked_taginfo G__G__ContLN_TObjArrayIter = { "TObjArrayIter" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TClonesArraycLcLdA = { "TClonesArray::$" , 101 , -1 };
G__linked_taginfo G__G__ContLN_vectorlEboolcOallocatorlEboolgRsPgR = { "vector<bool,allocator<bool> >" , 99 , -1 };
G__linked_taginfo G__G__ContLN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<bool,allocator<bool> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TExMapIter = { "TExMapIter" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TExMap = { "TExMap" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TExMapcLcLAssoc_t = { "TExMap::Assoc_t" , 115 , -1 };
G__linked_taginfo G__G__ContLN_TObjLink = { "TObjLink" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TListIter = { "TListIter" , 99 , -1 };
G__linked_taginfo G__G__ContLN_THashTable = { "THashTable" , 99 , -1 };
G__linked_taginfo G__G__ContLN_THashList = { "THashList" , 99 , -1 };
G__linked_taginfo G__G__ContLN_THashTableIter = { "THashTableIter" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TMapIter = { "TMapIter" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TPair = { "TPair" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TMap = { "TMap" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TMapcLcLdA = { "TMap::$" , 101 , -1 };
G__linked_taginfo G__G__ContLN_TOrdCollectionIter = { "TOrdCollectionIter" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TOrdCollection = { "TOrdCollection" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TOrdCollectioncLcLdA = { "TOrdCollection::$" , 101 , -1 };
G__linked_taginfo G__G__ContLN_TRefArrayIter = { "TRefArrayIter" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TRefArray = { "TRefArray" , 99 , -1 };
G__linked_taginfo G__G__ContLN_vectorlEstringcOallocatorlEstringgRsPgR = { "vector<string,allocator<string> >" , 99 , -1 };
G__linked_taginfo G__G__ContLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<string,allocator<string> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR = { "vector<int,allocator<int> >" , 99 , -1 };
G__linked_taginfo G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator = { "vector<int,allocator<int> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<int,allocator<int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TRefTablecLcLdA = { "TRefTable::$" , 101 , -1 };
G__linked_taginfo G__G__ContLN_TSortedList = { "TSortedList" , 99 , -1 };
G__linked_taginfo G__G__ContLN_TClassRef = { "TClassRef" , 99 , -1 };
G__linked_taginfo G__G__ContLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR = { "map<string,TObjArray*,less<string>,allocator<pair<const string,TObjArray*> > >" , 99 , -1 };
G__linked_taginfo G__G__ContLN_EDataType = { "EDataType" , 101 , -1 };
G__linked_taginfo G__G__ContLN_TVirtualCollectionProxycLcLEProperty = { "TVirtualCollectionProxy::EProperty" , 101 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__Cont() {
  G__G__ContLN_type_info.tagnum = -1 ;
  G__G__ContLN_TClass.tagnum = -1 ;
  G__G__ContLN_TBuffer.tagnum = -1 ;
  G__G__ContLN_TMemberInspector.tagnum = -1 ;
  G__G__ContLN_TObject.tagnum = -1 ;
  G__G__ContLN_TString.tagnum = -1 ;
  G__G__ContLN_TVirtualCollectionProxy.tagnum = -1 ;
  G__G__ContLN_ROOT.tagnum = -1 ;
  G__G__ContLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__ContLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__ContLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__ContLN_TList.tagnum = -1 ;
  G__G__ContLN_TBrowser.tagnum = -1 ;
  G__G__ContLN_TObjArray.tagnum = -1 ;
  G__G__ContLN_TProcessID.tagnum = -1 ;
  G__G__ContLN_TClonesArray.tagnum = -1 ;
  G__G__ContLN_TRefTable.tagnum = -1 ;
  G__G__ContLN_TStreamerInfoActions.tagnum = -1 ;
  G__G__ContLN_TStreamerInfoActionscLcLTActionSequence.tagnum = -1 ;
  G__G__ContLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__ContLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__ContLN_TArray.tagnum = -1 ;
  G__G__ContLN_TArrayC.tagnum = -1 ;
  G__G__ContLN_TArrayD.tagnum = -1 ;
  G__G__ContLN_TArrayF.tagnum = -1 ;
  G__G__ContLN_TArrayI.tagnum = -1 ;
  G__G__ContLN_TArrayL64.tagnum = -1 ;
  G__G__ContLN_TArrayL.tagnum = -1 ;
  G__G__ContLN_TArrayS.tagnum = -1 ;
  G__G__ContLN_TBits.tagnum = -1 ;
  G__G__ContLN_TBitscLcLTReference.tagnum = -1 ;
  G__G__ContLN_TCollection.tagnum = -1 ;
  G__G__ContLN_TIterator.tagnum = -1 ;
  G__G__ContLN_TPRegexp.tagnum = -1 ;
  G__G__ContLN_TObjectTable.tagnum = -1 ;
  G__G__ContLN_TCollectioncLcLdA.tagnum = -1 ;
  G__G__ContLN_TIter.tagnum = -1 ;
  G__G__ContLN_TSeqCollection.tagnum = -1 ;
  G__G__ContLN_TBtNode.tagnum = -1 ;
  G__G__ContLN_TBtreeIter.tagnum = -1 ;
  G__G__ContLN_TBtree.tagnum = -1 ;
  G__G__ContLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__ContLN_TClassRec.tagnum = -1 ;
  G__G__ContLN_ROOTcLcLTMapTypeToClassRec.tagnum = -1 ;
  G__G__ContLN_TClassTable.tagnum = -1 ;
  G__G__ContLN_TClassTablecLcLdA.tagnum = -1 ;
  G__G__ContLN_TObjArrayIter.tagnum = -1 ;
  G__G__ContLN_TClonesArraycLcLdA.tagnum = -1 ;
  G__G__ContLN_vectorlEboolcOallocatorlEboolgRsPgR.tagnum = -1 ;
  G__G__ContLN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__ContLN_TExMapIter.tagnum = -1 ;
  G__G__ContLN_TExMap.tagnum = -1 ;
  G__G__ContLN_TExMapcLcLAssoc_t.tagnum = -1 ;
  G__G__ContLN_TObjLink.tagnum = -1 ;
  G__G__ContLN_TListIter.tagnum = -1 ;
  G__G__ContLN_THashTable.tagnum = -1 ;
  G__G__ContLN_THashList.tagnum = -1 ;
  G__G__ContLN_THashTableIter.tagnum = -1 ;
  G__G__ContLN_TMapIter.tagnum = -1 ;
  G__G__ContLN_TPair.tagnum = -1 ;
  G__G__ContLN_TMap.tagnum = -1 ;
  G__G__ContLN_TMapcLcLdA.tagnum = -1 ;
  G__G__ContLN_TOrdCollectionIter.tagnum = -1 ;
  G__G__ContLN_TOrdCollection.tagnum = -1 ;
  G__G__ContLN_TOrdCollectioncLcLdA.tagnum = -1 ;
  G__G__ContLN_TRefArrayIter.tagnum = -1 ;
  G__G__ContLN_TRefArray.tagnum = -1 ;
  G__G__ContLN_vectorlEstringcOallocatorlEstringgRsPgR.tagnum = -1 ;
  G__G__ContLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR.tagnum = -1 ;
  G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__ContLN_TRefTablecLcLdA.tagnum = -1 ;
  G__G__ContLN_TSortedList.tagnum = -1 ;
  G__G__ContLN_TClassRef.tagnum = -1 ;
  G__G__ContLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR.tagnum = -1 ;
  G__G__ContLN_EDataType.tagnum = -1 ;
  G__G__ContLN_TVirtualCollectionProxycLcLEProperty.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__Cont() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__ContLN_type_info);
   G__get_linked_tagnum_fwd(&G__G__ContLN_TClass);
   G__get_linked_tagnum_fwd(&G__G__ContLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__ContLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__ContLN_TObject);
   G__get_linked_tagnum_fwd(&G__G__ContLN_TString);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TVirtualCollectionProxy),sizeof(TVirtualCollectionProxy),-1,102167,(char*)NULL,G__setup_memvarTVirtualCollectionProxy,G__setup_memfuncTVirtualCollectionProxy);
   G__get_linked_tagnum_fwd(&G__G__ContLN_ROOT);
   G__get_linked_tagnum_fwd(&G__G__ContLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__ContLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__ContLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TList),sizeof(TList),-1,130816,"Doubly linked list",G__setup_memvarTList,G__setup_memfuncTList);
   G__get_linked_tagnum_fwd(&G__G__ContLN_TBrowser);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TObjArray),sizeof(TObjArray),-1,98048,"An array of objects",G__setup_memvarTObjArray,G__setup_memfuncTObjArray);
   G__get_linked_tagnum_fwd(&G__G__ContLN_TProcessID);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TClonesArray),sizeof(TClonesArray),-1,130816,"An array of clone objects",G__setup_memvarTClonesArray,G__setup_memfuncTClonesArray);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TRefTable),sizeof(TRefTable),-1,128256,"Table of referenced objects during an I/O operation",G__setup_memvarTRefTable,G__setup_memfuncTRefTable);
   G__get_linked_tagnum_fwd(&G__G__ContLN_TStreamerInfoActions);
   G__get_linked_tagnum_fwd(&G__G__ContLN_TStreamerInfoActionscLcLTActionSequence);
   G__get_linked_tagnum_fwd(&G__G__ContLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__ContLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TArray),sizeof(TArray),-1,167683,"Abstract array base class",G__setup_memvarTArray,G__setup_memfuncTArray);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TArrayC),sizeof(TArrayC),-1,233216,"Array of chars",G__setup_memvarTArrayC,G__setup_memfuncTArrayC);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TArrayD),sizeof(TArrayD),-1,233216,"Array of doubles",G__setup_memvarTArrayD,G__setup_memfuncTArrayD);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TArrayF),sizeof(TArrayF),-1,233216,"Array of floats",G__setup_memvarTArrayF,G__setup_memfuncTArrayF);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TArrayI),sizeof(TArrayI),-1,233216,"Array of ints",G__setup_memvarTArrayI,G__setup_memfuncTArrayI);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TArrayL64),sizeof(TArrayL64),-1,233216,"Array of long64s",G__setup_memvarTArrayL64,G__setup_memfuncTArrayL64);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TArrayL),sizeof(TArrayL),-1,233216,"Array of longs",G__setup_memvarTArrayL,G__setup_memfuncTArrayL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TArrayS),sizeof(TArrayS),-1,233216,"Array of shorts",G__setup_memvarTArrayS,G__setup_memfuncTArrayS);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TBits),sizeof(TBits),-1,294656,"Bit container",G__setup_memvarTBits,G__setup_memfuncTBits);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TBitscLcLTReference),sizeof(TBits::TReference),-1,101632,(char*)NULL,G__setup_memvarTBitscLcLTReference,G__setup_memfuncTBitscLcLTReference);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TCollection),sizeof(TCollection),-1,98054,"Collection abstract base class",G__setup_memvarTCollection,G__setup_memfuncTCollection);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TIterator),sizeof(TIterator),-1,3843,"Iterator abstract base class",G__setup_memvarTIterator,G__setup_memfuncTIterator);
   G__get_linked_tagnum_fwd(&G__G__ContLN_TPRegexp);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TObjectTable),sizeof(TObjectTable),-1,32512,"Table of active objects",G__setup_memvarTObjectTable,G__setup_memfuncTObjectTable);
   G__get_linked_tagnum_fwd(&G__G__ContLN_TCollectioncLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TIter),sizeof(TIter),-1,36608,"Iterator wrapper",G__setup_memvarTIter,G__setup_memfuncTIter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TSeqCollection),sizeof(TSeqCollection),-1,29967,"Sequenceable collection ABC",G__setup_memvarTSeqCollection,G__setup_memfuncTSeqCollection);
   G__get_linked_tagnum_fwd(&G__G__ContLN_TBtNode);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TBtreeIter),sizeof(TBtreeIter),-1,36608,"B-tree iterator",G__setup_memvarTBtreeIter,G__setup_memfuncTBtreeIter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TBtree),sizeof(TBtree),-1,95488,"A B-tree",G__setup_memvarTBtree,G__setup_memfuncTBtree);
   G__get_linked_tagnum_fwd(&G__G__ContLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__get_linked_tagnum_fwd(&G__G__ContLN_TClassRec);
   G__get_linked_tagnum_fwd(&G__G__ContLN_ROOTcLcLTMapTypeToClassRec);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TClassTable),sizeof(TClassTable),-1,29952,"Table of known classes",G__setup_memvarTClassTable,G__setup_memfuncTClassTable);
   G__get_linked_tagnum_fwd(&G__G__ContLN_TClassTablecLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TObjArrayIter),sizeof(TObjArrayIter),-1,36608,"Object array iterator",G__setup_memvarTObjArrayIter,G__setup_memfuncTObjArrayIter);
   G__get_linked_tagnum_fwd(&G__G__ContLN_TClonesArraycLcLdA);
   G__get_linked_tagnum_fwd(&G__G__ContLN_vectorlEboolcOallocatorlEboolgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__ContLN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TExMapIter),sizeof(TExMapIter),-1,36352,"TExMap iterator",G__setup_memvarTExMapIter,G__setup_memfuncTExMapIter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TExMap),sizeof(TExMap),-1,98048,"Map with external hash",G__setup_memvarTExMap,G__setup_memfuncTExMap);
   G__get_linked_tagnum_fwd(&G__G__ContLN_TExMapcLcLAssoc_t);
   G__get_linked_tagnum_fwd(&G__G__ContLN_TObjLink);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TListIter),sizeof(TListIter),-1,36608,"Linked list iterator",G__setup_memvarTListIter,G__setup_memfuncTListIter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_THashTable),sizeof(THashTable),-1,32512,"A hash table",G__setup_memvarTHashTable,G__setup_memfuncTHashTable);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_THashList),sizeof(THashList),-1,65280,"Doubly linked list with hashtable for lookup",G__setup_memvarTHashList,G__setup_memfuncTHashList);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_THashTableIter),sizeof(THashTableIter),-1,36608,"Hash table iterator",G__setup_memvarTHashTableIter,G__setup_memfuncTHashTableIter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TMapIter),sizeof(TMapIter),-1,36608,"Map iterator",G__setup_memvarTMapIter,G__setup_memfuncTMapIter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TPair),sizeof(TPair),-1,65024,"Pair TObject*, TObject*",G__setup_memvarTPair,G__setup_memfuncTPair);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TMap),sizeof(TMap),-1,98048,"A (key,value) map",G__setup_memvarTMap,G__setup_memfuncTMap);
   G__get_linked_tagnum_fwd(&G__G__ContLN_TMapcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TOrdCollectionIter),sizeof(TOrdCollectionIter),-1,36608,"Ordered collection iterator",G__setup_memvarTOrdCollectionIter,G__setup_memfuncTOrdCollectionIter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TOrdCollection),sizeof(TOrdCollection),-1,32512,"An ordered collection",G__setup_memvarTOrdCollection,G__setup_memfuncTOrdCollection);
   G__get_linked_tagnum_fwd(&G__G__ContLN_TOrdCollectioncLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TRefArrayIter),sizeof(TRefArrayIter),-1,36608,"Object array iterator",G__setup_memvarTRefArrayIter,G__setup_memfuncTRefArrayIter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TRefArray),sizeof(TRefArray),-1,130816,"An array of references to TObjects",G__setup_memvarTRefArray,G__setup_memfuncTRefArray);
   G__get_linked_tagnum_fwd(&G__G__ContLN_vectorlEstringcOallocatorlEstringgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__ContLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgR),sizeof(vector<int,allocator<int> >),-1,36608,(char*)NULL,G__setup_memvarvectorlEintcOallocatorlEintgRsPgR,G__setup_memfuncvectorlEintcOallocatorlEintgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator),sizeof(vector<int,allocator<int> >::iterator),-1,35072,(char*)NULL,G__setup_memvarvectorlEintcOallocatorlEintgRsPgRcLcLiterator,G__setup_memfuncvectorlEintcOallocatorlEintgRsPgRcLcLiterator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),sizeof(reverse_iterator<vector<int,allocator<int> >::iterator>),-1,256,(char*)NULL,G__setup_memvarreverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR,G__setup_memfuncreverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__ContLN_TRefTablecLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ContLN_TSortedList),sizeof(TSortedList),-1,61696,"A sorted list",G__setup_memvarTSortedList,G__setup_memfuncTSortedList);
   G__get_linked_tagnum_fwd(&G__G__ContLN_TClassRef);
   G__get_linked_tagnum_fwd(&G__G__ContLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__ContLN_EDataType);
   G__get_linked_tagnum_fwd(&G__G__ContLN_TVirtualCollectionProxycLcLEProperty);
}
extern "C" void G__cpp_setupG__Cont(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__Cont()");
  G__set_cpp_environmentG__Cont();
  G__cpp_setup_tagtableG__Cont();

  G__cpp_setup_inheritanceG__Cont();

  G__cpp_setup_typetableG__Cont();

  G__cpp_setup_memvarG__Cont();

  G__cpp_setup_memfuncG__Cont();
  G__cpp_setup_globalG__Cont();
  G__cpp_setup_funcG__Cont();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__Cont();
  return;
}
class G__cpp_setup_initG__Cont {
  public:
    G__cpp_setup_initG__Cont() { G__add_setup_func("G__Cont",(G__incsetup)(&G__cpp_setupG__Cont)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__Cont() { G__remove_setup_func("G__Cont"); }
};
G__cpp_setup_initG__Cont G__cpp_setup_initializerG__Cont;

---